Fine-tuning approach in Computer Vision - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to load a pre-trained model for fine-tuning.

Computer Vision

from torchvision import models
model = models.resnet18(pretrained=[1])

Drag options to blanks, or click blank then click option'

A0

BFalse

CTrue

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using pretrained=False will initialize random weights, not useful for fine-tuning.

Passing None or 0 will cause errors or ignore pre-trained weights.

Setting pretrained=True loads the model with weights trained on ImageNet, which is needed for fine-tuning.

2fill in blank

medium

Complete the code to freeze all layers except the last fully connected layer.

Computer Vision

for param in model.parameters():
    param.[1] = False

Drag options to blanks, or click blank then click option'

Adetach

Bgrad

Ctrain

Drequires_grad

Attempts:

3 left

💡 Hint

Common Mistakes

Using grad or train attributes will cause errors or have no effect.

detach is a method, not an attribute to freeze parameters.

Setting requires_grad=False freezes the parameters so they won't update during training.

3fill in blank

hard

Fix the error in replacing the last layer to match 10 output classes.

Computer Vision

import torch.nn as nn
model.fc = nn.Linear(model.fc.in_features, [1])

Drag options to blanks, or click blank then click option'

A10

B0

C1

D100

Attempts:

3 left

💡 Hint

Common Mistakes

Using 100 or 1 will cause shape mismatch errors during training.

Using 0 will cause runtime errors.

The last layer must output the number of classes, here 10 for fine-tuning on a 10-class dataset.

4fill in blank

hard

Fill both blanks to set the optimizer to update only trainable parameters with learning rate 0.001.

Computer Vision

import torch.optim as optim
optimizer = optim.SGD([1], lr=[2])

Drag options to blanks, or click blank then click option'

Afilter(lambda p: p.requires_grad, model.parameters())

Bmodel.parameters()

C0.01

D0.001

Attempts:

3 left

💡 Hint

Common Mistakes

Passing all parameters causes frozen layers to update unnecessarily.

Using a too high learning rate like 0.01 may harm fine-tuning.

We use filter to pass only parameters that require gradients to the optimizer, and set learning rate to 0.001 for fine-tuning.

5fill in blank

hard

Fill all three blanks to complete the training loop for one epoch with loss calculation and optimizer step.

Computer Vision

model.train()
for inputs, labels in dataloader:
    optimizer.zero_grad()
    outputs = model([1])
    loss = criterion(outputs, [2])
    loss.[3]()
    optimizer.step()

Drag options to blanks, or click blank then click option'

Ainputs

Blabels

Cbackward

Dforward

Attempts:

3 left

💡 Hint

Common Mistakes

Passing labels to model instead of inputs causes errors.

Calling forward() on loss is invalid; use backward().

We pass inputs to the model, compare outputs with labels to compute loss, then call loss.backward() to compute gradients before optimizer.step().

Practice

1. What is the main purpose of fine-tuning a pre-trained computer vision model?

easy

A. To adapt the model to a new task using less data and time

B. To train a model from scratch with a large dataset

C. To increase the size of the model for better accuracy

D. To remove layers from the model to make it smaller

Solution

1. Step 1: Understand fine-tuning concept

   Fine-tuning means starting from a model already trained on a related task.

2. Step 2: Identify the benefit

   This approach saves time and data by reusing learned features for a new task.

3. Final Answer:

   To adapt the model to a new task using less data and time -> Option A

4. Quick Check:

   Fine-tuning = adapt pre-trained model fast [OK]

Hint: Fine-tuning means reusing a model to learn new tasks faster [OK]

Common Mistakes:

• Thinking fine-tuning trains from scratch
• Assuming fine-tuning always increases model size
• Confusing fine-tuning with pruning layers

2. Which code snippet correctly freezes the layers of a PyTorch model before fine-tuning?

easy

A. for param in model.parameters(): param.requires_grad = False

B. model.freeze_layers()

C. model.trainable = False

D. for layer in model.layers: layer.trainable = True

Solution

1. Step 1: Recall PyTorch freezing syntax

   In PyTorch, freezing means setting requires_grad = False for parameters.

2. Step 2: Match code to syntax

   for param in model.parameters(): param.requires_grad = False correctly loops over parameters and disables gradient updates.

3. Final Answer:

   for param in model.parameters(): param.requires_grad = False -> Option A

4. Quick Check:

   Freeze layers = requires_grad False [OK]

Hint: Freeze layers by setting requires_grad = False in PyTorch [OK]

Common Mistakes:

• Using non-existent methods like freeze_layers()
• Setting model.trainable instead of parameters
• Confusing trainable True/False for freezing

3. Given this PyTorch code snippet for fine-tuning, what will be the output of print(sum(p.requires_grad for p in model.parameters())) after freezing layers?

medium

A. Raises an error

B. Number of all model parameters

C. 0

D. Number of unfrozen parameters

Solution

1. Step 1: Understand freezing effect on requires_grad

   Freezing sets requires_grad = False for all parameters.

2. Step 2: Calculate sum of requires_grad flags

   Since all are False, sum counts zero True values.

3. Final Answer:

   0 -> Option C

4. Quick Check:

   All frozen means requires_grad sum = 0 [OK]

Hint: Frozen layers have requires_grad = False, sum is zero [OK]

Common Mistakes:

• Assuming sum counts total parameters
• Thinking sum counts unfrozen parameters without freezing
• Expecting an error from requires_grad attribute

4. You tried fine-tuning but the model's accuracy did not improve. Which mistake could cause this?

medium

A. Using a pre-trained model instead of training from scratch

B. Freezing all layers and not unfreezing any

C. Adding more layers without training them

D. Using a very high learning rate during fine-tuning

Solution

1. Step 1: Identify learning rate impact

   A very high learning rate can cause unstable training and no improvement.

2. Step 2: Evaluate other options

   Freezing all layers prevents learning but usually keeps baseline accuracy; pre-trained models help; adding untrained layers alone doesn't prevent improvement if trained.

3. Final Answer:

   Using a very high learning rate during fine-tuning -> Option D

4. Quick Check:

   High learning rate = no improvement [OK]

Hint: Use smaller learning rates for fine-tuning to improve accuracy [OK]

Common Mistakes:

• Ignoring learning rate effects
• Assuming freezing all layers always improves
• Thinking training from scratch is better always

5. You want to fine-tune a pre-trained CNN for a new image classification task with 5 classes. Which sequence of steps is best practice?

hard

A. Train entire model from scratch with random weights for 5 classes

B. Freeze all layers, replace final layer with 5 outputs, train only final layer, then unfreeze some layers and fine-tune with low learning rate

C. Replace final layer with 5 outputs and train all layers at once with high learning rate

D. Freeze final layer, train earlier layers only, then unfreeze final layer

Solution

1. Step 1: Replace final layer for new classes

   Adjust output layer to match 5 classes for the new task.

2. Step 2: Freeze old layers and train new layer first

   This preserves learned features and trains new output layer quickly.

3. Step 3: Unfreeze some layers and fine-tune with low learning rate

   This improves model performance by adapting features carefully without large updates.

4. Final Answer:

   Freeze all layers, replace final layer with 5 outputs, train only final layer, then unfreeze some layers and fine-tune with low learning rate -> Option B

5. Quick Check:

   Stepwise fine-tuning with low LR = best practice [OK]

Hint: Freeze, replace output, train new layer, then unfreeze and fine-tune [OK]

Common Mistakes:

• Training all layers at once with high learning rate
• Training from scratch ignoring pre-trained weights
• Freezing final layer instead of earlier layers