Freezing Model Layers for Fine-Tuning

This lesson looks at a single assignment that changes what a pre-trained GPT-2 model is for. The model keeps almost all of its structure. Its internal layers, which build representations of the input text, stay as they are. Only the final layer, the one that turns those internal representations into outputs, is replaced with a new layer built for a different task.

The swap is a single assignment, model.out_head = followed by a constructor call. Nothing else in the model is rewritten. That means every question about what changes comes down to two things: what the new object is, and how it is sized. The most useful habit here is to know which line changed the model and what the model looked like just before that line ran.

Before you can judge the replacement, you need to know what it replaces. The original model.out_head takes the internal vector produced for each position and maps it to 50,257 values. That number is the size of the vocabulary, which means there is one output value for every token the model can produce.

This makes the original layer a vocabulary projection. It answers the question of which token comes next by scoring every entry in the vocabulary. Each position gets its own vector of 50,257 scores, and the highest-scoring entry is the model's candidate for the next token.

A classification task does not need a score for every vocabulary token. If the goal is to choose between two categories, the model only needs two outputs. The replacement is the change that matches the output size to the task instead of to the vocabulary.

Read the diagram from the top down. The hidden vector on the left and the hidden vector on the right are the same kind of object, because the layers before the output layer are untouched. Only the last projection and the number of scores it produces have changed. The original projection emits a score for every vocabulary token, while the new projection emits one score for each class.

The replacement creates a new torch.nn.Linear layer and stores it in the model's out_head attribute, overwriting the original. The call takes two named arguments. Reading the line means understanding what each argument controls, so the constructor call is the place to start.

A Linear layer stores its weight matrix with one row per output feature and one column per input feature. Use that rule and the two arguments you just read to predict the shape of model.out_head.weight. Then check your answer against the reveal.

The number 768 could have been typed directly into the call. The source instead reads it from BASE_CONFIG['emb_dim']. The stated reason is generality: the same replacement line then works for larger GPT-2 variants, because each variant's embedding dimension is stored in the configuration rather than written into the line itself.

The hardcoded version is not wrong for gpt2-small. It becomes wrong only when the same code is pointed at a model with a different embedding dimension. The config-based version keeps the replacement line unchanged across model sizes, and the size-specific information lives in one place.

When the output layer is replaced incorrectly, the error usually does not appear on the replacement line itself. The line is accepted, because creating a Linear layer with those arguments is valid. The problem shows up later, when data first passes through the new layer or when a shape is inspected. The useful debugging question is therefore not only what the line says but where its result is first used.

Trace from the replacement to the first place a shape is checked, and compare what you see there with the shape rule you derived earlier. If the input width of the new layer does not match the width of the vector arriving from the earlier layers, the first mismatch appears at the first forward pass through the new layer. If the output has a size you did not expect, the mismatch appears when you inspect the output or the weight shape.