Image Classifier with PyTorch
Train a convolutional neural network (CNN) in PyTorch to recognize what's in small photos, using a dataset such as CIFAR-10 (airplanes, cars, birds, cats and six more classes). You'll load the images with torchvision, add data augmentation (random flips and crops) so the model generalizes better, design the network, write the training loop yourself, and track training and validation accuracy to spot overfitting. The model runs on a GPU when available, saves checkpoints so training can resume, and is evaluated with a confusion matrix showing which classes it confuses. You'll learn the full deep learning workflow: datasets and data loaders, CNN layers, loss functions and optimizers, the training loop, evaluation, and checkpointing.
- Estimate
- ~11.5h
- Steps
- 6
- Completed by
- 0
- Proposed by
- codeseed.app
PyTorch · torchvision
Project roadmap
- 01
Prepare the data
~2hLoad CIFAR-10 with torchvision.datasets, split the training set into training and validation parts (for example 45,000 and 5,000) with a fixed seed, and create DataLoaders. Normalize images with the dataset's channel means and standard deviations, and add augmentation (RandomCrop with padding and RandomHorizontalFlip) to the training set only. Show a grid of sample images with their labels. Done when: the loaders return batches of the right shape, and the sample grid looks correct.
- 02
Define the network
~1.5hBuild a CNN as an nn.Module: a few blocks of convolution, batch normalization, ReLU and max pooling, then dropout and a fully connected layer with 10 outputs. Print the number of parameters and check the output shape with a dummy batch. Done when: a dummy batch passes through the model and returns 10 scores per image.
- 03
Write the training loop
~2.5hWrite the loop yourself: move data and model to the GPU if available (or Apple's mps, or the CPU), compute the cross-entropy loss, call backward and the optimizer step (SGD with momentum, or Adam), and use a learning rate schedule. After each epoch, evaluate on the validation set (with model.eval() and torch.no_grad()) and print the loss and accuracy for both. Done when: training runs for several epochs, and validation accuracy rises well above chance (10%).
- 04
Evaluate and visualize
~2hPlot training and validation loss and accuracy per epoch with matplotlib, and explain what the curves say about overfitting. Evaluate the best model on the test set, compute a confusion matrix and per-class accuracy (with scikit-learn), and show a few misclassified images. Record the results in README.md. Done when: README.md shows the curves, test accuracy and the most confused classes.
- 05
Save checkpoints and predict
~1.5hSave a checkpoint each epoch with the model's and optimizer's state, the epoch and the best validation accuracy, keeping the best one separately. Add a --resume option that continues training from a checkpoint. Write a predict.py script that loads the best model and classifies an image file, printing the top 3 classes with probabilities. Done when: training can stop and resume, and predict.py classifies new images.
- 06
Improve and compare
~2hTry at least two changes (for example a deeper network, different augmentation, or a pretrained ResNet from torchvision fine-tuned on CIFAR-10) with the same seed and number of epochs, and compare their validation and test accuracy in README.md. Done when: README.md compares the experiments and explains which change helped.
Ready to build this?
Get a GitHub repo and start building. Your AI reviewer checks each step as you go.
Tech stack