Training loop structure in PyTorch

Introduction

A training loop helps a model learn from data by repeating steps many times. It updates the model to make better predictions.

When you want to teach a model to recognize images.

When you need to improve a model's predictions on new data.

When training a model to understand text or speech.

When adjusting model weights to reduce errors.

When running experiments to compare different models.

Syntax

PyTorch

for epoch in range(num_epochs):
    for inputs, labels in dataloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = loss_function(outputs, labels)
        loss.backward()
        optimizer.step()

The outer loop runs over epochs (full passes over data).

The inner loop runs over batches of data for efficiency.

Examples

Basic training loop running 5 epochs over batches from train_loader.

PyTorch

for epoch in range(5):
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

Training loop with loss tracking and printing average loss per epoch.

PyTorch

for epoch in range(3):
    total_loss = 0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {total_loss/len(train_loader):.4f}")

Sample Model

This program trains a simple linear model on random data for 3 epochs. It prints the average loss after each epoch to show learning progress.

PyTorch

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Simple dataset: inputs and labels
inputs = torch.randn(100, 3)
labels = torch.randn(100, 1)

dataset = TensorDataset(inputs, labels)
train_loader = DataLoader(dataset, batch_size=10)

# Simple model: one linear layer
model = nn.Linear(3, 1)

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

num_epochs = 3

for epoch in range(num_epochs):
    total_loss = 0
    for batch_inputs, batch_labels in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_inputs)
        loss = criterion(outputs, batch_labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    avg_loss = total_loss / len(train_loader)
    print(f"Epoch {epoch+1}, Loss: {avg_loss:.4f}")

Important Notes

Always call optimizer.zero_grad() before loss.backward() to reset gradients.

Use batches to speed up training and use less memory.

Printing loss helps see if the model is learning or stuck.

Summary

A training loop repeats over data to improve the model.

It has two loops: epochs and batches.

Key steps: zero gradients, forward pass, compute loss, backward pass, update weights.

Practice

1. Which of the following best describes the main purpose of a training loop in PyTorch?

easy

A. To save the model to a file

B. To repeatedly update the model weights to improve performance

C. To visualize the model architecture

D. To load data from disk into memory

Solution

1. Step 1: Understand the training loop role

   The training loop runs many times to adjust model weights based on data.

2. Step 2: Identify the main goal

   Its goal is to improve model performance by updating weights repeatedly.

3. Final Answer:

   To repeatedly update the model weights to improve performance -> Option B

4. Quick Check:

   Training loop = update weights repeatedly [OK]

Hint: Training loop = repeat updates to improve model [OK]

Common Mistakes:

• Confusing data loading with training loop
• Thinking training loop saves model
• Assuming training loop only visualizes model

2. Which of the following is the correct way to zero gradients in a PyTorch training loop?

easy

A. optimizer.zero_grad()

B. model.zero_gradients()

C. loss.zero_grad()

D. torch.zero_grad()

Solution

1. Step 1: Recall PyTorch gradient clearing method

   Gradients are cleared by calling zero_grad() on the optimizer.

2. Step 2: Check each option

   Only optimizer.zero_grad() is the correct PyTorch syntax.

3. Final Answer:

   optimizer.zero_grad() -> Option A

4. Quick Check:

   Clear gradients with optimizer.zero_grad() [OK]

Hint: Clear gradients with optimizer.zero_grad() [OK]

Common Mistakes:

• Calling zero_grad on model or loss
• Using non-existent torch.zero_grad()
• Forgetting to zero gradients before backward pass

3. What will be the output of the following PyTorch training loop snippet?

for epoch in range(2):
    for batch in range(3):
        print(f"Epoch {epoch}, Batch {batch}")

medium

A. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 1, Batch 0
Epoch 1, Batch 1

B. Epoch 0, Batch 0
Epoch 1, Batch 0
Epoch 2, Batch 0

C. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 0, Batch 2

D. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 0, Batch 2
Epoch 1, Batch 0
Epoch 1, Batch 1
Epoch 1, Batch 2

Solution

1. Step 1: Understand loop ranges

   Outer loop runs for epochs 0 and 1 (2 times). Inner loop runs for batches 0,1,2 (3 times).

2. Step 2: Trace output lines

   For each epoch, batches 0 to 2 print, so total 6 lines with epoch and batch numbers.

3. Final Answer:

   Epoch 0, Batch 0 Epoch 0, Batch 1 Epoch 0, Batch 2 Epoch 1, Batch 0 Epoch 1, Batch 1 Epoch 1, Batch 2 -> Option D

4. Quick Check:

   2 epochs x 3 batches = 6 lines printed [OK]

Hint: Multiply epochs by batches for total prints [OK]

Common Mistakes:

• Confusing range end values
• Mixing epoch and batch indices
• Counting fewer batches than loop runs

4. Identify the error in this PyTorch training loop snippet:

for data, target in dataloader:
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward
    optimizer.step()

medium

A. Missing parentheses after loss.backward

B. optimizer.zero_grad() should be after optimizer.step()

C. criterion should be called before model(data)

D. optimizer.step() should be called before loss.backward

Solution

1. Step 1: Check method calls

   loss.backward is missing parentheses, so it is not called as a function.

2. Step 2: Verify correct order

   optimizer.zero_grad() is correctly before backward and step; criterion call order is correct; optimizer.step() after backward is correct.

3. Final Answer:

   Missing parentheses after loss.backward -> Option A

4. Quick Check:

   Call loss.backward() with parentheses [OK]

Hint: Always add () to call backward() [OK]

Common Mistakes:

• Forgetting parentheses on backward()
• Changing correct optimizer.zero_grad() position
• Misordering loss and model calls

5. You want to train a model for 5 epochs with batches of size 10. Which of the following training loop structures correctly implements this in PyTorch?

hard

A. for epoch in range(5):
optimizer.zero_grad()
for batch_idx, (data, target) in enumerate(dataloader):
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

B. for batch_idx, (data, target) in enumerate(dataloader):
for epoch in range(5):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

C. for epoch in range(5):
for batch_idx, (data, target) in enumerate(dataloader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

D. for epoch in range(5):
for batch_idx, (data, target) in enumerate(dataloader):
output = model(data)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()

Solution

1. Step 1: Check loop order

   The outer loop should be epochs, inner loop batches. for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() follows this correctly.

2. Step 2: Verify zero_grad and step calls

   optimizer.zero_grad() must be before backward(), and optimizer.step() after. for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() has correct order.

3. Step 3: Check other options

   for batch_idx, (data, target) in enumerate(dataloader): for epoch in range(5): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() reverses loops (wrong). for epoch in range(5): optimizer.zero_grad() for batch_idx, (data, target) in enumerate(dataloader): output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() zeros gradients outside batch loop (wrong). for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): output = model(data) loss = criterion(output, target) optimizer.zero_grad() loss.backward() optimizer.step() zeros gradients after forward pass (wrong order).

4. Final Answer:

   for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() -> Option C

5. Quick Check:

   Epochs outside, zero_grad before backward, step after [OK]

Hint: Epoch loop outside, zero_grad before backward [OK]

Common Mistakes:

• Swapping epoch and batch loops
• Calling zero_grad outside batch loop
• Calling zero_grad after forward pass