ReduceLROnPlateau in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a ReduceLROnPlateau scheduler that monitors validation loss.

PyTorch

scheduler = torch.optim.lr_scheduler.[1](optimizer, mode='min')

Drag options to blanks, or click blank then click option'

AReduceLROnPlateau

BExponentialLR

CCosineAnnealingLR

DStepLR

Attempts:

3 left

💡 Hint

Common Mistakes

Using StepLR instead of ReduceLROnPlateau

Forgetting to set mode='min' for validation loss

The ReduceLROnPlateau scheduler reduces the learning rate when a metric has stopped improving. Here, it monitors validation loss, so mode='min' is used.

2fill in blank

medium

Complete the code to call the scheduler step function with the validation loss value.

PyTorch

scheduler.[1](val_loss)

Drag options to blanks, or click blank then click option'

Aadjust

Bupdate

Creduce

Dstep

Attempts:

3 left

💡 Hint

Common Mistakes

Calling step() without passing the metric value

Using incorrect method names like 'update' or 'reduce'

The step() method of ReduceLROnPlateau is called with the current validation loss to check if learning rate should be reduced.

3fill in blank

hard

Fix the error in the scheduler initialization by filling the blank with the correct patience value.

PyTorch

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=[1])

Drag options to blanks, or click blank then click option'

A5

B'5'

CNone

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Passing patience as a string instead of integer

Using negative or None values

The patience parameter expects an integer number of epochs to wait before reducing the learning rate. It should be 5, not a string or invalid value.

4fill in blank

hard

Fill both blanks to create a scheduler that reduces learning rate by a factor of 0.1 after 3 epochs without improvement.

PyTorch

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=[1], patience=[2])

Drag options to blanks, or click blank then click option'

A0.1

B3

C0.5

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using factor greater than 1

Setting patience too high or as a float

The factor controls how much the learning rate is reduced (0.1 means reduce to 10%). The patience is the number of epochs to wait (3 here) before reducing.

5fill in blank

hard

Fill all three blanks to create a training loop that updates the scheduler with validation loss and prints the learning rate.

PyTorch

for epoch in range(num_epochs):
    train()
    val_loss = validate()
    scheduler.[1](val_loss)
    lr = optimizer.param_groups[0]['[2]']
    print(f"Epoch {epoch+1}, Learning Rate: {lr:.6f}")

# The scheduler step method is called with the validation loss, and the learning rate key is '[3]'.

Drag options to blanks, or click blank then click option'

Astep

Blr

Dlearning_rate

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method name instead of 'step'

Accessing learning rate with wrong key like 'learning_rate'

The scheduler's step() method is called with the validation loss. The learning rate is accessed via the key 'lr' in the optimizer's parameter groups.

Practice

1. What is the main purpose of ReduceLROnPlateau in PyTorch training?

easy

A. To shuffle the training data before each epoch

B. To increase the batch size automatically during training

C. To stop training early when accuracy reaches a threshold

D. To reduce the learning rate when a monitored metric stops improving

Solution

1. Step 1: Understand the role of learning rate schedulers

   Learning rate schedulers adjust the learning rate during training to improve convergence.

2. Step 2: Identify what ReduceLROnPlateau does

   This scheduler reduces the learning rate when a monitored metric (like validation loss) stops improving.

3. Final Answer:

   To reduce the learning rate when a monitored metric stops improving -> Option D

4. Quick Check:

   ReduceLROnPlateau lowers LR on no improvement [OK]

Hint: Remember: it lowers LR when progress stalls [OK]

Common Mistakes:

• Confusing it with early stopping
• Thinking it changes batch size
• Assuming it shuffles data

2. Which of the following is the correct way to create a ReduceLROnPlateau scheduler in PyTorch?

easy

A. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min')

B. scheduler = torch.optim.ReduceLROnPlateau(optimizer, mode='max')

C. scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10)

D. scheduler = torch.optim.ReduceLROnPlateau(optimizer, patience=5)

Solution

1. Step 1: Check the correct module and class name

   The correct class is ReduceLROnPlateau inside torch.optim.lr_scheduler.

2. Step 2: Verify the constructor parameters

   It requires the optimizer and optional parameters like mode. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min') uses correct syntax and parameters.

3. Final Answer:

   scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min') -> Option A

4. Quick Check:

   Correct class and module usage [OK]

Hint: Use torch.optim.lr_scheduler.ReduceLROnPlateau with optimizer [OK]

Common Mistakes:

• Using wrong module path
• Confusing with StepLR scheduler
• Missing required optimizer argument

3. Given the code below, what will be the learning rate after the third call to scheduler.step(val_loss) if val_loss values are [0.5, 0.4, 0.4, 0.4] and patience=2?

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=2, factor=0.1)

val_losses = [0.5, 0.4, 0.4, 0.4]
for loss in val_losses:
    scheduler.step(loss)
    print(f"LR: {optimizer.param_groups[0]['lr']}")

medium

A. 0.1

B. 0.01

C. 0.001

D. 0.4

Solution

1. Step 1: Understand patience and when LR reduces

   Patience=2 means LR reduces after 2 epochs with no improvement in monitored metric.

2. Step 2: Analyze val_loss sequence and scheduler calls

   val_loss improves from 0.5 to 0.4 at second call, then stays same (no improvement) for next two calls. LR reduces only after 2 consecutive no improvements, so after the fourth call, not the third.

3. Final Answer:

   0.1 -> Option A

4. Quick Check:

   LR reduces after patience epochs, not before [OK]

Hint: LR changes after patience epochs without improvement [OK]

Common Mistakes:

• Reducing LR immediately on no improvement
• Confusing patience count
• Using val_loss value as LR

4. Identify the error in the following code snippet using ReduceLROnPlateau:

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer)

for epoch in range(5):
    train()
    val_loss = validate()
    scheduler.step()

medium

A. Learning rate must be set to 0.1 initially

B. Optimizer should be SGD, not Adam

C. Missing metric argument in scheduler.step() call

D. scheduler.step() should be called before training

Solution

1. Step 1: Check how ReduceLROnPlateau.step() is called

   This scheduler requires the monitored metric (e.g., val_loss) as an argument in step().

2. Step 2: Identify missing argument in code

   The code calls scheduler.step() without passing val_loss, causing an error.

3. Final Answer:

   Missing metric argument in scheduler.step() call -> Option C

4. Quick Check:

   Pass metric to step() for ReduceLROnPlateau [OK]

Hint: Always pass metric to scheduler.step() for ReduceLROnPlateau [OK]

Common Mistakes:

• Calling step() without metric
• Confusing optimizer type
• Wrong order of scheduler call

5. You want to train a model and reduce the learning rate by half if the validation accuracy does not improve for 3 epochs. Which of the following is the correct way to set up ReduceLROnPlateau for this task?

hard

A. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=2.0, patience=3)

B. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)

C. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3)

D. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=2.0, patience=3)

Solution

1. Step 1: Determine the mode based on metric type

   Validation accuracy should be maximized, so mode='max' is correct.

2. Step 2: Set factor and patience correctly

   Factor=0.5 halves the learning rate, patience=3 waits 3 epochs before reducing.

3. Final Answer:

   scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3) -> Option B

4. Quick Check:

   Maximize accuracy, reduce LR by half after 3 no improvements [OK]

Hint: Use mode='max' for accuracy, factor <1 to reduce LR [OK]

Common Mistakes:

• Using mode='min' for accuracy
• Setting factor > 1 (increases LR)
• Confusing patience value