Defining a model class in PyTorch

Introduction

We define a model class to create a reusable and clear structure for our machine learning model. This helps us organize layers and how data flows through them.

When you want to build a neural network with multiple layers.

When you need to customize how data moves through your model.

When you want to reuse the same model structure with different data.

When you want to save and load your model easily.

When you want to experiment with different model designs.

Syntax

PyTorch

import torch.nn as nn

class ModelName(nn.Module):
    def __init__(self):
        super(ModelName, self).__init__()
        # Define layers here

    def forward(self, x):
        # Define data flow here
        return x

The class inherits from nn.Module, which is the base for all models in PyTorch.

The __init__ method sets up layers, and forward defines how input moves through them.

Examples

A simple model with one linear layer that changes input size from 10 to 5.

PyTorch

import torch.nn as nn

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

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

A model with two layers and a ReLU activation between them.

PyTorch

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

class TwoLayerNN(nn.Module):
    def __init__(self):
        super(TwoLayerNN, self).__init__()
        self.layer1 = nn.Linear(8, 4)
        self.layer2 = nn.Linear(4, 2)

    def forward(self, x):
        x = self.layer1(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Sample Model

This code defines a simple model with one linear layer and softmax output. It runs the model on two input samples and prints the probabilities.

PyTorch

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

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

    def forward(self, x):
        x = self.fc1(x)
        return F.softmax(x, dim=1)

# Create model instance
model = SimpleModel()

# Sample input tensor with batch size 2 and 3 features
input_tensor = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

# Get model output
output = model(input_tensor)
print(output)

Important Notes

Always call super().__init__() in your model's __init__ method to initialize the base class.

The forward method is where you describe how input data moves through layers.

Use nn.functional for activation functions like relu or softmax inside forward.

Summary

Defining a model class helps organize layers and data flow clearly.

Inherit from nn.Module and implement __init__ and forward methods.

Use the model by creating an instance and passing input tensors to it.

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