Continuous Function

Machine Learning

Image Classification Pipeline

Image classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

status: reviewimportance: criticaldifficulty 3/5math: undergraduateread: 16mlive demo
Back to Machine LearningNext: Data Augmentation and Transfer Learning (review)

Concept Structure

Image Classification Pipeline

01Intuition

Start with the picture, metaphor, or geometric mechanism.

02Math

Make the objects explicit and connect them with notation.

03Code

Mirror the equations with runnable implementation details.

04Interactive Demo

Manipulate the mechanism and watch the idea respond.

2prerequisites
4next concepts
4related links

Learner Contract

What this page should let you do.

You are here becauseImage classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

This Machine Learning concept is the current idea: keep the same invariant visible across Intuition, Math, Code, Interactive Demo.

By the end4/4 sections ready | runnable code expected | live demo

Explain the mechanism, trace the main notation, and test one prediction in the live demo.

Do this firstIntuition

Read the intuition before the notation; the math should name a mechanism you already felt.

Test the linkManipulate one control and predict the visible change.Then continue to Data Augmentation and Transfer Learning (review)

Claim/source review status

Substantive review recorded

1/1 claims have bounded review metadata; still check caveats and source scope.Metadata-derived; review may be AI-assisted. Not a human certification.
Claims1/1 reviewed
Sources6 cited
Codeattached
Demolive
Reviewed2026-07-03
Updatedpage 2026-07-03

Learning item flow

4/4 sections readyAsk about thisResearch room
ConceptImage Classification PipelineMachine LearningEquationImage Classification Pipeline equation 1Exact equationCodeImage Classification Pipeline runnable code 1Exact runnable codeDemoImage Classification Pipeline interactive demoInteractive demoClaimA single-label image classification pipeline maps labeled images thro...Exact claim checkSourceCS231n: Linear ClassificationExact source
ConceptImage Classification PipelineMachine Learning
6 sources attachedLocal snapshot ready
concept:machine-learning/image-classification-pipeline
CodenearbyPredictbefore revealRoomitem handoff
01IntuitionStart with the picture, metaphor, or geometric mechanism.02MathMake the objects explicit and connect them with notation.03CodeMirror the equations with runnable implementation details.04Interactive DemoManipulate the mechanism and watch the idea respond.
01

01

Intuition

Build the mental picture first so the rest of the page has something to attach to.

Section prompt

You are here because image classifiers often look like one black box: picture in, class name out. The useful question is more concrete: which array, label index, score vector, or loss value changes at each step between a file on disk and the update used for learning?

Before this, know CNN tensor shapes and basic classification metrics. By the end, you should be able to trace one labeled image through preprocessing, augmentation, a batched tensor, logits, cross-entropy, and a top-k prediction. You should also be able to spot two quiet bugs: a tensor with the wrong channel order and a class index that names the wrong label.

An image file is not yet a model input. It becomes an array with height, width, and channels, often H×W×CH\times W\times C. A transform resizes or crops it, converts pixel values to floating point, normalizes them, and usually reorders the axes into the framework's batch convention. In many PyTorch-style models, a batch has shape B×C×H×WB\times C\times H\times W.

The label is just as important as the pixels. A directory name or dataset row such as "triangle" becomes an integer class index such as 22. Cross-entropy does not know the English word. It only sees that the target is index 22, so the class map must say the same thing during training, evaluation, and serving.

The model turns the batch into logits: one unnormalized score per class. Softmax turns those logits into probabilities for interpretation, but cross-entropy can consume logits directly in common frameworks. The loss for one example is the negative log probability assigned to the true class index.

Train transforms and evaluation transforms have different jobs. Training can use random crop, flip, color jitter, or other augmentations to create useful variation. Evaluation should be controlled and repeatable. If the random training transform leaks into evaluation, accuracy and top-k examples can move because the input changed, not because the model learned something new.

This page is only the supervised single-label pipeline. It does not cover detection boxes, segmentation masks, multilabel tags, data curation policy, robustness guarantees, or architecture design.

02

02

Math

Translate the story into symbols, assumptions, and a derivation you can inspect.

