Why nn.Module organizes model code in PyTorch - Experiment to Prove It

Experiment - Why nn.Module organizes model code

Problem:You want to build a neural network model in PyTorch but your code is messy and hard to manage. You notice that using nn.Module helps organize the model code better.

Current Metrics:No specific accuracy metric yet, just messy code with repeated parts and unclear structure.

Issue:The model code is not organized, making it hard to reuse, debug, and extend. Without nn.Module, you manually write forward passes and parameter management, which is error-prone.

Your Task

Rewrite a simple neural network using nn.Module to organize the code clearly and correctly.

Use PyTorch and nn.Module class.

Define layers in __init__ and computation in forward method.

Do not change the model architecture or dataset.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

PyTorch

import torch
import torch.nn as nn
import torch.optim as optim

# Define a simple neural network using nn.Module
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 20)  # input layer to hidden
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(20, 2)   # hidden to output

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

# Create model instance
model = SimpleNN()

# Dummy input and target
X = torch.randn(5, 10)  # batch of 5 samples, 10 features each
Y = torch.randint(0, 2, (5,))  # batch of 5 labels (0 or 1)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# Training step
model.train()
optimizer.zero_grad()
outputs = model(X)
loss = criterion(outputs, Y)
loss.backward()
optimizer.step()

# Print loss to confirm code runs
print(f"Training loss: {loss.item():.4f}")

Created a class SimpleNN inheriting from nn.Module.

Moved layer definitions to __init__ method.

Implemented forward method for data flow.

Used model.parameters() for optimizer to manage weights automatically.

Changed super().__init__() to super(SimpleNN, self).__init__() for compatibility.

Results Interpretation

Before: Model code was scattered with manual layer calls and no clear structure.
After: Model code is clean, reusable, and easy to read with nn.Module organizing layers and forward pass.

Using nn.Module helps organize model code by grouping layers and computation in one place. It makes code easier to maintain, reuse, and extend.

Bonus Experiment

Add a dropout layer to the model using nn.Module to reduce overfitting.

💡 Hint

Add nn.Dropout in __init__ and apply it in forward between layers.

Practice

1. Why do we use nn.Module to organize model code in PyTorch?

easy

A. It replaces the need for Python functions.

B. It automatically writes the training loop for you.

C. It only helps with saving models, not training.

D. It groups layers and logic to simplify training and reuse.

Solution

1. Step 1: Understand the role of nn.Module

   nn.Module helps organize layers and the forward pass logic in one place.

2. Step 2: Recognize benefits for training and reuse

   This organization makes training, saving, and reusing models easier and cleaner.

3. Final Answer:

   It groups layers and logic to simplify training and reuse. -> Option D

4. Quick Check:

   nn.Module groups layers and logic = C [OK]

Hint: Remember: nn.Module bundles layers and logic together [OK]

Common Mistakes:

• Thinking nn.Module writes training loops automatically
• Believing nn.Module replaces all Python functions
• Assuming nn.Module only helps with saving models

2. Which part of a PyTorch nn.Module subclass should you use to define layers?

easy

A. Outside the class definition

B. Inside the forward method

C. Inside the __init__ method

D. Inside the train method

Solution

1. Step 1: Identify where layers are defined

   Layers must be created once when the model is built, so they go in __init__.

2. Step 2: Understand the role of forward

   forward defines how data moves through layers, not layer creation.

3. Final Answer:

   Inside the __init__ method -> Option C

4. Quick Check:

   Define layers in __init__ = A [OK]

Hint: Layers go in __init__, data flow in forward [OK]

Common Mistakes:

• Defining layers inside forward method
• Placing layers outside the class
• Using a non-existent train method for layers

3. Given this PyTorch model code, what will print(model(torch.ones(1, 3))) output?

import torch
import torch.nn as nn

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

model = SimpleModel()

medium

A. A tensor of shape (3, 2) with random values

B. A tensor of shape (1, 2) with values equal to linear output plus 1

C. An error because forward is missing

D. A tensor of zeros

Solution

1. Step 1: Analyze the model structure

   The model has a linear layer from 3 inputs to 2 outputs, then adds 1 to output.

2. Step 2: Understand the input and output shapes

   Input shape is (1,3), so output shape is (1,2). The output is linear(x) + 1.

3. Final Answer:

   A tensor of shape (1, 2) with values equal to linear output plus 1 -> Option B

4. Quick Check:

   Output shape (1,2) and adds 1 = B [OK]

Hint: Check layer shapes and operations in forward [OK]

Common Mistakes:

• Confusing input and output shapes
• Expecting an error due to missing forward
• Assuming output is zeros without computation

4. What is wrong with this PyTorch model code?

import torch.nn as nn

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

medium

A. Missing call to super().__init__() in __init__

B. forward method should not return anything

C. Layers should be defined inside forward, not __init__

D. nn.Linear requires 3 input features, not 4

Solution

1. Step 1: Check __init__ method correctness

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

2. Step 2: Verify other parts

   forward returns output correctly; layers are defined in __init__; input size 4 is valid.

3. Final Answer:

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

4. Quick Check:

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

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

Common Mistakes:

• Forgetting super().__init__() call
• Defining layers inside forward method
• Misunderstanding nn.Linear input size

5. You want to create a PyTorch model that has two linear layers and applies ReLU between them. How should you organize this using nn.Module?

hard

A. Define both linear layers in __init__ and apply ReLU in forward.

B. Define layers and ReLU calls inside forward only.

C. Define layers outside the class and call them in forward.

D. Use only one linear layer and apply ReLU twice in forward.

Solution

1. Step 1: Organize layers in __init__

   Both linear layers should be created once in __init__ to register parameters properly.

2. Step 2: Define data flow in forward

   Apply the first linear layer, then ReLU, then second linear layer inside forward.

3. Final Answer:

   Define both linear layers in __init__ and apply ReLU in forward. -> Option A

4. Quick Check:

   Layers in __init__, logic in forward = A [OK]

Hint: Layers in __init__, operations in forward [OK]

Common Mistakes:

• Defining layers inside forward causing re-creation
• Not using ReLU between layers
• Defining layers outside the class