Why regularization controls overfitting in PyTorch - Why Metrics Matter

Metrics & Evaluation - Why regularization controls overfitting

Which metric matters for this concept and WHY

When we talk about overfitting, the key metrics to watch are training loss and validation loss. Overfitting happens when training loss keeps going down but validation loss starts going up. Regularization helps by keeping the model simpler, so validation loss stays low too. This means the model learns patterns that work well on new data, not just the training data.

Confusion matrix or equivalent visualization (ASCII)

    Overfitting example confusion matrix:

          Predicted
          Pos   Neg
    True Pos  90    10
         Neg  30    70

    Here, the model fits training data well but makes more mistakes on new data.

    With regularization, errors on new data reduce:

          Predicted
          Pos   Neg
    True Pos  85    15
         Neg  15    85

    Regularization reduces false positives and false negatives by controlling complexity.
    

Precision vs Recall tradeoff with concrete examples

Regularization affects how complex the model is. A very complex model may have high precision but low recall because it memorizes training data and misses some true cases on new data. A simpler model with regularization balances precision and recall better by generalizing well.

For example, in spam detection:

• Without regularization: Model may mark many emails as spam (high recall) but also mark many good emails as spam (low precision).
• With regularization: Model better balances catching spam (recall) and not marking good emails as spam (precision).

What "good" vs "bad" metric values look like for this use case

Good: Training loss and validation loss both decrease and stay close. Precision and recall on validation data are balanced and high (e.g., >80%). This shows the model learned useful patterns without memorizing noise.

Bad: Training loss is very low but validation loss is high or increasing. Precision might be very high but recall very low, or vice versa. This means the model is overfitting and won't perform well on new data.

Metrics pitfalls (accuracy paradox, data leakage, overfitting indicators)

• Accuracy paradox: High accuracy can hide overfitting if data is imbalanced. Regularization helps by improving generalization, not just accuracy.
• Data leakage: If validation data leaks into training, metrics look good but model overfits. Regularization cannot fix this.
• Overfitting indicators: Large gap between training and validation loss, or very high training accuracy but low validation accuracy.

Self-check: Your model has 98% accuracy but 12% recall on fraud. Is it good?

No, this model is not good for fraud detection. The 98% accuracy is misleading because fraud cases are rare. The 12% recall means the model misses 88% of fraud cases, which is dangerous. Regularization alone won't fix this; you need to improve recall by adjusting the model or data.

Key Result

Regularization helps keep training and validation losses close, reducing overfitting and improving model generalization.

Practice

1. Why does regularization help prevent overfitting in a PyTorch model?

easy

A. It keeps the model weights small by adding a penalty to the loss.

B. It increases the size of the training dataset automatically.

C. It removes layers from the neural network during training.

D. It speeds up the training process by skipping some data points.

Solution

1. Step 1: Understand what overfitting means

   Overfitting happens when a model learns the training data too well, including noise, causing poor performance on new data.

2. Step 2: Explain how regularization affects model weights

   Regularization adds a penalty to large weights, encouraging smaller weights that generalize better to new data.

3. Final Answer:

   It keeps the model weights small by adding a penalty to the loss. -> Option A

4. Quick Check:

   Regularization = penalty on weights = less overfitting [OK]

Hint: Regularization adds penalty to weights to reduce overfitting [OK]

Common Mistakes:

• Thinking regularization increases data size
• Believing regularization removes layers
• Assuming regularization speeds training

2. Which PyTorch code snippet correctly applies L2 regularization (weight decay) during optimizer setup?

easy

A. optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.1)

B. optimizer = torch.optim.SGD(model.parameters(), lr=0.01, dropout=0.1)

C. optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.1)

D. optimizer = torch.optim.SGD(model.parameters(), lr=0.01, decay=0.1)

Solution

1. Step 1: Identify correct parameter for L2 regularization in PyTorch

   PyTorch uses weight_decay in optimizers to apply L2 regularization.

2. Step 2: Check the code options for correct usage

   Only optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.1) uses weight_decay=0.1, which is the correct way to add L2 regularization.

