Pretrained Vision Models

A pretrained vision model ships with backbone weights learned from millions of photos, so your classifier starts from real edges and textures instead of random noise.

A pretrained vision model reuses backbone weights learned from millions of photos, so a new task trains only a small classifier head.

Why Does This Exist?

Training a ResNet-50 on ImageNet from random weights takes days on 8 GPUs and more than a million labeled photos. Almost nobody has that budget for every new task, and almost nobody needs it: the early and middle layers of trained vision networks converge to the same edge, texture, and part detectors no matter what the final classes are.

Pretrained models package that shared knowledge as downloadable weights. You load a backbone that already sees, attach a small head for your classes, and train on hundreds of images instead of millions. This page covers what those weights hold, the freeze-then-train workflow, and the head-swap arithmetic. The broader practice lives in transfer learning, and unfreezing schedules live in fine-tuning.

Think of It Like This

A library card instead of buying every book

Writing a report by buying and reading every source book takes months and a full shelf. A library card gives you the same knowledge for the cost of the trip: the books were written once, by others, and every reader reuses them.

The backbone is the library. ImageNet training wrote the volumes on edges, fur, metal, and text. Your two-class head is the final page you write yourself, citing the borrowed books instead of rewriting them.

It stops where reuse stops. Borrowed books never update for your topic, and a cookbook shelf will not fix a plumbing job: once your images leave the natural-photo domain, the borrowed knowledge runs thin and you must retrain deeper layers yourself.

How It Actually Works

A classifier splits into two parts. The backbone turns pixels into a feature vector (for ResNet-50, a 2048-number summary of the image). The head is one matrix that maps that vector onto class scores. Pretraining sets the backbone's numbers on ImageNet; you keep them and replace only the head.

What the weights hold

Early backbone stages detect edges and color blobs, middle stages detect textures and parts, late stages combine them into object-level patterns. The 1000-way ImageNet head is discarded because your classes differ. The preprocessing travels with the weights: resize to 256, center-crop to 224, then normalize with mean $[0.485, 0.456, 0.406]$ and std $[0.229, 0.224, 0.225]$ , where each entry is one color channel. Skip that normalization and you'll drop several points for no reason, because every filter expects centered inputs.

The standard workflow is freeze-then-train: hold the backbone fixed and train only the new head first (feature extraction), then optionally unfreeze the top layers at a small learning rate.

Worked example: the head swap

ResNet-50's original head maps 2048 features onto 1000 classes: $2048 \times 1000$ weights plus $1000$ biases equals $2{,}049{,}000$ parameters. For your two-class task the new head needs $2048 \times 2 + 2 = 4{,}098$ parameters. Divide: $2{,}049{,}000 / 4{,}098 = 500$ exactly, so the head itself shrinks 500-fold, and with the backbone frozen those 4,098 are the only numbers training touches, down from about 25.6 million.

Code

1def normalize(pixel: float, mean: float, std: float) -> float:2    """One channel of ImageNet normalization: center, then scale."""3    return (pixel - mean) / std4
5
6print(round(normalize(0.714, 0.485, 0.229), 4))7# -> 1.08print(2048 * 1000 + 1000, 2048 * 2 + 2)9# -> 2049000 4098

A pixel one standard deviation above the red mean normalizes to exactly 1.0, which is the centered input the filters expect. The second line replays the head swap: 2,049,000 parameters discarded, 4,098 trained.

Watch Out For

Pretraining domain mismatch

Weights learned from natural photos transfer poorly to X-rays, satellite radar, or microscopy, whose pixel statistics differ completely. The symptom is a frozen backbone that plateaus below even a small from-scratch model. Match the pretraining domain to your images with a medical or remote-sensing checkpoint, or budget for unfreezing deep into the backbone.

Wrong preprocessing silently costs points

Each weight release ships with the exact resize, crop, and normalization it trained with. Applying your own normalization shifts every activation off the values the weights expect, and the symptom is a model several points worse with nothing wrong in the training loop. Always use the checkpoint's own transform pipeline instead of numbers copied from a blog post.

The Quick Version

A pretrained vision model reuses backbone weights learned from millions of photos and trains only a new head.
Early layers hold edges and textures any task can reuse; the discarded head held the old classes.
The ResNet-50 head swap cuts head parameters exactly 500-fold, from 2,049,000 to 4,098.
Always apply the checkpoint's own resize, crop, and normalization values.
Natural-photo weights fail on X-ray or satellite images, so match the pretraining domain to yours.