Model parameters inspection in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of model parameter count code

What is the output of the following PyTorch code that counts the total number of parameters in a simple linear model?

PyTorch

import torch
import torch.nn as nn

model = nn.Linear(3, 2)

param_count = sum(p.numel() for p in model.parameters())
print(param_count)

A 9

B 6

C 5

D 8

💡 Hint

Remember that nn.Linear has weights and biases. Weights shape is (out_features, in_features).

The linear layer has weights of shape (2,3) = 6 parameters and biases of shape (2,) = 2 parameters, total 8.

🧠 Conceptual

intermediate

Understanding requires_grad attribute

Which statement correctly describes the effect of setting requires_grad=False on a model parameter in PyTorch?

A The parameter will not be updated during training because gradients are not computed for it.

B The parameter will be updated normally but gradients will be zero.

C The parameter will cause an error during backpropagation.

D The parameter will be frozen but still receive gradient updates.

💡 Hint

Think about what happens when gradients are not computed for a parameter.

If requires_grad=False, PyTorch does not compute gradients for that parameter, so optimizer does not update it.

❓ Metrics

advanced

Inspecting model parameter shapes

Given the following PyTorch model, what is the shape of the parameter named 'fc2.weight'?

PyTorch

import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 2)

model = SimpleNN()
print(model.fc2.weight.shape)

A torch.Size([5, 2])

B torch.Size([2, 5])

C torch.Size([10, 5])

D torch.Size([5, 10])

💡 Hint

Recall that nn.Linear weight shape is (out_features, in_features).

fc2 is Linear(5, 2), so weight shape is (2, 5).

🔧 Debug

advanced

Identifying error when accessing model parameters

What error will the following code raise when trying to access a non-existent parameter 'fc3.weight' in a PyTorch model?

PyTorch

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(4, 3),
    nn.ReLU(),
    nn.Linear(3, 2)
)

param = dict(model.named_parameters())['fc3.weight']

A KeyError

B AttributeError

C TypeError

D IndexError

💡 Hint

Check what keys are in the named_parameters dictionary.

The model has no parameter named 'fc3.weight', so accessing it raises KeyError.

❓ Model Choice

expert

Choosing model to inspect parameters for convolutional layers

You want to inspect the parameters of a convolutional neural network with two Conv2d layers. Which model definition will allow you to correctly access the weight tensor of the second convolutional layer as 'conv2.weight'?

A

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Conv2d(1, 16, 3)
        self.layer2 = nn.Conv2d(16, 32, 3)

model = CNN()

B

model = nn.Sequential(
    nn.Conv2d(1, 16, 3),
    nn.Conv2d(16, 32, 3)
)

# Access conv2.weight

C

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, 3)
        self.conv2 = nn.Conv2d(16, 32, 3)

model = CNN()

D

model = nn.ModuleList([
    nn.Conv2d(1, 16, 3),
    nn.Conv2d(16, 32, 3)
])

# Access conv2.weight

💡 Hint

Only named attributes can be accessed by their names directly.

Only in option C the second conv layer is named 'conv2', so model.conv2.weight works.

Practice

1. What does the named_parameters() method in a PyTorch model return?

easy

A. The optimizer's learning rate

B. An iterator over tuples of parameter names and their tensors

C. The model's training loss values

D. A list of all model layers

Solution

1. Step 1: Understand the purpose of named_parameters()

   This method is designed to give access to each parameter's name and its tensor, which includes weights and biases.

2. Step 2: Identify what it returns

   It returns an iterator over tuples, where each tuple contains the parameter's name and the tensor itself.

3. Final Answer:

   An iterator over tuples of parameter names and their tensors -> Option B

4. Quick Check:

   named_parameters() = iterator of (name, tensor) [OK]

Hint: Remember: named_parameters() lists names and tensors [OK]

Common Mistakes:

• Confusing parameters with layers
• Thinking it returns loss or optimizer info
• Assuming it returns just tensors without names

2. Which of the following code snippets correctly prints the names and shapes of all parameters in a PyTorch model model?

easy

A. for name, param in model.named_parameters(): print(name, param.shape)

B. for param in model.parameters(): print(param.name, param.shape)

C. print(model.parameters().names())

D. model.print_parameters()

Solution

1. Step 1: Check correct method usage

   The method named_parameters() returns (name, parameter) pairs, so unpacking into two variables is correct.

2. Step 2: Verify printing name and shape

   Accessing param.shape gives the tensor shape. for name, param in model.named_parameters(): print(name, param.shape) correctly prints both.

3. Final Answer:

   for name, param in model.named_parameters(): print(name, param.shape) -> Option A

4. Quick Check:

   Use named_parameters() with unpacking [OK]

Hint: Use named_parameters() to get names and tensors [OK]

Common Mistakes:

• Trying to access .name on param tensor (no such attribute)
• Using parameters() without names
• Calling non-existent methods like print_parameters()

3. Given the following PyTorch model code, what will be the output of the print statement?

import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 3)
        self.fc2 = nn.Linear(3, 2)

model = SimpleNet()
params = list(model.named_parameters())
print(len(params))

medium

A. 2

B. 6

C. 4

D. 3

Solution

1. Step 1: Count parameters in each layer

   Each nn.Linear has weights and biases, so 2 parameters per layer.

2. Step 2: Calculate total parameters

   Two layers x 2 parameters each = 4 parameters total.

3. Final Answer:

   4 -> Option C

4. Quick Check:

   2 layers x 2 params = 4 [OK]

Hint: Each Linear layer has weight and bias parameters [OK]

Common Mistakes:

• Counting only layers, not parameters
• Assuming one parameter per layer
• Confusing number of parameters with tensor sizes

4. You wrote this code to print model parameter names and shapes but get an error:

for name, param in model.parameters():
    print(name, param.shape)

What is the error and how to fix it?

medium

A. The loop syntax is wrong; use for param, name in model.parameters()

B. param.shape is invalid; use param.size() instead

C. You must call model.parameters().items() to get name and param

D. model.parameters() returns tensors only; use model.named_parameters() to get names

Solution

1. Step 1: Understand what model.parameters() returns

   This method returns only parameter tensors, no names.

2. Step 2: Correct method to get names and parameters

   Use model.named_parameters() which returns (name, param) pairs.

3. Final Answer:

   model.parameters() returns tensors only; use model.named_parameters() to get names -> Option D

4. Quick Check:

   parameters() = tensors only, named_parameters() = (name, tensor) [OK]

Hint: Use named_parameters() to get names with tensors [OK]

Common Mistakes:

• Trying to unpack parameters() into name and param
• Using .items() on parameters() which is not a dict
• Swapping variable order in for loop

5. You want to calculate the total number of trainable parameters in a PyTorch model model. Which code snippet correctly computes this?

hard

A. sum(p.numel() for p in model.parameters() if p.requires_grad)

B. len(model.named_parameters())

C. sum(p.shape for p in model.parameters())

D. model.count_parameters()

Solution

1. Step 1: Understand what counts as trainable parameters

   Only parameters with requires_grad=True are trainable.

2. Step 2: Use numel() to count elements in each tensor

   Summing p.numel() for all trainable parameters gives total count.

3. Final Answer:

   sum(p.numel() for p in model.parameters() if p.requires_grad) -> Option A

4. Quick Check:

   Sum numel() of trainable params = total count [OK]

Hint: Sum numel() of parameters with requires_grad True [OK]

Common Mistakes:

• Using len() which counts parameters, not elements
• Trying to sum shapes directly (shapes are tuples)
• Assuming model has count_parameters() method