torchvision pre-trained models in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output shape of pre-trained ResNet18 model

What is the shape of the output tensor when passing a batch of 8 RGB images of size 224x224 through a pre-trained ResNet18 model from torchvision?

PyTorch

import torch
import torchvision.models as models

model = models.resnet18(pretrained=True)
model.eval()

input_tensor = torch.randn(8, 3, 224, 224)
output = model(input_tensor)
output_shape = output.shape
print(output_shape)

A torch.Size([8, 512])

B torch.Size([8, 100])

C torch.Size([8, 1000])

D torch.Size([8, 2048])

💡 Hint

The pre-trained ResNet18 model outputs class scores for 1000 classes.

The pre-trained ResNet18 model outputs a tensor of shape (batch_size, 1000) representing the scores for 1000 ImageNet classes.

❓ Model Choice

intermediate

Choosing a model for feature extraction

You want to extract 512-dimensional feature vectors from images using a pre-trained torchvision model without the final classification layer. Which model and modification is correct?

A Use squeezenet and replace model.classifier with torch.nn.Linear(512, 1000)

B Use resnet18 and replace model.fc with torch.nn.Identity()

C Use vgg16 and replace model.features with torch.nn.Identity()

D Use alexnet and remove model.classifier entirely

💡 Hint

The final fully connected layer in ResNet18 is model.fc.

In ResNet18, the final classification layer is model.fc. Replacing it with Identity returns the 512-dimensional features before classification.

❓ Hyperparameter

advanced

Correct input normalization for pre-trained models

Which normalization mean and standard deviation values should be used to preprocess images before feeding them into any torchvision pre-trained model?

A mean=[0.406, 0.456, 0.485], std=[0.225, 0.224, 0.229]

B mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]

C mean=[0.0, 0.0, 0.0], std=[1.0, 1.0, 1.0]

D mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]

💡 Hint

These values are based on ImageNet dataset statistics.

All torchvision pre-trained models expect input images normalized with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].

❓ Metrics

advanced

Top-1 accuracy of pre-trained models on ImageNet validation

Which of the following is the closest reported Top-1 accuracy on ImageNet validation for the pre-trained torchvision DenseNet121 model?

A 74.9%

B 69.8%

C 77.0%

D 82.3%

💡 Hint

DenseNet121 accuracy is generally around mid-70s percent.

The DenseNet121 pre-trained model achieves about 74.9% Top-1 accuracy on ImageNet validation.

🔧 Debug

expert

Identifying error when loading pre-trained model weights

What error will occur if you try to load a pre-trained model with torchvision.models.resnet50(pretrained=False) and then call model.load_state_dict(torch.load('resnet50_weights.pth')) where the weights file contains pre-trained weights?

A RuntimeError: Error(s) in loading state_dict for ResNet

B FileNotFoundError: No such file or directory: 'resnet50_weights.pth'

C TypeError: load_state_dict() missing 1 required positional argument

D No error, model loads weights successfully

💡 Hint

Mismatch in model architecture or missing keys causes loading errors.

If the weights file does not exactly match the model architecture or keys, load_state_dict raises a RuntimeError with details about missing or unexpected keys.

Practice

1. What is the main advantage of using torchvision pre-trained models?

easy

A. They automatically improve your dataset quality.

B. They generate new images from text descriptions.

C. They reduce the size of your images.

D. They allow you to use powerful image models without training from scratch.

Solution

1. Step 1: Understand what pre-trained models do

   Pre-trained models are already trained on large datasets, so you don't need to train them from zero.

2. Step 2: Identify the main benefit

   This saves time and resources, letting you use powerful models quickly.

3. Final Answer:

   They allow you to use powerful image models without training from scratch. -> Option D

4. Quick Check:

   Pre-trained models = reuse trained weights [OK]

Hint: Pre-trained means ready to use without full training [OK]

Common Mistakes:

• Thinking pre-trained models improve data quality
• Confusing pre-trained models with image resizing
• Believing they generate images from text

2. Which of the following is the correct way to load a pre-trained ResNet18 model from torchvision?

easy

A. model = torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1)

