Training loop structure in PyTorch - Model Metrics & Evaluation

Metrics & Evaluation - Training loop structure

Which metric matters for Training Loop Structure and WHY

When training a model, the key metrics to watch are training loss and validation loss. Loss tells us how far off the model's predictions are from the true answers. Lower loss means better learning.

Accuracy is also important if the task is classification. It shows the percentage of correct predictions.

We track these metrics each training step or epoch to see if the model is improving or stuck.

Confusion Matrix Example

Confusion Matrix (for classification):

          Predicted
          0    1
Actual 0 50   10
       1  5   35

TP = 35 (correctly predicted 1s)
FP = 10 (wrongly predicted 1s)
TN = 50 (correctly predicted 0s)
FN = 5  (missed 1s)

Total samples = 50 + 10 + 5 + 35 = 100
    

This matrix helps calculate precision, recall, and accuracy during training evaluation.

Precision vs Recall Tradeoff in Training

During training, improving one metric can lower another. For example:

• Precision: How many predicted positives are actually positive.
• Recall: How many actual positives were found.

If the model is too strict, it may have high precision but low recall (miss many positives). If too loose, high recall but low precision (many false alarms).

Choosing which to prioritize depends on the problem. Training loops should monitor both to balance them.

Good vs Bad Metric Values During Training

Good:

• Training and validation loss steadily decrease.
• Accuracy improves and stabilizes at a high value.
• Precision and recall both improve without big gaps.

Bad:

• Training loss decreases but validation loss increases (overfitting).
• Accuracy stays low or fluctuates wildly.
• Precision very high but recall very low, or vice versa.

Common Pitfalls in Training Loop Metrics

• Accuracy paradox: High accuracy can be misleading if classes are imbalanced.
• Data leakage: Validation data accidentally used in training inflates metrics.
• Overfitting: Training loss drops but validation loss rises, showing poor generalization.
• Ignoring loss curves: Not checking loss trends can miss training issues.

Self Check

Your model has 98% accuracy but 12% recall on fraud detection. Is it good?

No. The model misses 88% of fraud cases (low recall), which is dangerous. High accuracy is misleading because fraud is rare. You need to improve recall to catch more fraud.

Key Result

Training and validation loss trends are key to judge if the training loop is working well.

Practice

1. Which of the following best describes the main purpose of a training loop in PyTorch?

easy

A. To save the model to a file

B. To repeatedly update the model weights to improve performance

C. To visualize the model architecture

D. To load data from disk into memory

Solution

1. Step 1: Understand the training loop role

   The training loop runs many times to adjust model weights based on data.

2. Step 2: Identify the main goal

   Its goal is to improve model performance by updating weights repeatedly.

3. Final Answer:

   To repeatedly update the model weights to improve performance -> Option B

4. Quick Check:

   Training loop = update weights repeatedly [OK]

Hint: Training loop = repeat updates to improve model [OK]

Common Mistakes:

• Confusing data loading with training loop
• Thinking training loop saves model
• Assuming training loop only visualizes model

2. Which of the following is the correct way to zero gradients in a PyTorch training loop?

easy

A. optimizer.zero_grad()

B. model.zero_gradients()

C. loss.zero_grad()

D. torch.zero_grad()

Solution

1. Step 1: Recall PyTorch gradient clearing method

   Gradients are cleared by calling zero_grad() on the optimizer.

2. Step 2: Check each option

   Only optimizer.zero_grad() is the correct PyTorch syntax.

3. Final Answer:

   optimizer.zero_grad() -> Option A

4. Quick Check:

   Clear gradients with optimizer.zero_grad() [OK]

Hint: Clear gradients with optimizer.zero_grad() [OK]

Common Mistakes:

• Calling zero_grad on model or loss
• Using non-existent torch.zero_grad()
• Forgetting to zero gradients before backward pass

3. What will be the output of the following PyTorch training loop snippet?

