PyTorch
Build · Data
Train neural networks and inspect the data, loss and predictions at each stage.
All capabilities · Machine learning & data science
Build and train neural networks in PyTorch
Tensors, autograd, training loops, transfer learning, GPU usage.
Explore 3 tools for this projectMarket relevance
Which roles ask for this — and how often
Share of job postings in India, per role, that name this capability.
What employers mean
You should be able to…
- Write a training loop from scratch: forward pass, loss, backward, optimizer step
- Use PyTorch tensors, autograd and nn.Module correctly (not just call .fit())
- Load data efficiently with Dataset/DataLoader, including batching and augmentation
- Do transfer learning: fine-tune a pretrained model (ResNet, ViT) on a new dataset
- Debug a network that isn't learning (loss not decreasing, exploding/vanishing gradients)
- Use a GPU correctly (device placement, mixed precision) and know when it isn't helping
- Track experiments (loss curves, learning rate schedules) and know when to stop training
Needs first: Train and evaluate classical ML models
Learn — free, link-checked
The few resources that matter
Read · beginner · 60 min · pytorch.org
Deep Learning with PyTorch: A 60 Minute Blitz
Official tutorial that gets you from tensors to autograd to a trained CNN in one sitting -- the fastest legitimate path to a working training loop. — PyTorch
Watch · beginner · 70 min · youtube.com
Neural networks
The visual explanation of backpropagation that lets you actually answer 'walk me through how a network learns' instead of reciting the chain rule. — 3Blue1Brown
Read · beginner · 90 min · pytorch.org
Learn the Basics
Slower-paced official walkthrough of Datasets/DataLoaders, autograd, optimization and model saving -- fills the gaps the 60-minute blitz skips. — PyTorch
Course · intermediate · 1200 min · course.fast.ai
Practical Deep Learning for Coders
Top-down, code-first course (free videos + notebooks) that gets you to a fine-tuned, deployed image classifier before it explains the underlying math. — fast.ai
Tools for practice
Choose a tool for the job
Start with one tool for each part of your project. You don’t need to learn them all.
3 tools to explore
TensorBoard
Monitor · Test
Visualise training curves and compare runs while debugging a model.
Google Colab
Code · Data
Share a runnable notebook for an experiment, tutorial or classroom exercise.
Practice
Devanagari handwriting classifier: from-scratch CNN vs transfer learning
Train a CNN in PyTorch to classify handwritten Devanagari characters using the UCI Devanagari Handwritten Character Dataset — 92,000 labelled 32×32 images across 46 characters — writing the Dataset, DataLoader and training loop yourself rather than calling a trainer. Then fine-tune a pretrained ResNet on the same split. Compare the two on accuracy, training time and data efficiency by retraining both on 10%, 50% and 100% of the training set, logging every run so the curves are comparable.
Start from
Milestones
- Write the Dataset/DataLoader with augmentation and visualise a real batch · ~9h
- Hand-write the training loop and train the from-scratch CNN to convergence · ~11h
- Fine-tune a pretrained ResNet on the same split, logging both runs to TensorBoard · ~9h
- Run the data-efficiency sweep (10% / 50% / 100% of train) and write it up · ~7.5h
Done when
- Custom PyTorch Dataset/DataLoader with augmentation (rotation, noise) implemented
- Training loop written manually (no high-level trainer library) with visible loss/accuracy curves
- From-scratch CNN and fine-tuned pretrained model both trained and compared on the same test split
- README states final test accuracy for both, and explains the tradeoff observed
Prove it
Evidence a recruiter can check
- Loss and accuracy curves for both runs on shared axes, with the epoch where the from-scratch model starts overfitting marked
- A data-efficiency table: test accuracy for both models trained on 10%, 50% and 100% of the training set
- A confusion matrix that names the character pairs the model actually mixes up, not just an overall number
- A runnable checkpoint plus a ten-line inference snippet that classifies a character you wrote and photographed yourself
Signal it
Trained a Devanagari handwriting classifier in PyTorch with a hand-written training loop — from-scratch CNN benchmarked against a fine-tuned ResNet across 10/50/100% training-data slices to quantify what transfer learning is actually worth.
Interview
Questions you'll get asked
- Explain what autograd does and how backpropagation actually computes gradients
- Your training loss is decreasing but validation loss is increasing -- what's happening and what do you do?
- Why would you use transfer learning instead of training from scratch?
- What's the effect of learning rate being too high vs too low? How do you find a good one?
- Explain batch normalization and why it helps training
- How do you handle a dataset that doesn't fit in GPU memory?
- Walk me through the shape of tensors flowing through a simple CNN