B. model = torchvision.resnet18(pretrained=True)

C. model = torchvision.models.resnet18(pretrained=False)

D. model = torchvision.models.load_resnet18(pretrained=True)

Solution

1. Step 1: Recall the updated torchvision syntax

   Since torchvision 0.13+, pre-trained weights are loaded using the 'weights' argument with a weights enum, not 'pretrained=True'.

2. Step 2: Identify the correct syntax for ResNet18

   Use torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1).

3. Final Answer:

   model = torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1) -> Option A

4. Quick Check:

   Use weights=enum, not pretrained=True [OK]

Hint: Use weights= argument, not pretrained=True [OK]

Common Mistakes:

• Using pretrained=False which doesn't load pre-trained weights
• Calling torchvision.resnet18 directly
• Using a non-existent load_resnet18 function

3. What will be the output shape of the following code snippet using a pre-trained ResNet18 model on a batch of 8 RGB images of size 224x224?

import torch
import torchvision.models as models
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
model.eval()
inputs = torch.randn(8, 3, 224, 224)
outputs = model(inputs)
print(outputs.shape)

medium

A. torch.Size([8, 3, 224, 224])

B. torch.Size([8, 1000])

C. torch.Size([8, 512])

D. torch.Size([1, 1000])

Solution

1. Step 1: Understand ResNet18 output size

   ResNet18 pre-trained on ImageNet outputs logits for 1000 classes, so output shape is (batch_size, 1000).

2. Step 2: Check input batch size and output shape

   Input batch size is 8, so output shape is (8, 1000).

3. Final Answer:

   torch.Size([8, 1000]) -> Option B

4. Quick Check:

   Batch size 8, 1000 classes output [OK]

Hint: Output shape = (batch_size, number_of_classes) [OK]

Common Mistakes:

• Confusing output with input image shape
• Expecting feature vector size instead of class logits
• Assuming batch size 1 output

4. You wrote this code to use a pre-trained model for prediction but get wrong results:

model = torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1)
inputs = torch.randn(1, 3, 224, 224)
outputs = model(inputs)

What is the likely mistake?

medium

A. Input tensor shape should be (3, 224, 224) without batch dimension.

B. You need to set weights=None to use pre-trained weights.

C. You forgot to call model.eval() before prediction.

D. You must convert inputs to numpy arrays before passing to model.

Solution

1. Step 1: Check model mode for prediction

   Pre-trained models must be set to evaluation mode with model.eval() to disable dropout and batch norm updates.

2. Step 2: Identify the missing step

   The code misses model.eval(), so outputs may be incorrect or inconsistent.

3. Final Answer:

   You forgot to call model.eval() before prediction. -> Option C

4. Quick Check:

   Set model.eval() before inference [OK]

Hint: Always call model.eval() before predicting [OK]

Common Mistakes:

• Not calling model.eval() before inference
• Wrong input tensor shape without batch
• Trying to convert tensors to numpy before model

5. You want to fine-tune a pre-trained ResNet18 model on your own 5-class dataset. Which of the following code snippets correctly replaces the final layer for this task?

hard

A. model.fc = torch.nn.Linear(in_features=512, out_features=5)

B. model.classifier = torch.nn.Linear(in_features=1000, out_features=5)

C. model.fc = torch.nn.Linear(in_features=2048, out_features=5)

D. model.output = torch.nn.Linear(in_features=512, out_features=1000)

Solution

1. Step 1: Identify the final layer of ResNet18

   ResNet18's final fully connected layer is model.fc with input features 512 and output 1000 classes.

2. Step 2: Replace final layer for 5 classes

   To fine-tune, replace model.fc with a new Linear layer with 512 inputs and 5 outputs.

3. Final Answer:

   model.fc = torch.nn.Linear(in_features=512, out_features=5) -> Option A

4. Quick Check:

   Replace model.fc with correct output size [OK]

Hint: Replace model.fc with Linear(512, number_of_classes) [OK]

Common Mistakes:

• Replacing wrong attribute like model.classifier
• Using wrong input feature size (2048 instead of 512)
• Not changing output features to dataset classes