Sequential model shortcut in PyTorch

Introduction

We use the Sequential model shortcut to quickly build a simple chain of layers in a neural network without writing extra code for each step.

When you want to create a simple neural network with layers stacked one after another.

When you need a quick way to test ideas without writing a full class for the model.

When your model has a straight flow from input to output without branches or loops.

Syntax

PyTorch

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(input_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, output_size)
)

The layers are passed as arguments inside nn.Sequential in the order they connect.

This shortcut works well for simple feed-forward networks.

Examples

A model with input size 10, one hidden layer of size 5, and output size 2.

PyTorch

model = nn.Sequential(
    nn.Linear(10, 5),
    nn.ReLU(),
    nn.Linear(5, 2)
)

A simple convolutional model for 28x28 images with 1 channel.

PyTorch

model = nn.Sequential(
    nn.Conv2d(1, 16, 3),
    nn.ReLU(),
    nn.Flatten(),
    nn.Linear(16*26*26, 10)
)

Sample Model

This code builds a simple Sequential model with two linear layers and ReLU in between. It runs a forward pass on sample data, calculates mean squared error loss, and performs one optimization step.

PyTorch

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

# Create a simple Sequential model
model = nn.Sequential(
    nn.Linear(4, 3),
    nn.ReLU(),
    nn.Linear(3, 2)
)

# Sample input tensor (batch size 2, features 4)
x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                  [4.0, 3.0, 2.0, 1.0]])

# Forward pass
output = model(x)

# Print output
print("Model output:")
print(output)

# Define dummy target and loss
target = torch.tensor([[0.0, 1.0], [1.0, 0.0]])
criterion = nn.MSELoss()
loss = criterion(output, target)
print(f"Loss: {loss.item():.4f}")

# Backward pass
optimizer = optim.SGD(model.parameters(), lr=0.01)
optimizer.zero_grad()
loss.backward()
optimizer.step()

Important Notes

Sequential models are easy to build but not flexible for complex architectures like multiple inputs or outputs.

Use nn.Sequential only when the data flows straight through layers.

Summary

Sequential shortcut helps build simple neural networks fast.

It stacks layers in order without extra code.

Good for beginners and quick experiments.

Practice

1. What is the main advantage of using torch.nn.Sequential in PyTorch?

easy

A. It allows stacking layers quickly without writing a forward method.

B. It automatically tunes hyperparameters during training.

C. It visualizes the model architecture graphically.

D. It replaces the need for a loss function.

Solution

1. Step 1: Understand what Sequential does

   torch.nn.Sequential stacks layers in order and handles the forward pass automatically.

2. Step 2: Compare other options

   Hyperparameter tuning, visualization, and replacing the loss function are not features of Sequential.

3. Final Answer:

   It allows stacking layers quickly without writing a forward method. -> Option A

4. Quick Check:

   Sequential = quick layer stacking [OK]

Hint: Sequential stacks layers; no manual forward needed [OK]

Common Mistakes:

• Thinking Sequential tunes hyperparameters
• Confusing Sequential with visualization tools
• Assuming Sequential replaces loss functions

2. Which of the following is the correct way to create a simple feedforward network with two linear layers using torch.nn.Sequential?

easy

A. model = nn.Sequential(nn.Linear(10, 5) nn.ReLU() nn.Linear(5, 2))

B. model = nn.Sequential([nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 2)])

C. model = nn.Sequential(nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 2))

D. model = nn.Sequential{nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 2)}

Solution

1. Step 1: Check correct syntax for Sequential

   nn.Sequential takes layers as separate arguments, separated by commas and enclosed in parentheses.

2. Step 2: Identify syntax errors in other options

   A misses commas between layers causing a syntax error, B uses a list which is invalid here, C uses curly braces which is wrong.

3. Final Answer:

   model = nn.Sequential(nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 2)) -> Option C