Section prompt
Equation 1(xi,yi),(x_i, y_i),Equation 2m:{0,…,K−1}→{class names}.m:\{0,\dots,K-1\}\to\{\text{class names}\}.

Let one labeled image be

(xi,yi),(x_i, y_i),

where xi∈RH×W×Cx_i\in\mathbb R^{H\times W\times C} is the image array and yi∈{0,…,K−1}y_i\in\{0,\dots,K-1\} is a class index. The human-readable class map is a function

m:{0,…,K−1}→{class names}.m:\{0,\dots,K-1\}\to\{\text{class names}\}.

That map is part of the mathematical object. If m(2)=trianglem(2)=\text{triangle} during training but m(2)=circlem(2)=\text{circle} during evaluation, the tensor target still has the right type while the learning problem has changed meaning.

A train or evaluation transform TT creates the model input

x~i=T(xi).\tilde x_i = T(x_i).

For a mini-batch of size BB, a common CNN convention is

X∈RB×C×H′×W′.X\in\mathbb R^{B\times C\times H'\times W'}.

The model produces logits

Z=fθ(X)∈RB×K.Z=f_\theta(X)\in\mathbb R^{B\times K}.

For example ii and class kk, softmax gives

pik=exp⁡Zik∑j=0K−1exp⁡Zij.p_{ik}=\frac{\exp Z_{ik}}{\sum_{j=0}^{K-1}\exp Z_{ij}}.

The single-label cross-entropy loss for example ii is

ℓi=−log⁡pi,yi.\ell_i=-\log p_{i,y_i}.

The batch loss is often the mean

L(θ)=1B∑i=1Bℓi.L(\theta)=\frac1B\sum_{i=1}^{B}\ell_i.

The top-1 prediction is

y^i=arg⁡max⁡kZik,\hat y_i=\arg\max_k Z_{ik},

and top-rr prediction asks whether the true index yiy_i appears among the rr largest logits. Logits are enough for top-k because softmax preserves the ordering.

The pipeline contract is:

image and label semantics→transform→B×C×H′×W′→K logits→loss and prediction.\text{image and label semantics} \rightarrow \text{transform} \rightarrow B\times C\times H'\times W' \rightarrow K\text{ logits} \rightarrow \text{loss and prediction}.

Each arrow should preserve either tensor shape or label meaning. When a bug breaks one of those contracts, the model can be wrong before learning even begins.

03

03

Code

Keep the implementation aligned with the notation so the algorithm is legible.

Section prompt
Runnable code 1import numpy as np class_names = np.array(["background", "line", "triangle", "circle"]) image...python
import numpy as np

class_names = np.array(["background", "line", "triangle", "circle"])
image_hwc = np.arange(28 * 28, dtype=np.float32).reshape(28, 28, 1)
image_chw = np.moveaxis(image_hwc / 255.0, -1, 0)
batch = image_chw[None, :, :, :]

logits = np.array([[0.1, -1.2, 2.4, 0.7]])
target = np.array([2])
shifted = logits - logits.max(axis=1, keepdims=True)
probs = np.exp(shifted) / np.exp(shifted).sum(axis=1, keepdims=True)
loss = -np.log(probs[np.arange(len(target)), target])
top2 = np.argsort(logits[0])[-2:][::-1]

print("raw HWC:", image_hwc.shape)
print("batch NCHW:", batch.shape)
print("target:", target[0], class_names[target[0]])
print("logits:", logits.shape, np.round(logits[0], 2))
print("cross entropy:", round(float(loss.mean()), 3))
print("top-2:", [(int(k), class_names[k], round(float(probs[0, k]), 3)) for k in top2])

The code mirrors the math. moveaxis makes the channel dimension explicit, batch adds the mini-batch axis, target is a class index, and the loss reads the probability assigned to that exact index.

04

04

Interactive Demo

Use direct manipulation to connect the explanation to a moving system.

Section prompt

Use the lab as a pipeline debugger. Pick the checkpoint that breaks the run before reveal:

  • Shape contract: the tensor axes do not match what the CNN expects.
  • Label semantics: the integer target exists, but the class map names the wrong thing.
  • Train/eval transform: evaluation still uses a random training transform, so the input is not repeatable.

