Vision Is Representation Under Pressure

Every method in this sequence answers one question: what representation survives an image that nobody arranged for the model. The notes run from pixels to systems that classify, localize, generate, attend, transfer, and fail in ways you can name.

An image is a block of numbers until you build the machine that can use it. From those numbers the model must recover objects, shapes, texture, motion, and meaning. The work is turning raw arrays into decisions you can act on.

The pipeline is what you are learning, and it has seven stages

The pipeline is the lesson. The stages run in this order: data, representation, loss, optimization, architecture, evaluation, and failure analysis. Each stage decides what the next stage can see.

Data sets the ceiling on what the model can learn about. Representation decides what survives the first transform. The loss states what counts as wrong, and the model optimizes that statement rather than your intent. Optimization moves the parameters, and backpropagation is the bookkeeping for blame that tells each one how it contributed. Architecture makes some structure cheap to express and leaves the rest expensive.

Evaluation is the stage where the split does the work. Train fits the parameters. Validation picks the choices you make by hand. Test reports what happens on data you never touched. Failure analysis then decides what you fix next, and the fix often lands back at data or representation.

The pressures are the same at every stage: pose, lighting, scale, background, occlusion, viewpoint, and class imbalance. Every later note tests against that one list.

Every method asks the same question in a different costume

The sequence defines the task first, then makes the simplest models fail in public. After that come gradients, backpropagation, neural networks, convolution, and the training discipline that survives contact with real data. Later notes add attention, transformers, generative models, NeRF, and adversarial examples.

Each method answers the same two things: what must stay fixed, and what the model must learn from data.

Nearest neighbor fixes the data and changes the comparison rule. Linear classifiers learn a weight matrix, and from there the parameters carry the model. Neural networks learn layers of representation. ConvNets learn local filters and share them across space.

Transformers learn routing. Generative models learn the data distribution. Adversarial examples show that the learned representation is not the same thing as human vision.

Each answer buys an invariance and pays for it with information it throws away. Convolution buys locality and weight sharing because images repeat local patterns, and it gives up per-pixel parameters.

Historical order teaches the names. Shortcut order teaches the work: what shortcut each architecture blocks, and what new shortcut it opens. Track what each method makes easier to represent and which failure it leaves exposed.

The contract holds even when the architecture changes

Every note in the sequence works under one contract. You start with raw visual data, define a task, choose a representation and an objective, and optimize it. Then you show the result survives new examples.

That is why notes written before transformers still decide how I read the new ones. Six standing checks carry across all of them.

• Name the input and its exact shape.
• Say where the labels came from and who made them.
• Write the loss down and read it as the goal the model pursues.
• Pick the baseline that makes any gain believable.
• State what changed after training.
• Find what breaks under distribution shift.

Read every note with one builder question

One filter decides what I keep from a note. If I must implement this or debug it tomorrow, what do I need to remember?

That filter cuts a lot of academic fog. It keeps the shape math, the loss intuition, and the failure modes. It keeps the small implementation details that decide whether a notebook trains or only looks like it trains.

A clean accuracy number is the easiest thing to trust too early

A model can win the average case and break under a lighting change, an occlusion, or a rare class. It can also break because it found a background cue and used it.

Vision models see tensors and correlations, and a background cue is a correlation like any other. That is why baselines, augmentation, saliency, ablations, and error analysis carry the weight here. Trust an accuracy number after it holds on a slice you chose to be hard.

The Builder Test

Pick one misclassified image and explain the mistake. Name the feature the model used and the evidence that proves it. Then name the one change that makes the model less brittle.

You pass when another person looks at the same evidence and sees the same cue.

What Carries

Generalization is the whole point. Training accuracy is a rehearsal, and the image the model never saw is the performance.

The first stage fixes the task: pixels in, one label out. Start there. The label must hold under the pressure list, and the split is the instrument that reports whether it does.