Train and test an image classifier with PyTorch

Learn in your browser · Chapter 01 of 06

Choose the prediction, independence unit and evidence you will preserve. A tiny image task can teach a complete experiment without representing a real camera system.

The original MICKAI Pixel Workshop classifies an 8 by 8 greyscale array as vertical, horizontal or cross. Labels are integers 0, 1 and 2 in that order. A prediction concerns one array, not a person or an entire source group. Every pixel is generated by the supplied Python program; there are no photographs, personal records, external datasets or pretrained weights. The purpose is to train and challenge a small convolutional classifier while keeping every data and evaluation decision visible.

Begin with Tensors, gradients and a first training loop, available as tensors-gradients-training-loop. That course explains tensor arithmetic, differentiation and the generic update cycle. Here those ideas become a spatial input contract, grouped image split and an end-to-end classifier experiment. Transformers: attention explained and implemented concerns forward attention, while Build a tiny language model from scratch trains a character model. Those are useful related paths, not missing chapters to repeat here. This course concentrates on convolution and image evaluation.

Write the experiment contract before looking for an impressive score. The output is one of three known pattern classes. The data source is this fixed synthetic generator, the model runs on CPU, and the primary validation criterion is mean cross-entropy loss. Use 16 epochs, batch size 18, learning rate 0.03 and the documented model seed. Select the lowest clean validation loss, keeping the earliest epoch on an exact tie. These are exercise choices to inspect, not recommended settings for every image problem. The four-hour study estimate is unpiloted; record actual learner time separately.

Give the three splits different jobs. Training examples supply parameter updates and fitted preprocessing statistics. Validation examples support the predeclared model-selection rule and diagnostic analysis. The final test is opened only after the selected checkpoint, class order and preprocessing are frozen. Calling a dataset test does not protect it if its results guide repeated changes. The separate fit and test commands make the intended sequence reviewable; they are educational guards, not an access-control system preventing a learner from reading files.

Establish a baseline that requires no learned image features. Count labels in the training split and always predict its most frequent class, resolving a balanced tie with the smallest class index. All three training classes have 36 images, so the baseline predicts vertical. It gets 12 of the 36 balanced validation images correct. That is a 33.3 percent reference for this task, not a universal chance level or a useful classifier. Preserve it so that a trained model must demonstrate more than an attractive training curve.

The author tested Python 3.12.10 and the official Windows CPU wheel torch 2.14.1+cpu. The PyTorch release page identified v2.14.1 and its 2.14 API documentation was checked on 26 October 2026. The exact wheel hash and dependency versions are recorded separately. No CUDA build, GPU, torchvision, account or model API is used. Installation downloads packages, but generating data and running the exercise afterward needs no network. Other platforms or versions require their own installation and execution check. [S2] [S3]

NVIDIA publishes its separate Fundamentals of Deep Learning course, including convolution and other topics. Its repository was consulted to understand the requested learning area, not to obtain this manuscript, code, dataset, notebook or assessment. This is an original, narrower MICKAI CPU exercise. It does not reproduce the full NVIDIA programme, teach all its modules or award its credential. Keep the provenance statement with the experiment record so an educational result cannot be mistaken for NVIDIA affiliation, accreditation or professional deployment approval. [S1]

Learn in your browser · Chapter 02 of 06

Protect the evaluation boundary before turning lists into tensors. Correlated views and fitted preprocessing can leak information even when filenames differ.

The generator creates 30 independent synthetic base drawings for each of three classes. Each base has its own seeded pixel values and a stroke position, then produces two related noisy views. A source group identifies that base; two view IDs identify its children. Both views of a group must stay together. Different view filenames do not make them independent observations. The drawings still share a deliberately simple generator and pattern family, so disjoint groups do not turn this exercise into evidence about arbitrary real-world images.

Group numbers 0 through 17 belong to training, 18 through 23 to validation and 24 through 29 to final test, separately within each class. That gives 54 training groups and 108 images, 18 validation groups and 36 images, and 18 test groups and 36 images. The split is assigned before view noise is generated. Changing a view seed cannot repair a group appearing in two splits. The manifest-level disjointness check can run without constructing or inspecting final-test pixel arrays.

The tensor contract is N, C, H, W: batch size, channel count, height and width. A full training tensor has shape 108, 1, 8, 8 and float32 values. Integer targets have shape 108 and dtype torch.long, with values 0 through 2. The channel dimension is present even for greyscale. A tensor with dimensions 108, 8, 8 has lost that declared axis; simply having 64 numbers per image does not establish the shape consumed by the network.

Validate source data before creating a promising curve. Each image must have a unique ID, an integer label in the known class range and exactly 64 finite numeric pixels between zero and one. Reject a missing pixel, NaN or a fractional class label. Do not silently replace malformed values and retain the old experiment identity. A repair changes the input and requires a new recorded comparison. These checks protect the declared synthetic contract; they do not verify that a real image was correctly labelled or ethically obtained.