Before reveal, logits, loss, top-k prediction, and the exact failure explanation stay locked. After reveal, compare the raw image card, transform card, batch tensor shape, class-index map, logits, loss, and top-k panel. The demo is a teaching pipeline, not a benchmark or production data loader.

Live Concept Demo

Explore Image Classification Pipeline

The stage is code-native and interactive. Use it to test the explanation against the mechanism.

difficulty 3/5undergraduatecode-aligned
Demo Prediction Checkpoint

Manipulate one control and predict the visible change.

Commit to what Image Classification Pipeline should make visible before reading the result.

After The First Pass

Turn the concept into an inspected object.

Once the invariant is visible in the intuition, math, code, and demo, use these panels to inspect the mechanism visually, check source support, practice the idea, and attach a grounded research question.

Mechanism Storyboard

See the idea move before the page explains it

Image classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

Prediction open01 / Intuition
Prediction lens

Start with the picture, metaphor, or geometric mechanism.

Commit first

Before reading further, choose the kind of change Image Classification Pipeline should make visible.

Visual Inquiry

Make the image answer a mathematical question

Image classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

4/4 stages readyLive demo connected
Prediction

Which visible object should carry the first intuition?

Commit first

Pick the cue that should make Image Classification Pipeline easier to reason about before the page gives the answer.

Source Grounding

Canonical references for the mechanism on this page.

course-notes · 2026CS231n: Linear ClassificationStanford CS231n

Source for image classification as mapping image tensors to class scores and losses.

Open source
course-notes · 2026CS231n: Neural Networks Part 2 - Setting up the Data and the LossStanford CS231n

Source for image data preprocessing, mean subtraction, normalization, and training-set statistics.

Open source
book · 2026Dive into Deep Learning: Softmax RegressionZhang, Lipton, Li, and Smola

Source for logits, softmax probabilities, one-hot labels, and cross-entropy for multiclass classification.

Open source
book · 2026Dive into Deep Learning: Image AugmentationZhang, Lipton, Li, and Smola

Source for image augmentation as training-time transformations and the need to keep evaluation transforms controlled.

Open source
documentation · 2026fastai: Computer Vision Tutorialfast.ai

Source for practical image classification workflows with image blocks, category labels, data loaders, and vision learners.

Open source
documentation · 2026PyTorch: torch.nn.CrossEntropyLossPyTorch contributors

Source for the framework contract that cross-entropy consumes unnormalized logits and class-index targets.

Open source

Claim Review

Image classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

Status1 substantive review recorded

Claims without a substantive review badge still need exact source-support review.

Sources6 references

cs231n-linear-classification, cs231n-neural-networks-data-preprocessing, d2l-softmax-regression, d2l-image-augmentation, fastai-vision-tutorial, pytorch-cross-entropy-loss

Local checks4 local checks

Use equations, runnable code, and demos to check whether the source support is operational.

Substantively reviewedA single-label image classification pipeline maps labeled images through train/eval transforms into batched tensors, model logits, cross-entropy loss, and class predictions; tensor shape and label-index semantics must remain aligned across that whole path.Claim metadata: source checked

The sources jointly support image tensors being transformed into classifier scores/logits, softmax/cross-entropy training with class labels, augmentation as controlled training-time data transformation, and the practical requirement that class-index targets match the model's class order.

Sources: CS231n: Linear Classification, CS231n: Neural Networks Part 2 - Setting up the Data and the Loss, Dive into Deep Learning: Softmax Regression, Dive into Deep Learning: Image Augmentation, fastai: Computer Vision Tutorial, PyTorch: torch.nn.CrossEntropyLossSingle-label supervised image classification only; not object detection, segmentation, multilabel classification, self-supervised learning, production data-governance pipelines, robustness certification, or GPT Pro publication approval.A bounded review summary is present; still check caveats and exact reference scope.

