ReduceLROnPlateau in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding ReduceLROnPlateau behavior

What does the ReduceLROnPlateau scheduler do in PyTorch?

A It increases the learning rate after every epoch regardless of performance.

B It resets the model weights to initial values when loss plateaus.

C It reduces the learning rate when a monitored metric stops improving.

D It stops training automatically when the validation loss stops decreasing.

💡 Hint

Think about what happens when the model's performance metric does not improve.

The ReduceLROnPlateau scheduler lowers the learning rate if the monitored metric (like validation loss) does not improve for a set number of epochs. This helps the model converge better.

❓ Predict Output

intermediate

Output of learning rate after plateau

Given the following PyTorch code snippet, what will be the learning rate after 3 epochs if the validation loss does not improve?

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.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=2)

val_losses = [0.5, 0.5, 0.5]

for epoch, loss in enumerate(val_losses):
    scheduler.step(loss)
    print(f"Epoch {epoch+1} LR: {optimizer.param_groups[0]['lr']}")

A

Epoch 1 LR: 0.1
Epoch 2 LR: 0.01
Epoch 3 LR: 0.001

B

Epoch 1 LR: 0.1
Epoch 2 LR: 0.1
Epoch 3 LR: 0.010000000000000002

C

Epoch 1 LR: 0.1
Epoch 2 LR: 0.1
Epoch 3 LR: 0.1

D

Epoch 1 LR: 0.1
Epoch 2 LR: 0.05
Epoch 3 LR: 0.025

💡 Hint

Remember the patience is 2, so learning rate reduces after 2 epochs without improvement.

The learning rate stays at 0.1 for the first two epochs because patience=2 means it waits 2 epochs without improvement. On the third epoch, since loss did not improve, the learning rate reduces by factor 0.1 to 0.01.

❓ Model Choice

advanced

Choosing correct scheduler for validation accuracy

You want to reduce the learning rate when validation accuracy stops improving. Which mode should you use in ReduceLROnPlateau?

A 'max', because accuracy should increase to improve.

B 'min', because accuracy should decrease to improve.

C 'min', because accuracy is a loss metric.

D 'max', because accuracy should decrease to improve.

💡 Hint

Think about whether accuracy is better when higher or lower.

Accuracy improves when it increases, so the scheduler should watch for when the metric stops increasing. Thus, mode='max' is correct.

❓ Hyperparameter

advanced

Effect of patience parameter in ReduceLROnPlateau

What is the effect of setting a high patience value in ReduceLROnPlateau?

A The learning rate reduces immediately after one bad epoch.

B The learning rate stays fixed and never changes.

C The learning rate increases after many epochs without improvement.

D The learning rate reduces only after many epochs without improvement.

💡 Hint

Patience controls how long the scheduler waits before reducing LR.

A higher patience means the scheduler waits longer before reducing the learning rate, allowing more epochs without improvement.

🔧 Debug

expert

Why does ReduceLROnPlateau not reduce LR as expected?

Consider this code snippet:

import torch
import torch.optim as optim

model_params = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = optim.Adam(model_params, lr=0.01)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=1)

val_losses = [0.3, 0.3, 0.3, 0.3]

for epoch, loss in enumerate(val_losses):
    scheduler.step(loss)
    print(f"Epoch {epoch+1} LR: {optimizer.param_groups[0]['lr']}")

Why does the learning rate never reduce?

A Because the scheduler.step() must be called with a metric that decreases, but here loss is constant, so no improvement triggers LR reduction.

B Because the optimizer is Adam, which does not support learning rate changes.

C Because the validation loss never improves, so LR stays the same.

D Because patience=1 means LR reduces only after 3 epochs without improvement.

💡 Hint

Check how the scheduler detects improvement and what happens if the metric stays the same.

The scheduler reduces LR only if the metric does not improve (decrease) for patience epochs. Here, the loss stays constant (0.3), which is not considered an improvement, but also not worse. By default, the scheduler treats equal values as no improvement, so it waits. Since patience=1, after 1 epoch without improvement, LR should reduce. If LR never reduces, it may be because the metric is not passed correctly or patience is too high. Here, the constant loss means no improvement, so LR should reduce after patience epochs.