Compute one scalar mean and population standard deviation from training pixels only. The code uses unbiased=False for that standard deviation and clamps it away from zero. Apply the same stored statistics to validation and final test. Pixels already lie between zero and one; they are not byte values needing another division by 255. Fitting statistics on all splits lets evaluation inputs influence preprocessing. Refitting on a future batch also changes the model interface even when learned weights are unchanged.

Treat augmentation as a data-generation decision with a label meaning. In this lab the two small-noise views are generated after group assignment and preserve the underlying label. A ninety-degree rotation would exchange a vertical bar and a horizontal bar, so retaining their old labels would corrupt supervision. The supplied exercise does not use rotation or borrow an image augmentation library. When extending it, state which transformation preserves each label and keep derived views within the source group rather than re-splitting them as new examples.

Use group IDs, image IDs and payload digests for different questions. Group IDs expose a correlated-source overlap. Image IDs detect accidental repeated rows. A SHA-256 payload digest binds the generated records and labels that were checked. Two differently named files can still contain related or identical input, while a changed digest does not identify a changed label by itself. Preserve the generator, split rule and seed as well as the digest so another reviewer can reconstruct the precise dataset rather than merely trust its filename.

Learn in your browser · Chapter 03 of 06

Trace dimensions and the loss interface. A model with only 235 learned values is large enough for the toy task and small enough to inspect.

TinyCNN begins with Conv2d from one input channel to four output channels, using a 3 by 3 kernel and padding one. With default stride one, an 8 by 8 image keeps its spatial size. The batch therefore becomes N, 4, 8, 8. A convolution applies each learned local pattern across spatial positions using shared weights. It does not automatically recognise every translation or make the data split independent. Its useful bias is local feature extraction, which must still be tested on the chosen images. [S4]

ReLU replaces negative activations with zero. Average pooling over non-overlapping 2 by 2 regions halves each spatial dimension, producing N, 4, 4, 4. Flatten preserves the batch dimension and combines those 64 feature values per image. Dropout with probability 0.1 precedes a linear layer from 64 features to three outputs. Pooling and flatten do not invent additional labels; they reshape and summarise features. A wrong flatten boundary can mix examples even if a later matrix multiplication happens to run. [S5]

Count parameters independently of the printed model. Four convolution filters each have one times three times three weights plus a bias: 4 times 10 gives 40. The final linear layer has 64 times 3 weights and 3 biases, giving 195. Total learned parameters are 235. ReLU, average pooling, flatten and dropout add no learned parameters here. A larger count or a different output shape indicates that the executable architecture differs from the workbook; resolve that mismatch before comparing results.

The three outputs are logits, one score per class, not an image and not necessarily probabilities. Feed raw logits of shape N, 3 and integer targets of shape N to CrossEntropyLoss. Do not insert a softmax before this loss in the supplied model. For zero logits and a valid one-class target the loss is log(3), approximately 1.099, because the classes have equal probability under the loss calculation. Class-index targets use torch.long; probability-target alternatives are a different interface not used here. [S6]

For a prediction, argmax over the class dimension selects the highest logit. It returns a class index interpreted using the saved order vertical, horizontal, cross. Normalising logits with softmax would not change this argmax for ordinary finite scores, but it would not make the resulting number a calibrated confidence guarantee. A prediction can be wrong with a large score gap. Preserve raw counts and record IDs for error analysis instead of describing a confident score as an independently verified label.

Mean loss and accuracy answer different questions. Accuracy counts correct predicted classes divided by evaluated images. Cross-entropy also responds to how strongly the scores favour the correct target. Two checkpoints can have equal accuracy but different mean loss. The predeclared selection rule uses clean validation loss, so do not switch to whichever metric favours a preferred epoch after seeing the curve. Report the majority baseline alongside the learned result using the same image population, label order and evaluation definition.

When aggregating batch losses, weight each mean by its batch image count, add those totals and divide by total images. If a last batch has six images while earlier batches have eighteen, averaging batch means equally gives the smaller batch disproportionate influence. The supplied loop records an image-weighted training mean across updates. Its training-time dropout and changing weights mean this number is not identical to evaluating the selected fixed checkpoint on all training images afterward. Label these two quantities separately.

logits = model(images)  # [N, 3], raw scores
loss = torch.nn.functional.cross_entropy(logits, labels)
predicted_class = logits.argmax(dim=1)

Learn in your browser · Chapter 04 of 06

Keep parameter updates and model selection separate. Record the executable sequence instead of relying on an attractive screenshot.