for epoch in range(2):
    for batch in range(3):
        print(f"Epoch {epoch}, Batch {batch}")

medium

A. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 1, Batch 0
Epoch 1, Batch 1

B. Epoch 0, Batch 0
Epoch 1, Batch 0
Epoch 2, Batch 0

C. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 0, Batch 2

D. Epoch 0, Batch 0
Epoch 0, Batch 1
Epoch 0, Batch 2
Epoch 1, Batch 0
Epoch 1, Batch 1
Epoch 1, Batch 2

Solution

1. Step 1: Understand loop ranges

   Outer loop runs for epochs 0 and 1 (2 times). Inner loop runs for batches 0,1,2 (3 times).

2. Step 2: Trace output lines

   For each epoch, batches 0 to 2 print, so total 6 lines with epoch and batch numbers.

3. Final Answer:

   Epoch 0, Batch 0 Epoch 0, Batch 1 Epoch 0, Batch 2 Epoch 1, Batch 0 Epoch 1, Batch 1 Epoch 1, Batch 2 -> Option D

4. Quick Check:

   2 epochs x 3 batches = 6 lines printed [OK]

Hint: Multiply epochs by batches for total prints [OK]

Common Mistakes:

• Confusing range end values
• Mixing epoch and batch indices
• Counting fewer batches than loop runs

4. Identify the error in this PyTorch training loop snippet:

for data, target in dataloader:
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward
    optimizer.step()

medium

A. Missing parentheses after loss.backward

B. optimizer.zero_grad() should be after optimizer.step()

C. criterion should be called before model(data)

D. optimizer.step() should be called before loss.backward

Solution

1. Step 1: Check method calls

   loss.backward is missing parentheses, so it is not called as a function.

2. Step 2: Verify correct order

   optimizer.zero_grad() is correctly before backward and step; criterion call order is correct; optimizer.step() after backward is correct.

3. Final Answer:

   Missing parentheses after loss.backward -> Option A

4. Quick Check:

   Call loss.backward() with parentheses [OK]

Hint: Always add () to call backward() [OK]

Common Mistakes:

• Forgetting parentheses on backward()
• Changing correct optimizer.zero_grad() position
• Misordering loss and model calls

5. You want to train a model for 5 epochs with batches of size 10. Which of the following training loop structures correctly implements this in PyTorch?

hard

A. for epoch in range(5):
optimizer.zero_grad()
for batch_idx, (data, target) in enumerate(dataloader):
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

B. for batch_idx, (data, target) in enumerate(dataloader):
for epoch in range(5):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

C. for epoch in range(5):
for batch_idx, (data, target) in enumerate(dataloader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

D. for epoch in range(5):
for batch_idx, (data, target) in enumerate(dataloader):
output = model(data)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()

Solution

1. Step 1: Check loop order

   The outer loop should be epochs, inner loop batches. for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() follows this correctly.

2. Step 2: Verify zero_grad and step calls

   optimizer.zero_grad() must be before backward(), and optimizer.step() after. for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() has correct order.

3. Step 3: Check other options

   for batch_idx, (data, target) in enumerate(dataloader): for epoch in range(5): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() reverses loops (wrong). for epoch in range(5): optimizer.zero_grad() for batch_idx, (data, target) in enumerate(dataloader): output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() zeros gradients outside batch loop (wrong). for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): output = model(data) loss = criterion(output, target) optimizer.zero_grad() loss.backward() optimizer.step() zeros gradients after forward pass (wrong order).

4. Final Answer:

   for epoch in range(5): for batch_idx, (data, target) in enumerate(dataloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() -> Option C

5. Quick Check:

   Epochs outside, zero_grad before backward, step after [OK]

Hint: Epoch loop outside, zero_grad before backward [OK]

Common Mistakes:

• Swapping epoch and batch loops
• Calling zero_grad outside batch loop
• Calling zero_grad after forward pass