Sequential model shortcut in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple PyTorch Sequential model

What is the output shape of the tensor after passing through this PyTorch Sequential model?

PyTorch

import torch
import torch.nn as nn

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

x = torch.randn(3, 10)
out = model(x)
print(out.shape)

A torch.Size([5, 2])

B torch.Size([3, 2])

C torch.Size([10, 2])

D torch.Size([3, 5])

💡 Hint

Remember the input batch size and the output size of the last Linear layer.

The input tensor has shape (3, 10). The first Linear layer outputs (3, 5), then ReLU keeps the shape, and the last Linear layer outputs (3, 2). So the final output shape is (3, 2).

❓ Model Choice

intermediate

Choosing the correct Sequential model for image flattening

Which PyTorch Sequential model correctly flattens a 28x28 grayscale image and outputs 10 class scores?

A nn.Sequential(nn.Flatten(), nn.Linear(28*28, 10))

B nn.Sequential(nn.Flatten(), nn.Linear(10, 28*28))

C nn.Sequential(nn.Conv2d(1, 10, 3), nn.Flatten())

D nn.Sequential(nn.Linear(28*28, 10), nn.Flatten())

💡 Hint

Flatten should come before Linear to convert 2D image to 1D vector.

Option A first flattens the 28x28 image into a vector of length 784, then applies a Linear layer to output 10 scores. Option A tries to flatten after Linear which is invalid. Option A uses Conv2d which changes shape differently. Option A outputs wrong size.

❓ Hyperparameter

advanced

Effect of changing hidden layer size in Sequential model

You have a Sequential model: nn.Sequential(nn.Linear(20, 50), nn.ReLU(), nn.Linear(50, 5)). What happens if you change the hidden layer size from 50 to 10?

A The input size must be changed to 10.

B The model will have more parameters and train slower.

C The output size changes from 5 to 10.

D The model has fewer parameters and may train faster but could underfit.

💡 Hint

Hidden layer size controls model capacity and parameter count.

Reducing hidden layer size from 50 to 10 reduces parameters, which can speed training but may reduce model capacity, risking underfitting. Output size remains 5, input size stays 20.

🔧 Debug

advanced

Identify the error in this Sequential model code

What error will this PyTorch code raise?

PyTorch

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

A TypeError because ReLU is not callable

B SyntaxError due to missing comma

C RuntimeError due to mismatched input size in second Linear layer

D No error, code runs fine

💡 Hint

Check the output size of first Linear and input size of second Linear.

The first Linear outputs size 20, but the second Linear expects input size 15, causing a runtime size mismatch error.

❓ Metrics

expert

Interpreting training loss and accuracy from Sequential model training

After training a PyTorch Sequential model for classification, you observe the following metrics: training loss decreases steadily, but training accuracy stays around 50%. What is the most likely explanation?

A The model is not learning useful features; possibly wrong labels or model too simple.

B The optimizer is not updating weights due to zero learning rate.

C The loss function is incorrect and does not reflect accuracy.

D The batch size is too large causing unstable training.

💡 Hint

Loss decreasing but accuracy stuck means model predictions improve but not enough to classify correctly.

If loss decreases but accuracy stays low, the model may be learning something but not enough to classify well. This can happen if labels are wrong or model capacity is insufficient.

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