CosineAnnealingLR in PyTorch - Model Metrics & Evaluation

Metrics & Evaluation - CosineAnnealingLR

Which metric matters for CosineAnnealingLR and WHY

CosineAnnealingLR is a learning rate scheduler. It changes the learning rate during training to help the model learn better. The key metric to watch is the training loss and validation loss. These show if the model is learning well and not stuck or jumping around.

Why loss? Because the scheduler affects how fast or slow the model updates its knowledge. A good scheduler helps the loss go down smoothly and reach a low value.

Confusion matrix or equivalent visualization

CosineAnnealingLR does not directly affect classification results or confusion matrices. Instead, we look at loss curves over epochs.

Epoch | Training Loss | Validation Loss | Learning Rate
------------------------------------------------------
  1   |     0.85     |      0.90      |    0.1
  2   |     0.70     |      0.75      |    0.095
  3   |     0.60     |      0.65      |    0.09
 ...  |     ...      |      ...       |    ...
 30   |     0.15     |      0.20      |    0.01
    

This table shows how the learning rate decreases following a cosine curve, helping the loss reduce steadily.

Precision vs Recall tradeoff (or equivalent)

CosineAnnealingLR affects training speed and stability, not precision or recall directly. But indirectly, a good learning rate schedule can help the model find a better balance between underfitting and overfitting.

If the learning rate is too high, the model jumps around and may not learn well (high loss, unstable training). If too low, training is slow and may get stuck (slow loss decrease).

CosineAnnealingLR smoothly lowers the learning rate, allowing the model to explore early and fine-tune later, improving final accuracy and generalization.

What "good" vs "bad" metric values look like for CosineAnnealingLR

Good:

• Training and validation loss decrease smoothly over epochs.
• Learning rate follows a cosine curve, starting higher and gradually lowering.
• Validation loss does not increase sharply (no overfitting).
• Final accuracy or other task metrics improve compared to constant learning rate.

Bad:

• Loss curves are noisy or jump up and down.
• Validation loss increases early, showing overfitting.
• Learning rate does not change or changes abruptly.
• Model accuracy is worse than with a fixed learning rate.

Metrics pitfalls

• Ignoring loss curves: Only looking at final accuracy can hide unstable training caused by poor learning rate scheduling.
• Overfitting signs: Validation loss rising while training loss falls means the model memorizes training data, not generalizing well.
• Data leakage: If validation data leaks into training, loss and accuracy look too good, hiding scheduler issues.
• Overfitting to scheduler: Using too short or too long cosine cycles can cause poor convergence.

Self-check question

Your model uses CosineAnnealingLR. Training loss decreases smoothly, but validation loss stays high and does not improve. Is the scheduler working well? Why or why not?

Answer: The scheduler helps training loss go down, but high validation loss means the model is overfitting or data issues exist. The scheduler alone is not enough; you may need regularization or better data.

Key Result

CosineAnnealingLR helps reduce training loss smoothly by adjusting learning rate, improving model convergence and generalization.

Practice

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

easy

A. To stop training early when accuracy is high

B. To increase the batch size during training

C. To smoothly adjust the learning rate in a wave-like pattern

D. To shuffle the training data every epoch

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 CosineAnnealingLR does

   CosineAnnealingLR changes the learning rate smoothly following a cosine curve, avoiding sudden jumps.

3. Final Answer:

   To smoothly adjust the learning rate in a wave-like pattern -> Option C

4. Quick Check:

   CosineAnnealingLR = smooth wave learning rate [OK]

Hint: CosineAnnealingLR changes learning rate smoothly like a wave [OK]

Common Mistakes:

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

2. Which of the following is the correct way to create a CosineAnnealingLR scheduler in PyTorch with a cycle length of 10 epochs and minimum learning rate 0.001?

easy

A. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0.001)

B. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max_T=10, min_lr=0.001)

C. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)

D. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, min_lr=0.001)

Solution

1. Step 1: Check the official PyTorch parameter names

   The correct parameters are T_max for cycle length and eta_min for minimum learning rate.

2. Step 2: Match parameters with options

   scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0.001) uses T_max=10 and eta_min=0.001, which is correct syntax.

3. Final Answer:

   scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0.001) -> Option A

4. Quick Check:

   Use T_max and eta_min parameters [OK]

Hint: Use T_max and eta_min exactly as parameter names [OK]

Common Mistakes:

• Using wrong parameter names like max_T or min_lr
• Omitting eta_min when needed
• Swapping parameter order incorrectly

3. Given the code below, what will be the learning rate after 5 calls to scheduler.step() if initial lr is 0.1, T_max=10, and eta_min=0?

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0)
for _ in range(5):
    scheduler.step()
print(optimizer.param_groups[0]['lr'])

medium

A. 0.0

B. Approximately 0.0707

C. 0.1

D. 0.05

Solution

1. Step 1: Understand CosineAnnealingLR formula

   Learning rate after t calls to step() is: eta_min + 0.5*(initial_lr - eta_min)*(1 + cos(pi * t / T_max))

2. Step 2: Calculate learning rate at t=5

   lr = 0 + 0.5*0.1*(1 + cos(pi*5/10)) = 0.05*(1 + cos(pi/2)) = 0.05*(1 + 0) = 0.05 exactly.

3. Final Answer:

   0.05 -> Option D

4. Quick Check:

   Cosine formula at step 5 = 0.05 [OK]

Hint: Use cosine formula: lr = eta_min + 0.5*(lr0 - eta_min)*(1+cos(pi*t/T_max)) at t=5 = 0.05 [OK]

Common Mistakes:

• Assuming lr stays constant
• Confusing step count indexing
• Ignoring eta_min in calculation
• Miscalculating to ~0.0707

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

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)
for epoch in range(10):
    train()
    scheduler.step()

medium

A. scheduler.step() should be called before train()

B. No error, code is correct

C. T_max should be equal to total epochs (10) not 5

D. Learning rate should be set to 0.1 for Adam optimizer

Solution

1. Step 1: Understand scheduler.step() timing

   Standard PyTorch practice is to call scheduler.step() after train() to update LR for the next epoch.

2. Step 2: Verify the code

   The loop trains with current LR then steps, which is correct. T_max=5 works for 10 epochs as the schedule continues.

3. Final Answer:

   No error, code is correct -> Option B

4. Quick Check:

   train() then scheduler.step() [OK]

Hint: Call scheduler.step() after train() [OK]

Common Mistakes:

• Thinking step() goes before train()
• Requiring T_max = total epochs
• Dictating specific LR for Adam

5. You want to train a model for 50 epochs using CosineAnnealingLR with 2 cycles of learning rate decay. How should you set T_max and why?

hard

A. Set T_max=25 to have two full cosine cycles over 50 epochs

B. Set T_max=50 to have one full cosine cycle over 50 epochs

C. Set T_max=100 to have half a cosine cycle over 50 epochs

D. Set T_max=10 to have five full cosine cycles over 50 epochs

Solution

1. Step 1: Understand T_max meaning

   T_max is the number of epochs for one full cosine cycle of learning rate decay.

2. Step 2: Calculate T_max for 2 cycles in 50 epochs

   To have 2 cycles in 50 epochs, each cycle should last 25 epochs, so T_max=25.

3. Final Answer:

   Set T_max=25 to have two full cosine cycles over 50 epochs -> Option A

4. Quick Check:

   Two cycles = total epochs / 2 = 25 [OK]

Hint: Divide total epochs by number of cycles for T_max [OK]

Common Mistakes:

• Setting T_max equal to total epochs for multiple cycles
• Confusing half and full cycles
• Choosing T_max larger than total epochs