Defining a model class in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the PyTorch module needed to define a model.

PyTorch

import torch.nn as [1]

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

Aoptim

Butils

Cnn

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'optim' instead of 'nn' for model definition.

Using 'data' which is for datasets, not models.

The 'nn' module in PyTorch contains classes to build neural network models.

2fill in blank

medium

Complete the code to define a model class that inherits from the correct PyTorch base class.

PyTorch

class MyModel([1]):
    def __init__(self):
        super().__init__()

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

Ann.Linear

Bnn.Module

Cnn.Parameter

Dnn.Sequential

Attempts:

3 left

💡 Hint

Common Mistakes

Inheriting from nn.Sequential which is a container, not a base class.

Using nn.Linear which is a layer, not a base class.

All PyTorch models should inherit from nn.Module to work properly.

3fill in blank

hard

Fix the error in the forward method definition by completing the method signature correctly.

PyTorch

def [1](self, x):
    return self.layer(x)

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

Arun

Bpredict

Ccall

Dforward

Attempts:

3 left

💡 Hint

Common Mistakes

Naming the method 'predict' which is not recognized by PyTorch.

Using 'call' or 'run' which are not valid method names here.

The forward method must be named 'forward' for PyTorch to know how to compute outputs.

4fill in blank

hard

Fill both blanks to define a linear layer with 10 inputs and 5 outputs inside the model's __init__ method.

PyTorch

self.layer = nn.[1]([2], 5)

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

ALinear

B10

CConv2d

DReLU

Attempts:

3 left

💡 Hint

Common Mistakes

Using Conv2d which is for images, not linear layers.

Putting the output size before the input size.

The linear layer is created with nn.Linear and input size 10 for 5 output features.

5fill in blank

hard

Fill all three blanks to complete the forward method that applies the linear layer and then a ReLU activation.

PyTorch

def forward(self, x):
    x = self.layer(x)
    x = nn.[1]()([2])
    return [3]

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

ASigmoid

Bx

CReLU

Dself

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sigmoid instead of ReLU as activation here.

Returning 'self' instead of the output tensor.

After the linear layer, ReLU activation is applied to x, and x is returned.

Practice

1. What is the main purpose of defining a model class in PyTorch?

easy

A. To automatically tune hyperparameters

B. To organize layers and define how data flows through the model

C. To store training data separately

D. To visualize the model architecture

Solution

1. Step 1: Understand the role of a model class

   In PyTorch, a model class helps organize the layers and defines the forward pass, which is how data flows through the model.

2. Step 2: Compare with other options

   Storing training data, tuning hyperparameters, or visualizing architecture are not the main purposes of defining the model class.

3. Final Answer:

   To organize layers and define how data flows through the model -> Option B

4. Quick Check:

   Model class = organize layers + data flow [OK]

Hint: Model class defines layers and data flow [OK]

Common Mistakes:

• Thinking model class stores data
• Confusing model class with training process
• Assuming model class tunes hyperparameters

2. Which of the following is the correct way to start defining a PyTorch model class?

easy

A. class MyModel(nn.Module):

B. class MyModel():

C. def MyModel(nn.Module):

D. model = nn.Module()

Solution

1. Step 1: Recall PyTorch model class syntax

   PyTorch models must inherit from nn.Module, so the class definition should be class MyModel(nn.Module):.

2. Step 2: Check other options

   class MyModel(): misses inheritance, C uses def instead of class, and D creates an instance, not a class.

3. Final Answer:

   class MyModel(nn.Module): -> Option A

4. Quick Check:

   Model class inherits nn.Module [OK]

Hint: Model class must inherit nn.Module [OK]

Common Mistakes:

• Forgetting to inherit nn.Module
• Using def instead of class
• Creating instance instead of class

3. Given this PyTorch model class snippet, what will print(model(torch.tensor([[1.0, 2.0]]))) output?

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(2, 1)
    def forward(self, x):
        return self.linear(x)

model = SimpleModel()
with torch.no_grad():
    model.linear.weight.fill_(1.0)
    model.linear.bias.fill_(0.0)

medium

A. tensor([[2.]])

B. RuntimeError due to wrong input shape

C. tensor([[0.]])

D. tensor([[3.]])

Solution

1. Step 1: Understand the model and weights

   The model has a linear layer with 2 inputs and 1 output. We set weights to 1.0 and bias to 0.0.