3. Final Answer:

   optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.1) -> Option C

4. Quick Check:

   weight_decay = L2 regularization in PyTorch [OK]

Hint: Use weight_decay param for L2 regularization in PyTorch optimizers [OK]

Common Mistakes:

• Using dropout parameter in optimizer
• Confusing momentum with regularization
• Using decay instead of weight_decay

3. Consider this PyTorch training loop snippet with L2 regularization applied:

optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)
for data, target in dataloader:
    optimizer.zero_grad()
    output = model(data)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

What effect does the weight_decay=0.01 have during training?

medium

A. It adds a penalty to large weights, helping reduce overfitting.

B. It increases the learning rate by 0.01 each step.

C. It drops 1% of neurons randomly during training.

D. It stops training early when loss is below 0.01.

Solution

1. Step 1: Understand weight_decay in optimizer

   The weight_decay parameter adds L2 regularization, penalizing large weights during training.

2. Step 2: Identify the effect on training

   This penalty helps the model avoid overfitting by keeping weights smaller and more generalizable.

3. Final Answer:

   It adds a penalty to large weights, helping reduce overfitting. -> Option A

4. Quick Check:

   weight_decay = L2 penalty = less overfitting [OK]

Hint: weight_decay adds penalty to weights, not learning rate or dropout [OK]

Common Mistakes:

• Confusing weight_decay with learning rate changes
• Thinking weight_decay is dropout
• Assuming weight_decay controls early stopping

4. You have this PyTorch code snippet intended to apply L2 regularization:

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
for data, target in dataloader:
    optimizer.zero_grad()
    output = model(data)
    loss = loss_fn(output, target) + 0.01 * torch.sum(model.parameters())
    loss.backward()
    optimizer.step()

What is wrong with this code regarding regularization?

medium

A. It uses SGD optimizer which does not support regularization.

B. It forgets to call optimizer.zero_grad() before backward.

C. It applies regularization after optimizer.step(), so no effect.

D. It incorrectly sums parameters instead of their squares for L2 penalty.

Solution

1. Step 1: Check how L2 regularization is computed

   L2 regularization requires summing the squares of parameters, not just their values.

2. Step 2: Analyze the code's regularization term

   The code sums parameters directly with torch.sum(model.parameters()), which is incorrect for L2 penalty.

3. Final Answer:

   It incorrectly sums parameters instead of their squares for L2 penalty. -> Option D

4. Quick Check:

   L2 penalty = sum of squares, not sum of values [OK]

Hint: L2 regularization sums squares of weights, not weights themselves [OK]

Common Mistakes:

• Summing parameters instead of squared parameters
• Thinking SGD can't use regularization
• Misplacing optimizer.zero_grad() call

5. You train two PyTorch models on the same dataset: Model A uses no regularization, Model B uses L2 regularization with weight_decay=0.05. After training, Model A has training accuracy 98% but test accuracy 70%, while Model B has training accuracy 90% and test accuracy 85%. What explains this difference?

hard

A. Model A's higher training accuracy means it will always perform better on test data.

B. Model B's regularization reduced overfitting by keeping weights smaller, improving test accuracy.

C. Model B used a larger learning rate, causing better generalization.

D. Model A trained longer, so it has better test accuracy.

Solution

1. Step 1: Compare training and test accuracies

   Model A fits training data very well but performs poorly on test data, indicating overfitting.

2. Step 2: Understand effect of L2 regularization on Model B

   Model B has lower training accuracy but better test accuracy because regularization keeps weights smaller, improving generalization.

3. Final Answer:

   Model B's regularization reduced overfitting by keeping weights smaller, improving test accuracy. -> Option B

4. Quick Check:

   Regularization = smaller weights = better test accuracy [OK]

Hint: Better test accuracy with regularization means less overfitting [OK]

Common Mistakes:

• Assuming higher training accuracy means better test accuracy
• Confusing learning rate with regularization effect
• Ignoring the role of weight size in generalization