Defining a model class in PyTorch - ML Experiment: Train & Evaluate

Experiment - Defining a model class

Problem:You want to create a simple neural network model class in PyTorch to classify images from the MNIST dataset.

Current Metrics:Training accuracy: 85%, Validation accuracy: 82%, Training loss: 0.45, Validation loss: 0.50

Issue:The current model is defined using a sequential container only, which limits flexibility for future changes and custom layers.

Your Task

Define a PyTorch model class that inherits from nn.Module with an __init__ method and a forward method to build the same model architecture.

Use nn.Module inheritance.

Include at least one hidden layer with ReLU activation.

Output layer must have 10 units for 10 classes.

Do not change the model architecture or training code.

Hint 1

Hint 2

Hint 3

Solution

PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleMNISTModel(nn.Module):
    def __init__(self):
        super(SimpleMNISTModel, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # input layer to hidden
        self.fc2 = nn.Linear(128, 10)     # hidden to output

    def forward(self, x):
        x = x.view(x.size(0), -1)  # flatten images
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Example usage:
# model = SimpleMNISTModel()
# output = model(torch.randn(64, 1, 28, 28))  # batch of 64 images

Created a class SimpleMNISTModel inheriting from nn.Module.

Defined __init__ method to initialize two linear layers.

Defined forward method to flatten input, apply first layer with ReLU, then output layer.

Replaced sequential container with explicit layer definitions for flexibility.

Results Interpretation

Before: Model was defined using nn.Sequential, limiting customization.
After: Model is a class with explicit layers and forward method, allowing easy changes and better understanding.

Training and validation metrics remain the same, confirming the model architecture is unchanged.

Defining a model as a class in PyTorch gives you full control over the model's structure and data flow, which is essential for building more complex or custom models.

Bonus Experiment

Add a dropout layer after the first hidden layer to reduce overfitting.

💡 Hint

Use nn.Dropout in __init__ and apply it in forward after ReLU activation.

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