2. Step 2: Calculate output for input tensor

   Input is [[1.0, 2.0]]. The output is (1*1.0 + 2*1.0) + 0 = 3.0, so output tensor is [[3.0]].

3. Final Answer:

   tensor([[3.]]) -> Option D

4. Quick Check:

   Sum inputs * weights + bias = 3.0 [OK]

Hint: Sum inputs times weights plus bias for linear output [OK]

Common Mistakes:

• Ignoring bias value
• Mixing input shape
• Assuming default weights instead of set values

4. What is wrong with this PyTorch model class definition?

import torch.nn as nn

class BadModel(nn.Module):
    def __init__(self):
        self.linear = nn.Linear(3, 1)
    def forward(self, x):
        return self.linear(x)

medium

A. Class should not inherit from nn.Module

B. forward method should be named backward

C. Missing call to super().__init__() in __init__ method

D. nn.Linear should have input size 1, not 3

Solution

1. Step 1: Check __init__ method

   In PyTorch, the __init__ method must call super().__init__() to initialize the base nn.Module class.

2. Step 2: Verify other parts

   The forward method name is correct, input size 3 is valid, and inheriting nn.Module is required.

3. Final Answer:

   Missing call to super().__init__() in __init__ method -> Option C

4. Quick Check:

   Always call super().__init__() in __init__ [OK]

Hint: Always call super().__init__() in model __init__ [OK]

Common Mistakes:

• Forgetting super().__init__()
• Renaming forward method incorrectly
• Changing input size without reason

5. You want to define a PyTorch model class with two linear layers and a ReLU activation between them. Which code correctly implements this?

hard

A. class TwoLayerModel(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(4, 3)
self.layer2 = nn.Linear(3, 1)
self.relu = nn.ReLU()
def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
x = self.layer2(x)
return x

B. class TwoLayerModel(nn.Module):
def __init__(self):
self.layer1 = nn.Linear(4, 3)
self.layer2 = nn.Linear(3, 1)
self.relu = nn.ReLU()
def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
x = self.layer2(x)
return x

C. class TwoLayerModel(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(3, 4)
self.layer2 = nn.Linear(1, 3)
self.relu = nn.ReLU()
def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
x = self.layer2(x)
return x

D. class TwoLayerModel:
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(4, 3)
self.layer2 = nn.Linear(3, 1)
self.relu = nn.ReLU()
def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
x = self.layer2(x)
return x

Solution

1. Step 1: Check inheritance and super call

   class TwoLayerModel(nn.Module): def __init__(self): super().__init__() self.layer1 = nn.Linear(4, 3) self.layer2 = nn.Linear(3, 1) self.relu = nn.ReLU() def forward(self, x): x = self.layer1(x) x = self.relu(x) x = self.layer2(x) return x correctly inherits nn.Module and calls super().__init__(). class TwoLayerModel(nn.Module): def __init__(self): self.layer1 = nn.Linear(4, 3) self.layer2 = nn.Linear(3, 1) self.relu = nn.ReLU() def forward(self, x): x = self.layer1(x) x = self.relu(x) x = self.layer2(x) return x misses super().__init__(), and D does not inherit nn.Module.

2. Step 2: Verify layer sizes and forward method

   class TwoLayerModel(nn.Module): def __init__(self): super().__init__() self.layer1 = nn.Linear(4, 3) self.layer2 = nn.Linear(3, 1) self.relu = nn.ReLU() def forward(self, x): x = self.layer1(x) x = self.relu(x) x = self.layer2(x) return x uses correct input-output sizes (4->3, 3->1) and applies ReLU between layers. class TwoLayerModel(nn.Module): def __init__(self): super().__init__() self.layer1 = nn.Linear(3, 4) self.layer2 = nn.Linear(1, 3) self.relu = nn.ReLU() def forward(self, x): x = self.layer1(x) x = self.relu(x) x = self.layer2(x) return x has wrong layer sizes.

3. Final Answer:

   Option A correctly defines the model with two linear layers and ReLU -> Option A

4. Quick Check:

   Inherit nn.Module + super().__init__() + correct layers [OK]

Hint: Inherit nn.Module, call super().__init__(), correct layer sizes [OK]

Common Mistakes:

• Forgetting super().__init__()
• Wrong input-output sizes in layers
• Not inheriting nn.Module