Why learning rate strategy affects convergence in PyTorch

Introduction

The learning rate controls how much the model changes at each step. Using a good learning rate strategy helps the model learn faster and better without getting stuck or jumping around.

Training a neural network to recognize images

Adjusting model training to avoid slow or unstable learning

Improving accuracy by fine-tuning how the model updates weights

Preventing the model from missing the best solution during training

Syntax

PyTorch

optimizer = torch.optim.SGD(model.parameters(), lr=initial_lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=step, gamma=decay)

The optimizer updates model weights using the learning rate.

The scheduler changes the learning rate during training to help convergence.

Examples

Reduces learning rate by half every 10 steps.

PyTorch

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

Multiplies learning rate by 0.9 every step for smooth decay.

PyTorch

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)

Sample Model

This code trains a simple model to learn y=2x. The learning rate starts at 0.1 and halves every 5 epochs. You see loss decrease and learning rate change, showing how the strategy affects training.

PyTorch

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

# Simple model
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)

model = SimpleModel()

# Data: y = 2x
x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
y = torch.tensor([[2.0], [4.0], [6.0], [8.0]])

# Optimizer and scheduler
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)

loss_fn = nn.MSELoss()

for epoch in range(15):
    optimizer.zero_grad()
    outputs = model(x)
    loss = loss_fn(outputs, y)
    loss.backward()
    optimizer.step()
    scheduler.step()
    print(f"Epoch {epoch+1}: Loss={loss.item():.4f}, LR={scheduler.get_last_lr()[0]:.4f}")

Important Notes

A learning rate too high can make training jump around and not settle.

A learning rate too low can make training very slow.

Changing the learning rate during training helps balance speed and stability.

Summary

The learning rate controls how big each step is when the model learns.

Using a strategy to change the learning rate helps the model find better answers faster.

Schedulers in PyTorch make it easy to adjust learning rates during training.

Practice

1. What is the main role of the learning rate in training a PyTorch model?

easy

A. It determines the type of activation function used.

B. It decides the number of layers in the model.

C. It sets the batch size for training.

D. It controls the size of the steps the model takes to learn.

Solution

1. Step 1: Understand learning rate function

   The learning rate controls how much the model changes its weights after seeing each batch of data.

2. Step 2: Identify the correct role

   Among the options, only controlling step size matches the learning rate's role.

3. Final Answer:

   It controls the size of the steps the model takes to learn. -> Option D

4. Quick Check:

   Learning rate = step size [OK]

Hint: Learning rate = step size in learning [OK]

Common Mistakes:

• Confusing learning rate with batch size
• Thinking learning rate sets model layers
• Mixing learning rate with activation functions

2. Which PyTorch code snippet correctly creates an optimizer with a learning rate of 0.01?

easy

A. optimizer = torch.optim.SGD(model.parameters(), learningRate=0.01)

B. optimizer = torch.optim.Adam(model.parameters(), learning_rate=0.01)

C. optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

D. optimizer = torch.optim.Adam(model.parameters(), rate=0.01)

Solution

1. Step 1: Check PyTorch optimizer syntax

   The correct argument for learning rate is 'lr', not 'learning_rate' or 'learningRate' or 'rate'.

2. Step 2: Identify correct code

   optimizer = torch.optim.SGD(model.parameters(), lr=0.01) uses 'lr=0.01' correctly with SGD optimizer.

3. Final Answer:

   optimizer = torch.optim.SGD(model.parameters(), lr=0.01) -> Option C

4. Quick Check:

   Use 'lr' for learning rate in PyTorch optimizers [OK]

Hint: Use 'lr' keyword for learning rate in PyTorch [OK]

Common Mistakes:

• Using 'learning_rate' instead of 'lr'
• Wrong capitalization like 'learningRate'
• Using 'rate' instead of 'lr'

3. Consider this PyTorch training loop snippet with a fixed learning rate of 0.1:

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
for epoch in range(3):
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()
    print(f"Epoch {epoch+1} loss: {loss.item():.4f}")

What is the likely effect of using a high fixed learning rate like 0.1 on convergence?

medium

A. The model may overshoot minima and fail to converge.

B. The model will converge faster without any issues.

C. The model will ignore the learning rate and converge normally.

D. The loss will always be zero from the first epoch.

Solution

1. Step 1: Understand effect of high learning rate

   A high learning rate can cause the model to take too large steps, missing the best solution and causing unstable training.

2. Step 2: Analyze options

   Only The model may overshoot minima and fail to converge. correctly describes overshooting and failure to converge due to high learning rate.

3. Final Answer:

   The model may overshoot minima and fail to converge. -> Option A

4. Quick Check:

   High learning rate = overshoot minima [OK]

Hint: High learning rate risks overshooting minima [OK]

Common Mistakes:

• Assuming high learning rate always speeds convergence
• Thinking learning rate is ignored by optimizer
• Believing loss is zero immediately

4. You have this PyTorch code using a learning rate scheduler:

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.5)
for epoch in range(4):
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()
    scheduler.step()
    print(f"Epoch {epoch+1} lr: {scheduler.get_last_lr()[0]:.4f}")

The printed learning rates are: 0.0500, 0.0500, 0.0250, 0.0250. What is wrong?

medium

A. Calling scheduler.step() after optimizer.step() causes learning rate to update too early.

B. The scheduler should be called before optimizer.step() to update correctly.

C. The learning rate is not changing because gamma is too small.

D. The step_size should be 1 to update every epoch.

Solution

1. Step 1: Understand StepLR behavior

   StepLR updates learning rate every 'step_size' epochs by multiplying by 'gamma'. It should be called before optimizer.step() to update the learning rate correctly for the current epoch.

2. Step 2: Analyze learning rate printout

   Learning rate halves too early (at epoch 1 instead of 2), indicating scheduler.step() is called too late.

3. Final Answer:

   The scheduler should be called before optimizer.step() to update correctly. -> Option B

4. Quick Check:

   Scheduler step timing affects lr update [OK]

Hint: Scheduler.step() timing affects learning rate update [OK]

Common Mistakes:

• Assuming gamma controls if lr changes or not
• Thinking step_size must be 1 always
• Calling scheduler.step() after optimizer.step() causes early update

5. You want to train a model that first learns quickly and then fine-tunes slowly. Which learning rate strategy in PyTorch best fits this goal?

hard

A. Use a StepLR scheduler to reduce learning rate after fixed epochs.

B. Use a constant learning rate throughout training.

C. Use a learning rate that increases over time.

D. Use no learning rate scheduler and manually change lr each epoch.

Solution

1. Step 1: Understand training phases

   Starting with a higher learning rate helps fast learning; lowering it later helps fine-tuning.

2. Step 2: Match strategy to goal

   StepLR reduces learning rate after set epochs, matching the goal of fast then slow learning.

3. Final Answer:

   Use a StepLR scheduler to reduce learning rate after fixed epochs. -> Option A

4. Quick Check:

   StepLR = fast then slow learning [OK]

Hint: StepLR reduces learning rate after epochs for fine-tuning [OK]

Common Mistakes:

• Thinking constant lr adapts learning speed
• Believing increasing lr helps fine-tuning
• Ignoring built-in schedulers and changing lr manually