Defining a model class in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple PyTorch model forward pass

What is the output shape of the tensor after running the forward method of this model with input shape (10, 5)?

PyTorch

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(5, 3)

    def forward(self, x):
        return self.linear(x)

model = SimpleModel()
input_tensor = torch.randn(10, 5)
output = model(input_tensor)
output_shape = output.shape
print(output_shape)

A torch.Size([10, 3])

B torch.Size([5, 3])

C torch.Size([10, 5])

D torch.Size([3, 10])

💡 Hint

Remember the linear layer changes the last dimension from input features to output features.

The input tensor has shape (10, 5). The linear layer maps 5 features to 3 features, so the output shape is (10, 3).

❓ Model Choice

intermediate

Choosing the correct model class definition

Which of the following PyTorch model class definitions correctly implements a model with one hidden layer of size 4 and ReLU activation?

A

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(4, 3)
        self.output = nn.Linear(3, 2)
    def forward(self, x):
        x = torch.relu(self.hidden(x))
        return self.output(x)

B

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(3, 4)
        self.output = nn.Linear(4, 2)
    def forward(self, x):
        x = self.hidden(x)
        x = torch.relu(self.output(x))
        return x

C

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(3, 2)
        self.output = nn.Linear(2, 4)
    def forward(self, x):
        x = torch.relu(self.hidden(x))
        return self.output(x)

D

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(3, 4)
        self.output = nn.Linear(4, 2)
    def forward(self, x):
        x = torch.relu(self.hidden(x))
        return self.output(x)

💡 Hint

Check the input and output sizes of each layer and the order of activation.

Option D correctly defines a hidden layer from 3 to 4 units, applies ReLU, then outputs from 4 to 2 units. Other options have incorrect layer sizes or apply activation after the output layer.

❓ Hyperparameter

advanced

Effect of changing hidden layer size in a model class

If you increase the hidden layer size from 10 to 100 in a fully connected PyTorch model, which of the following is a likely effect?

A The model will train faster because it has more neurons.

B The model will have more parameters and may overfit more easily.

C The model will always have worse accuracy due to overfitting.

D The model will use less memory during training.

💡 Hint

Think about how model size affects capacity and training behavior.

Increasing hidden layer size increases parameters, which can lead to overfitting if not controlled. It usually slows training and uses more memory.

🔧 Debug

advanced

Identify the error in this PyTorch model class

What error will this PyTorch model class raise when instantiated?

PyTorch

import torch.nn as nn

class FaultyModel(nn.Module):
    def __init__(self):
        self.linear = nn.Linear(5, 2)

    def forward(self, x):
        return self.linear(x)

model = FaultyModel()

A AttributeError because nn.Module __init__ is not called

B TypeError because forward method is missing

C SyntaxError due to missing colon

D No error, model instantiates correctly

💡 Hint

Check the __init__ method and superclass initialization.

The __init__ method does not call super().__init__(), so nn.Module is not properly initialized, causing AttributeError when accessing layers.

🧠 Conceptual

expert

Why define a model class instead of using nn.Sequential?

Which reason best explains why you might define a custom PyTorch model class instead of using nn.Sequential?

A Because custom classes always train faster than nn.Sequential models.

B Because nn.Sequential cannot be used with linear layers.

C To implement complex forward logic like multiple inputs, conditional operations, or loops.

D To avoid writing the forward method manually.

💡 Hint

Think about flexibility in model design and forward pass control.

Custom model classes allow you to write any forward pass logic, including conditionals and multiple inputs, which nn.Sequential cannot handle.