Learning rate schedulers in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of a learning rate scheduler?

In training neural networks, why do we use learning rate schedulers?

A To randomly reset model weights at certain epochs to prevent overfitting.

B To adjust the learning rate during training to improve convergence and avoid overshooting minima.

C To increase the batch size dynamically during training for faster computation.

D To change the activation function of the model layers during training.

💡 Hint

Think about how changing the step size affects learning progress.

Learning rate schedulers adjust the learning rate during training to help the model converge better and avoid jumping over minima.

❓ Predict Output

intermediate

Output of learning rate after 3 epochs with StepLR

Given the PyTorch code below, what is the learning rate printed after 3 epochs?

PyTorch

import torch
import torch.optim as optim

model_params = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = optim.SGD(model_params, lr=0.1)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.5)

for epoch in range(3):
    optimizer.step()
    scheduler.step()
    lr = optimizer.param_groups[0]['lr']
print(f"Learning rate after 3 epochs: {lr}")

A Learning rate after 3 epochs: 0.05

B Learning rate after 3 epochs: 0.1

C Learning rate after 3 epochs: 0.025

D Learning rate after 3 epochs: 0.2

💡 Hint

StepLR reduces the learning rate by gamma every step_size epochs.

StepLR reduces lr by 0.5 every 2 epochs. After 2 epochs lr=0.05, after 3 epochs still 0.05.

❓ Model Choice

advanced

Choosing a scheduler for cyclic learning rate

You want the learning rate to cyclically increase and decrease during training to help escape local minima. Which PyTorch scheduler should you choose?

A torch.optim.lr_scheduler.CyclicLR

B torch.optim.lr_scheduler.StepLR

C torch.optim.lr_scheduler.ExponentialLR

D torch.optim.lr_scheduler.ReduceLROnPlateau

💡 Hint

Look for a scheduler that explicitly cycles the learning rate.

CyclicLR cycles the learning rate between bounds, increasing and decreasing it during training.

❓ Metrics

advanced

Effect of learning rate scheduler on training loss

During training, you apply a learning rate scheduler that reduces the learning rate when validation loss plateaus. What effect do you expect on the training loss curve?

A Training loss will remain constant regardless of scheduler.

B Training loss will increase sharply after scheduler reduces learning rate.

C Training loss will decrease more smoothly and possibly reach a lower minimum.

D Training loss will oscillate wildly without any pattern.

💡 Hint

Reducing learning rate on plateau helps fine-tune the model.

Lowering learning rate when progress stalls helps the model settle into a better minimum, smoothing loss decrease.

🔧 Debug

expert

Why does this CosineAnnealingLR scheduler not reduce learning rate as expected?

Consider this PyTorch code snippet:

import torch
import torch.optim as optim

params = [torch.nn.Parameter(torch.randn(1, requires_grad=True))]
optimizer = optim.SGD(params, lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)

for epoch in range(10):
    optimizer.step()
    scheduler.step()
    print(f"Epoch {epoch+1}: lr = {optimizer.param_groups[0]['lr']}")

The learning rate resets after 5 epochs but does not decrease smoothly over 10 epochs as intended. What is the cause?

A CosineAnnealingLR requires gamma parameter to reduce learning rate, which is missing.

B The learning rate is fixed and cannot be changed by CosineAnnealingLR.

C The optimizer.step() must be called after scheduler.step() for correct learning rate update.

D The scheduler restarts after T_max epochs; to have smooth decay over 10 epochs, T_max should be set to 10.

💡 Hint

Check the meaning of T_max parameter in CosineAnnealingLR.

T_max defines the number of epochs for one cosine cycle. Setting T_max=5 causes the learning rate to restart every 5 epochs, not smooth over 10.

Practice

1. What is the main purpose of using a learning rate scheduler in PyTorch training?

easy

A. To change the model architecture dynamically

B. To increase the batch size automatically

C. To shuffle the training data at each epoch

D. To adjust the learning rate during training for better model performance

Solution

1. Step 1: Understand the role of learning rate

   The learning rate controls how fast the model updates its knowledge during training.

2. Step 2: Identify what a scheduler does

   A learning rate scheduler changes the learning rate over time to improve training stability and performance.

3. Final Answer:

   To adjust the learning rate during training for better model performance -> Option D

4. Quick Check:

   Learning rate scheduler adjusts learning rate [OK]

Hint: Schedulers change learning rate, not batch size or model structure [OK]

Common Mistakes:

• Confusing scheduler with batch size adjustment
• Thinking scheduler changes model layers
• Assuming scheduler shuffles data

2. Which of the following is the correct way to create a StepLR scheduler in PyTorch for optimizer opt with step size 10 and gamma 0.1?

easy

A. scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.1)

B. scheduler = torch.optim.StepLR(opt, step=10, decay=0.1)