The training loader uses batch size 18, shuffles training examples with a seeded generator and uses zero worker processes. One epoch visits 108 training images in six batches. Sixteen fixed epochs therefore perform 96 optimiser steps. Shuffling changes update order without moving a record into a different split. A DataLoader provides batches, not a guarantee of correct labels or independent evaluation. The explicit CPU path avoids multiprocessing setup and GPU transfer issues while you inspect the experiment. [S7]

At each training batch, use train mode, clear previous gradients with optimiser.zero_grad(set_to_none=True), run the forward pass, compute scalar loss, call backward and then optimiser.step(). The supplied code sets train mode once at the epoch start and keeps it active for its batches. Clearing gradients matters because backward otherwise accumulates them. Backward alone computes gradients without applying an update. An optimiser step before those gradients exist cannot substitute for the intended learning sequence. Check the complete order when a loss refuses to change.

After an epoch, validation calls model.eval() and enters torch.inference_mode(). These solve different problems. Evaluation mode changes layers such as dropout; inference mode disables autograd work for that evaluation. Inference mode does not itself switch dropout off. The evaluator performs no backward pass or optimiser step, so validation examples do not train weights. Returning to training requires train mode again. Keeping these transitions explicit prevents a validation function from silently changing the next epoch into the wrong phase. [S8] [S9]

Select the checkpoint with the lowest clean validation loss, not the final loop iteration by habit. Copy its state dictionary with copy.deepcopy when it improves. A live reference to model.state_dict() may continue reflecting later updates instead of preserving earlier best parameters. On an exact loss tie, the strict less-than comparison keeps the earliest checkpoint. The selected epoch is an observation of this run. Record it with the full history rather than treating it as a universal number of epochs for this architecture.

The seed controls model initialisation and loader order, while each synthetic drawing has its own deterministic generation seed. The author also used one CPU thread and deterministic algorithms. PyTorch warns that complete reproducibility is not guaranteed across releases, devices and platforms. Record Python and torch versions, CPU execution, data hashes and settings. If environments disagree, investigate changed inputs or environment before discarding a record. A seed is a useful control; it is not proof that every future machine will produce identical floating-point bytes. [S10]

The author run on 26 October 2026 selected epoch 15 from the fixed 16-epoch schedule. Initial training loss was approximately 1.151; evaluating the selected state on training gave approximately 0.0000182. Clean validation classified 36 of 36 correctly. These are measured results for the supplied seeds and simple patterns, not promised learner outputs or real-image quality evidence. Logs preserve the full curve. In particular, the selected epoch does not imply that epochs after 15 should be removed from every future experiment.

The fit command writes selection.json and selected-state.pt into a fresh run directory. Metadata records preprocessing, label order, architecture input shape, selection rule, data hashes and checkpoint hash, and explicitly records zero test evaluations. Repeating fit into that directory is refused to preserve earlier evidence. A unit test replaces the test-record constructor with a failure during fitting, demonstrating that this implementation finishes training and selection without generating test pixels. That strengthens the protocol claim without evaluating final-test performance or relying on an author statement alone.

model.train()
optimiser.zero_grad(set_to_none=True)
loss = criterion(model(images), labels)
loss.backward()
optimiser.step()
# Validation uses eval and inference_mode, without an update.

Learn in your browser · Chapter 05 of 06

An easy clean split can conceal a brittle task. Diagnose inputs and model separately before changing the experiment.

A confusion matrix has true labels in rows and predicted labels in columns here. Its entries count images, so all nine cells sum to the evaluated population. A row sum is the number of examples of that true class. The diagonal counts correct predictions. If a horizontal row contains eight horizontal predictions and four cross predictions, horizontal recall is eight divided by twelve, not eight divided by all 36 images. Write the axis convention next to the matrix; a transposed table can otherwise support a wrong narrative.

Overall accuracy can conceal which class fails, especially after introducing class imbalance. Compare each true-class row, its errors and actual image IDs instead of declaring the task solved from one average. The validation set is balanced and very small. Even 36/36 leaves uncertainty about other generator settings, unseen failure types and real inputs. Two views within a group are correlated, so treating 36 images as 36 unrelated real-world acquisitions would exaggerate the diversity of this evidence. A larger numeral is not a substitute for an independent data source.

The stress condition was declared before final testing: replace every validation pixel with zero while retaining labels. It deliberately removes the class signal. The author model then classified 12/36 correctly, while clean validation remained 36/36. This contrast demonstrates dependence on visible pattern information and a severe out-of-distribution input. It does not measure camera-noise robustness or establish that an all-black real image should have one of these labels. A real interface might need an invalid-input or abstention policy that this three-class lab does not implement.

Inspect mistakes with source IDs, true label, prediction and input condition. Errors under blank stress are not evidence that original labels should change to the predicted class. A model output is a hypothesis, not label authority. For a malformed example, fix the data contract and create a new version. For systematic confusion on valid examples, formulate a training or architecture hypothesis and test it using training and validation. Do not quietly repair evaluation labels until the metric improves; preserve the original finding and the reason for any authorised correction.

