Sequential model shortcut in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple sequential model with one linear layer.

PyTorch

import torch.nn as nn
model = nn.Sequential(nn.Linear(10, [1]))

Drag options to blanks, or click blank then click option'

A5

B10

C15

D20

Attempts:

3 left

💡 Hint

Common Mistakes

Using the input size instead of output size for the second argument.

Confusing input and output dimensions.

The linear layer output size is set to 5, which matches the intended model design.

2fill in blank

medium

Complete the code to add a ReLU activation after the linear layer in the sequential model.

PyTorch

import torch.nn as nn
model = nn.Sequential(
    nn.Linear(10, 5),
    [1]()
)

Drag options to blanks, or click blank then click option'

ASigmoid

BTanh

CSoftmax

DReLU

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sigmoid or Softmax which are less common for hidden layers.

Forgetting to add parentheses after the activation class.

ReLU is a common activation function used after linear layers to add non-linearity.

3fill in blank

hard

Fix the error in the code to correctly create a sequential model with two layers.

PyTorch

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

Drag options to blanks, or click blank then click option'

AConv2d

BDropout

CLinear

DBatchNorm1d

Attempts:

3 left

💡 Hint

Common Mistakes

Using Conv2d which expects image data.

Using BatchNorm1d or Dropout incorrectly as a layer with input/output sizes.

The second linear layer should be nn.Linear to connect 5 inputs to 2 outputs.

4fill in blank

hard

Fill both blanks to create a sequential model with two linear layers and a ReLU activation in between.

PyTorch

import torch.nn as nn
model = nn.Sequential(
    nn.[1](10, 8),
    nn.[2](),
    nn.Linear(8, 3)
)

Drag options to blanks, or click blank then click option'

ALinear

BReLU

CSigmoid

DDropout

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sigmoid instead of ReLU for activation.

Using Dropout instead of activation.

The first blank is 'Linear' to create the first layer, the second blank is 'ReLU' for activation.

5fill in blank

hard

Fill all three blanks to build a sequential model with two linear layers, a ReLU activation, and a dropout layer.

PyTorch

import torch.nn as nn
model = nn.Sequential(
    nn.[1](12, 10),
    nn.[2](),
    nn.[3](p=0.3),
    nn.Linear(10, 4)
)

Drag options to blanks, or click blank then click option'

ALinear

BReLU

CDropout

DBatchNorm1d

Attempts:

3 left

💡 Hint

Common Mistakes

Using BatchNorm1d instead of Dropout for regularization.

Forgetting to add parentheses after the class names.

The model has a Linear layer, followed by ReLU activation, then Dropout with 0.3 probability.

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