4. Quick Check:

   Sequential layers separated by commas in parentheses [OK]

Hint: Use commas between layers inside parentheses [OK]

Common Mistakes:

• Using square brackets inside Sequential
• Using curly braces instead of parentheses
• Forgetting commas between layers

3. Given the following code, what will be the output shape of output?

import torch
import torch.nn as nn
model = nn.Sequential(
    nn.Linear(4, 3),
    nn.ReLU(),
    nn.Linear(3, 2)
)
input = torch.randn(5, 4)
output = model(input)
print(output.shape)

medium

A. torch.Size([4, 2])

B. torch.Size([5, 3])

C. torch.Size([5, 4])

D. torch.Size([5, 2])

Solution

1. Step 1: Analyze input and first layer

   Input shape is (5,4). First Linear layer maps 4 features to 3, so output shape becomes (5,3).

2. Step 2: Analyze second Linear layer output

   Second Linear layer maps 3 features to 2, so final output shape is (5,2).

3. Final Answer:

   torch.Size([5, 2]) -> Option D

4. Quick Check:

   Input batch 5, final features 2 [OK]

Hint: Track input batch size and final layer output features [OK]

Common Mistakes:

• Confusing input and output feature sizes
• Ignoring batch dimension
• Assuming ReLU changes shape

4. What is wrong with this PyTorch Sequential model code?

import torch.nn as nn
model = nn.Sequential(
    nn.Linear(10, 5),
    nn.ReLU,
    nn.Linear(5, 2)
)

medium

A. Missing parentheses after nn.ReLU causing a type error.

B. Linear layers have wrong input-output sizes.

C. Sequential cannot contain activation functions.

D. Model should be defined using nn.Module subclass.

Solution

1. Step 1: Check usage of nn.ReLU

   nn.ReLU is a class; it must be called with parentheses to create an instance.

2. Step 2: Verify other options

   Linear layers sizes are compatible, Sequential supports activations, and subclassing is optional.

3. Final Answer:

   Missing parentheses after nn.ReLU causing a type error. -> Option A

4. Quick Check:

   Activation needs parentheses () [OK]

Hint: Always add () after activation layers [OK]

Common Mistakes:

• Forgetting () after activation functions
• Thinking Sequential disallows activations
• Believing subclassing is mandatory

5. You want to build a neural network with three layers: input size 8, hidden size 4, and output size 1. You also want to add dropout after the first layer and use ReLU activations. Which nn.Sequential model correctly implements this?

hard

A. nn.Sequential(nn.Linear(8,4), nn.ReLU, nn.Dropout(0.5), nn.Linear(4,1))

B. nn.Sequential(nn.Linear(8,4), nn.Dropout(0.5), nn.ReLU(), nn.Linear(4,1))

C. nn.Sequential(nn.Linear(8,4), nn.ReLU(), nn.Linear(4,1), nn.Dropout(0.5))

D. nn.Sequential(nn.Dropout(0.5), nn.Linear(8,4), nn.ReLU(), nn.Linear(4,1))

Solution

1. Step 1: Check layer order and activations

   Dropout should come after the first Linear layer and before ReLU to randomly drop activations during training.

2. Step 2: Verify correct usage of activations and dropout

   nn.Sequential(nn.Linear(8,4), nn.Dropout(0.5), nn.ReLU(), nn.Linear(4,1)) correctly uses nn.ReLU() with parentheses and places dropout before ReLU. Other options either miss parentheses or misplace dropout.

3. Final Answer:

   nn.Sequential(nn.Linear(8,4), nn.Dropout(0.5), nn.ReLU(), nn.Linear(4,1)) -> Option B

4. Quick Check:

   Dropout after Linear, before ReLU, with () [OK]

Hint: Dropout after Linear, before ReLU, use () for activations [OK]

Common Mistakes:

• Placing dropout after output layer
• Forgetting parentheses on ReLU
• Putting dropout before first Linear layer