Checked CS231n for image-to-score/loss framing and data preprocessing, D2L for softmax/cross-entropy and augmentation, fastai for practical vision data/label workflows, and PyTorch CrossEntropyLoss for logits plus class-index targets. GPT Pro publication critique remains pending because the Oracle lane was unavailable.

Reviewer: codex-local-primary-source-audit; reviewed 2026-07-03
source-span-cs231n-linear-classificationsource-span-d2l-softmax-regressionsource-span-d2l-image-augmentationsource-span-pytorch-cross-entropy-lossEquation 1Equation 2Runnable code 1Interactive demo

Source support candidates

course-notes 2026CS231n: Linear Classification

Source for image classification as mapping image tensors to class scores and losses.

course-notes 2026CS231n: Neural Networks Part 2 - Setting up the Data and the Loss

Source for image data preprocessing, mean subtraction, normalization, and training-set statistics.

book 2026Dive into Deep Learning: Softmax Regression

Source for logits, softmax probabilities, one-hot labels, and cross-entropy for multiclass classification.

book 2026Dive into Deep Learning: Image Augmentation

Source for image augmentation as training-time transformations and the need to keep evaluation transforms controlled.

Mechanism checks

Equation 1
(xi,yi),(x_i, y_i),
Equation 2
m:{0,…,K−1}→{class names}.m:\{0,\dots,K-1\}\to\{\text{class names}\}.
Runnable code 1import numpy as np class_names = np.array(["background", "line", "triangle", "circle"]) image...Demo stateLive mechanism probe

Practice Loop

Try the idea before it explains itself

Image classification turns labeled images into normalized tensors, logits, cross-entropy loss, and predictions while preserving tensor shape and class-index meaning.

Readiness0/3 checks ready
Predict

Before touching the demo, predict one visible change that should happen in Image Classification Pipeline.

Hint 1

Reveal when your model needs a nudge.

Hint 2

Reveal when your model needs a nudge.

Hint 3

Reveal when your model needs a nudge.

Grounded research drawerClose
ConceptImage Classification PipelineMachine Learning
Runnable code comparisonImage Classification Pipeline runnable code 1class_names = np.array(["background", "line", "triangle", "circle"])Prediction before revealImage Classification Pipeline interactive demoManipulate one control and predict the visible change.
Grounded room questionWhat is the smallest example that makes Image Classification Pipeline click without losing the math?Local snapshot ready

Research Room

Attach the question to a claim, equation, code, or demo

Pick the concept, equation, source, runnable code, claim, misconception, or demo state before asking for help. The handoff keeps that page item in context.
Next local actionNo local draft saved yet

Open the draft below to save one note and next action in this browser.

conceptMachine Learning

Image Classification Pipeline

Attached question

What is the smallest example that makes Image Classification Pipeline click without losing the math?

Local action draftNo local draft saved yetExpand only when ready to capture one local next action
Local action draft

This draft stays in this browser, attached to the selected learning item.

No local draft saved.
Evidence to inspect
  • References to inspect: attached references on this page.
  • Definition, prerequisite, and contrast concept links
  • The equation or runnable code that makes the concept operational
  • One demo state that shows the invariant instead of a slogan
What would resolve this
  • The learner can state the mechanism in their own words
  • The learner can name the prerequisite that would repair confusion
  • The learner can predict how the mechanism changes under one perturbation
Grounded AI handoff

I am working in Continuous Function's research reading room. Object: concept - Image Classification Pipeline Selected item key: recorded for copy. Context: Machine Learning Page anchor: recorded for copy. Open question: What is the smallest example that makes Image Classification Pipeline click without losing the math? Evidence to inspect: - References to inspect: attached references on this page. - Definition, prerequisite, and contrast concept links - The equation or runnable code that makes the concept operational - One demo state that shows the invariant instead of a slogan What would resolve this: - The learner can state the mechanism in their own words - The learner can name the prerequisite that would repair confusion - The learner can predict how the mechanism changes under one perturbation Answer as a careful research tutor: stay source-grounded, separate verified evidence from assumptions, name the relevant math objects, and end with one next action.

View it in context
concept/concept-notebook/machine-learning/image-classification-pipeline concept:machine-learning/image-classification-pipeline