C. scheduler = torch.optim.lr_scheduler.StepLR(opt, steps=10, gamma=0.1)

D. scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=10, decay=0.1)

Solution

1. Step 1: Recall PyTorch StepLR syntax

   The correct class is torch.optim.lr_scheduler.StepLR with parameters step_size and gamma.

2. Step 2: Match parameters correctly

   step_size=10 and gamma=0.1 are the correct parameter names and values.

3. Final Answer:

   scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.1) -> Option A

4. Quick Check:

   StepLR uses step_size and gamma [OK]

Hint: Use exact parameter names: step_size and gamma [OK]

Common Mistakes:

• Using wrong parameter names like step or decay
• Calling StepLR from wrong module
• Mixing up parameter order

3. Given the code below, what will be the learning rate after 3 calls to scheduler.step()?

import torch
opt = torch.optim.SGD([torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))], lr=0.1)
scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=2, gamma=0.5)

for _ in range(3):
    scheduler.step()
    current_lr = opt.param_groups[0]['lr']

medium

A. 0.05

B. 0.1

C. 0.025

D. 0.0125

Solution

1. Step 1: Understand StepLR behavior

   StepLR reduces learning rate by gamma every step_size epochs. Here, step_size=2, gamma=0.5.

2. Step 2: Calculate learning rate after 3 steps

   After 1 step: lr=0.1 (no change, step 1 < 2)
   After 2 steps: lr=0.1 * 0.5 = 0.05 (step 2 reached)
   After 3 steps: lr remains 0.05 (step 3 < 4)

3. Final Answer:

   0.05 -> Option A

4. Quick Check:

   StepLR halves lr every 2 steps [OK]

Hint: Learning rate changes only at multiples of step_size [OK]

Common Mistakes:

• Reducing learning rate every step instead of every step_size
• Multiplying gamma incorrectly
• Ignoring initial learning rate

4. Identify the error in the following PyTorch learning rate scheduler code:

import torch
opt = torch.optim.Adam([torch.nn.Parameter(torch.randn(3, 3, requires_grad=True))], lr=0.01)
scheduler = torch.optim.lr_scheduler.ExponentialLR(opt, gamma=0.9)

for epoch in range(5):
    scheduler.step()
    print(f"Epoch {epoch}: lr = {opt.param_groups[0]['lr']}")

medium

A. Learning rate should be set inside the loop

B. scheduler.step() should be called after optimizer.step()

C. ExponentialLR does not exist in PyTorch

D. gamma value must be greater than 1

Solution

1. Step 1: Recall correct scheduler usage

   In PyTorch, scheduler.step() should be called after optimizer.step() to update learning rate correctly.

2. Step 2: Check code order

   The code calls scheduler.step() before any optimizer.step(), which is incorrect and may cause unexpected lr updates.

3. Final Answer:

   scheduler.step() should be called after optimizer.step() -> Option B

4. Quick Check:

   Call scheduler.step() after optimizer.step() [OK]

Hint: Always call scheduler.step() after optimizer.step() [OK]

Common Mistakes:

• Calling scheduler.step() before optimizer.step()
• Using invalid gamma values
• Misunderstanding scheduler existence

5. You want to train a model where the learning rate starts at 0.1, then reduces by half every 5 epochs, but after 20 epochs, it should decay exponentially by 0.9 every epoch. Which PyTorch scheduler setup achieves this behavior?

hard

A. Use CosineAnnealingLR with T_max=20 and then StepLR with step_size=5, gamma=0.5

B. Use ExponentialLR with gamma=0.9 from start and manually adjust learning rate at epoch 20

C. Use StepLR with step_size=5, gamma=0.5 for first 20 epochs, then switch to ExponentialLR with gamma=0.9

D. Use StepLR with step_size=20, gamma=0.5 and ignore exponential decay

Solution

1. Step 1: Understand the two-phase learning rate schedule

   First phase: reduce lr by half every 5 epochs for 20 epochs.
   Second phase: after 20 epochs, apply exponential decay by 0.9 every epoch.

2. Step 2: Match PyTorch schedulers to phases

   StepLR with step_size=5, gamma=0.5 fits first phase.
   ExponentialLR with gamma=0.9 fits second phase.
   Switching schedulers after 20 epochs achieves desired behavior.

3. Final Answer:

   Use StepLR with step_size=5, gamma=0.5 for first 20 epochs, then switch to ExponentialLR with gamma=0.9 -> Option C

4. Quick Check:

   Combine StepLR then ExponentialLR for phased decay [OK]

Hint: Combine schedulers for multi-phase learning rate changes [OK]

Common Mistakes:

• Trying to use one scheduler for both phases
• Ignoring the switch at epoch 20
• Using wrong scheduler types for phases