Build with nn.Sequential

easyPROModelingPyTorch ModelingPytorch

Problem Statement

Build a neural network using the nn.Sequential container.

Background

nn.Sequential is a convenient container for building simple feed-forward networks. Modules are added in order, and each module's output is automatically passed as input to the next.

Your Task

Write a function build_sequential_net(input_size, hidden_size, output_size) that builds a two-layer network with a ReLU activation between them and returns a dictionary describing it.

Output Format

Return a dictionary with keys: "num_layers" (int), "output_shape" (list — shape for a single sample), "has_relu" (boolean).

Example

Input

input_size=784, hidden_size=128, output_size=10

Output

{'num_layers': 3, 'output_shape': [1, 10], 'has_relu': True}

Reasoning

Inputs: input_size $=784$ is the length of one flattened sample, hidden_size $=128$ is the width of the middle representation, and output_size $=10$ is the number of scores produced.
Stage 1 (affine): a single sample is a $1 \times 784$ row $x$ . Multiplying by a $784 \times 128$ weight matrix and adding a bias gives $h = xW_1 + b_1$ , a $1 \times 128$ row ( $784 \cdot 128 + 128 = 100{,}480$ learnable numbers).
Stage 2 (activation): each entry becomes $\max(0, h_j)$ . Negatives turn into $0$ , the shape stays $1 \times 128$ , and nothing here is learned, yet it still counts as a stage.
Stage 3 (affine): $y = \max(0,h)\,W_2 + b_2$ with $W_2$ of size $128 \times 10$ , so $y$ is $1 \times 10$ ( $1{,}290$ learnable numbers).
Output: three stages gives 'num_layers': 3; the final row gives 'output_shape': [1, 10] (the leading $1$ is the single sample); the rectifier stage is present, so 'has_relu': True.
Notice that hidden_size never shows up in the result: $(10, 20, 5)$ still yields 3 stages and shape $[1, 5]$ . Only the last dimension tracks output_size.

Constraints

Use nn.Sequential
Include nn.Linear and nn.ReLU
Network: Linear → ReLU → Linear

Learn this in

PyTorch FundamentalsFoundations

More from Pytorch

Apply Softmax for Predictionseasy Count Model Parametersmedium Use nn.Flatten Layereasy Create a Simple Neural Network Classeasy Compose Multiple Transformsmedium

Concept primerPREVIEW

1. Background Knowledge

PyTorch nn.Sequential is a container that chains modules sequentially, automatically passing each module's output as input to the next. This is ideal for feed-forward neural networks where data flows linearly without branches or loops.

Key Components:

nn.Linear(in_features, out_features): Fully connected layer performing $y = xW^T + b$ , where $W \in \mathbb{R}^{$ \text{out} $\times$ \text{in} $}$ , $b \in \mathbb{R}^{$ \text{out} $}$ .
nn.ReLU(): Rectified Linear Unit activation, $f(x) = \max(0, x)$ , introducing non-linearity.
Network Architecture: Input → Linear → ReLU → Linear → Output, forming a 2-layer MLP (Multi-Layer Perceptron).

Mathematical Forward Pass:

Input: x ∈ ℝ^(1, input_size)
Hidden: h = ReLU(x * W₁^T + b₁), h ∈ ℝ^(1, hidden_size)
Output: y = h * W₂^T + b₂, y ∈ ℝ^(1, output_size)

Prerequisites: Basic PyTorch tensor operations, torch.nn module imports, tensor shape manipulation.

2. Algorithm Approach

Direct Construction Pattern:

Import torch.nn as nn
Create nn.Sequential([nn.Linear(...), nn.ReLU(), nn.Linear(...)])
Analyze properties: len(sequential) for layer count, torch.no_grad() inference for shape

Why Sequential? Enables modular, readable network definition vs. manual forward() method.

3. Step-by-Step Strategy

def build_sequential_net(input_size, hidden_size, output_size):
 # Step 1: Build Sequential network
 net = nn.Sequential(
 nn.Linear(input_size, hidden_size), # Layer 1
 nn.ReLU(), # Activation
 nn.Linear(hidden_size, output_size) # Layer 2
 )

 # Step 2: Count layers (3 modules total)
 num_layers = len(net)

 # Step 3: Get output shape for input (1, input_size)
 with torch.no_grad():
 sample_input = torch.randn(1, input_size)
 output = net(sample_input)
 output_shape = list(output.shape)

 # Step 4: Check for ReLU (inspect modules)
 has_relu = any(isinstance(m, nn.ReLU) for m in net)

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results