Model parameters inspection in PyTorch

Introduction

We look at model parameters to understand what the model has learned and to check its size. This helps us know how complex the model is.

When you want to see the weights and biases of a neural network layer.

To check if the model parameters are updating during training.

To count how many parameters your model has to estimate its size.

When debugging to ensure layers are connected correctly.

To save or load specific parts of a model.

Syntax

PyTorch

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

model.named_parameters() gives you the name and value of each parameter.

param.shape shows the size of the parameter tensor.

Examples

This prints only the names of all parameters in the model.

PyTorch

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

This prints the actual values (weights) stored in each parameter.

PyTorch

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

This counts and prints the total number of parameters in the model.

PyTorch

total_params = sum(param.numel() for param in model.parameters())
print(f"Total parameters: {total_params}")

Sample Model

This code creates a small neural network with two layers. It then prints each parameter's name, shape, and if it will update during training. Finally, it counts all parameters.

PyTorch

import torch
import torch.nn as nn

# Define a simple model
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 3)
        self.fc2 = nn.Linear(3, 1)

    def forward(self, x):
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.fc2(x)
        return x

model = SimpleModel()

# Inspect parameters
for name, param in model.named_parameters():
    print(f"{name}: shape={param.shape}, requires_grad={param.requires_grad}")

# Count total parameters
total_params = sum(param.numel() for param in model.parameters())
print(f"Total parameters: {total_params}")

Important Notes

Parameters with requires_grad=True will be updated during training.

You can freeze parameters by setting param.requires_grad = False.

Inspecting parameters helps in debugging and understanding model size.

Summary

Model parameters include weights and biases that the model learns.

You can list parameters with their names and shapes using named_parameters().

Counting parameters helps estimate model complexity and memory needs.

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