Tests challenge meaningful failure modes. Moving one source group into validation must fail disjointness. A NaN, missing pixel or out-of-range class must fail input validation. Evaluation must leave weights unchanged and give stable predictions with dropout disabled. Reloading selected state must reproduce its clean validation predictions. Training must change a parameter and lower the recorded training loss in this fixed toy experiment. These checks exercise intended contracts rather than merely checking that a script exits successfully, and their expected rejections should be kept in the evidence record.

Keep dataset corruption, implementation defects and limited generalisation separate in the failure log. A fractional target is a data-contract defect. Crediting a validation update to training is a phase defect. Poor performance on a valid shifted pattern is a model limitation or distribution question. These categories imply different next actions and evidence. Reinstalling a package cannot establish a correct label, and increasing epochs cannot repair a source group leaked across splits. Start with the earliest violated contract before tuning a parameter simply because it is easy to change.

Validation has now informed diagnosis, so it is a development resource rather than a final independent verdict. Record the hypotheses considered, including changes you decide against. If a final-test result selects another architecture, that set becomes development evidence for the revised experiment. A later final claim needs new appropriately separated data or a clearly disclosed reuse protocol. A new output directory preserves files; it does not make previously inspected examples scientifically untouched again. Preserve that distinction even when every command is technically reproducible.

Learn in your browser · Chapter 06 of 06

Bind the tested state, preserve the result and state what this small CPU experiment leaves out.

Before the test command, freeze selected checkpoint, preprocessing statistics, class order, input shape and selection metadata. The final command checks the checkpoint digest against selection.json, loads selected state and only then generates the 36 test images from separate source groups. It writes FINAL-RESULTS.json and refuses to evaluate into that run directory again. This makes accidental repeated testing visible. It does not stop deliberate copying or changing the program; honest experiment records still matter. A frozen decision is a research protocol, not merely a file extension.

Reconstruct the same TinyCNN class before loading its state dictionary. Use CPU map_location and weights_only=True for this locally produced file, then enter eval and inference mode. A state dictionary contains learned tensors, not every detail needed to interpret inputs. Keep architecture source, preprocessing and label mapping beside it. PyTorch documents restrictions and residual risks of weights-only loading; the lab loads its own checkpoint, not an arbitrary unknown file. A matching hash checks a version, not general safety or the truth of a result. [S11]

The author final test, performed after selection, classified 36 of 36 correctly; the training-derived majority baseline classified 12 of 36. Clean validation was also 36 of 36, while the predeclared blank validation condition had 12 correct. Report these populations and conditions separately. Do not average clean and blank scores into a new headline or say a perfect test proves broad visual understanding. This result belongs to the selected checkpoint and exact generator, split and package versions recorded in the evidence, not every future revision of the code.

A handover names the task and class order, source-group split, generated-data hashes, training settings, selected epoch and rule, checkpoint digest, clean validation diagnostics, final-test counts and known exclusions. Preserve failed checks and expected mutation rejections alongside successes. Another reviewer should identify which model produced which result without relying on the author remembering a filename. Keep the private final knowledge-assessment bank outside the learner ZIP. Learner practice answers are separate educational material and must not become a route for publishing scored exam items.

CPU execution makes the full experiment small enough for an ordinary development machine. It does not estimate GPU throughput, large-image memory, deployment latency or energy requirements. This task has three generated patterns and 235 parameters; there is no camera acquisition, real image licensing, distribution monitoring, production service or user study. An extension to real images needs new data provenance, labels, group definitions, evaluation and operational work. Replacing a filename without reconsidering those assumptions does not transfer the evidence from a synthetic pattern task to a real visual application.

Convolutional training and testing are the outcome here. Transfer learning, pretrained image backbones, object detection, segmentation and transformer training are possible later studies, not completed competencies implied by this exercise. Reuse the tensor course for foundations and attention or tiny-language-model courses for their distinct architectures. NVIDIA offers its own broader material independently. This MICKAI course and any educational completion certificate do not provide NVIDIA credentials, professional qualification, learner identity verification or permission to deploy. Describe the specific demonstrated learning activity rather than borrowing authority from a neighbouring programme.

The knowledge assessment has 40 private multiple-choice items and draws a 20-question sitting. Strictly above 80 percent requires 17 correct; 16 does not pass. The six written exercises and executable practical work are ungraded. A knowledge score does not verify that a learner ran this loop or can operate a real vision system. A different reviewer must inspect teaching, every key and explanation, the learner package and rendering before publication. Actual author execution is evidence, not self-approval, and local files do not establish current course, exam or certificate availability.

model = TinyCNN().cpu()
state = torch.load(path, map_location="cpu", weights_only=True)
model.load_state_dict(state)
model.eval()
with torch.inference_mode():
    logits = model(normalised_images)