Why automatic differentiation enables training in PyTorch - Why Metrics Matter

Metrics & Evaluation - Why automatic differentiation enables training

Which metric matters for this concept and WHY

When training a model, the key metric is the loss. Loss tells us how far the model's predictions are from the true answers. Automatic differentiation helps us find the direction to change model settings to reduce this loss. Without it, training would be very slow or impossible because we wouldn't know how to improve the model step-by-step.

Confusion matrix or equivalent visualization (ASCII)

Automatic differentiation itself does not produce a confusion matrix, but it helps minimize loss which improves metrics like accuracy, precision, and recall shown in a confusion matrix.

Confusion Matrix Example (for classification):

          Predicted
          P     N
Actual P  TP    FN
       N  FP    TN

Where:
TP = True Positives
FP = False Positives
TN = True Negatives
FN = False Negatives

Automatic differentiation helps adjust model weights to increase TP and TN, and reduce FP and FN over time.

Precision vs Recall tradeoff with concrete examples

Automatic differentiation helps find model parameters that balance precision and recall by minimizing loss. For example:

• Spam filter: High precision means fewer good emails marked as spam. Automatic differentiation adjusts weights to reduce false positives.
• Cancer detection: High recall means catching most cancer cases. Automatic differentiation helps reduce false negatives.

By computing gradients automatically, the model learns how to improve these tradeoffs efficiently.

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

Good training means loss steadily decreases, showing the model is learning. For example:

• Good: Loss drops from 1.0 to 0.1 over epochs, accuracy rises from 50% to 90%
• Bad: Loss stays high or jumps around, accuracy stays near random chance (e.g., 50% for binary)

Automatic differentiation enables this by providing exact gradients to update model weights correctly.

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

• Accuracy paradox: High accuracy can be misleading if classes are imbalanced. Automatic differentiation optimizes loss, but metric choice matters.
• Data leakage: If training data leaks info from test data, loss looks low but model fails in real use.
• Overfitting: Loss on training data drops but test loss rises. Automatic differentiation updates weights perfectly but model memorizes instead of generalizing.

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

No, this is not good for fraud detection. The model misses 88% of fraud cases (low recall), which is dangerous. Automatic differentiation helped train the model, but the loss function or data might need adjustment to improve recall. High accuracy alone is misleading here.

Key Result

Automatic differentiation enables efficient training by computing exact gradients to reduce loss, improving model predictions and key metrics like accuracy, precision, and recall.

Practice

1. Why is automatic differentiation important for training machine learning models in PyTorch?

easy

A. It stores the training data efficiently.

B. It generates random numbers for model initialization.

C. It visualizes the model architecture.

D. It calculates gradients automatically to update model parameters.

Solution

1. Step 1: Understand the role of gradients in training

   Training adjusts model numbers to reduce errors, which requires knowing how errors change with each number.

2. Step 2: Identify what automatic differentiation does

   Automatic differentiation calculates these changes (gradients) automatically, so the model can update correctly.

3. Final Answer:

   It calculates gradients automatically to update model parameters. -> Option D

4. Quick Check:

   Gradients = Automatic differentiation [OK]

Hint: Automatic differentiation = auto gradient calculation [OK]

Common Mistakes:

• Confusing gradient calculation with data storage
• Thinking it generates random numbers
• Assuming it visualizes models

2. Which PyTorch code snippet correctly enables automatic differentiation for a tensor?

easy

A. tensor = torch.tensor([1.0, 2.0], requires_grad=False)

B. tensor = torch.tensor([1.0, 2.0], requires_grad=True)

C. tensor = torch.tensor([1.0, 2.0]).detach()

D. tensor = torch.tensor([1.0, 2.0]).numpy()

Solution

1. Step 1: Check how to enable gradient tracking

   In PyTorch, setting requires_grad=True tells PyTorch to track operations for gradients.

2. Step 2: Identify the correct code snippet

   tensor = torch.tensor([1.0, 2.0], requires_grad=True) sets requires_grad=True, enabling automatic differentiation.

3. Final Answer:

   tensor = torch.tensor([1.0, 2.0], requires_grad=True) -> Option B

4. Quick Check:

   requires_grad=True enables gradients [OK]

Hint: Use requires_grad=True to track gradients [OK]

Common Mistakes:

• Using requires_grad=False disables gradients
• Calling detach() stops gradient tracking
• Converting to numpy removes gradient info

3. What will be the output of this PyTorch code?

import torch
x = torch.tensor(2.0, requires_grad=True)
y = x ** 3
z = y + 2 * x
z.backward()
print(x.grad.item())

medium

A. 8.0

B. 12.0

C. 14.0

D. 10.0

Solution

1. Step 1: Calculate the function and its derivative

   The function is z = x^3 + 2x. Its derivative is dz/dx = 3x^2 + 2.

2. Step 2: Compute the gradient at x=2.0

   Plug in x=2: dz/dx = 3*(2^2) + 2 = 3*4 + 2 = 12 + 2 = 14.

3. Final Answer:

   14.0 -> Option C

4. Quick Check:

   Derivative at 2 = 14 [OK]

Hint: Derivative of x³+2x at 2 is 14 [OK]

Common Mistakes:

• Forgetting to apply chain rule
• Calculating derivative incorrectly
• Using wrong x value

4. Identify the error in this PyTorch code that prevents training:

import torch
x = torch.tensor([1.0, 2.0, 3.0])
y = x.sum()
y.backward()
print(x.grad)

medium

A. x does not have requires_grad=True, so gradients are not tracked.

B. Using sum() prevents gradient calculation.

C. backward() must be called on x, not y.

D. x.grad should be printed before backward() call.

Solution

1. Step 1: Check if gradients are tracked

   By default, tensors have requires_grad=False, so no gradients are stored.

2. Step 2: Identify why backward() fails to compute gradients

   Since x lacks requires_grad=True, x.grad remains None after backward.

3. Final Answer:

   x does not have requires_grad=True, so gradients are not tracked. -> Option A

4. Quick Check:

   requires_grad=True needed for gradients [OK]

Hint: Set requires_grad=True to track gradients [OK]

Common Mistakes:

• Assuming sum() disables gradients
• Calling backward() on wrong tensor
• Printing grad before backward()

5. You want to train a model with parameters w and b using PyTorch. Which sequence correctly uses automatic differentiation to update parameters after computing loss?

hard

A. loss.backward()
with torch.no_grad():
w -= learning_rate * w.grad
b -= learning_rate * b.grad
w.grad.zero_()
b.grad.zero_()

B. loss.backward()
w = w - learning_rate * w.grad
b = b - learning_rate * b.grad
w.grad.zero_()
b.grad.zero_()

C. loss.backward()
w.grad = None
b.grad = None
w -= learning_rate * w.grad
b -= learning_rate * b.grad

D. loss.backward()
w.grad.zero_()
b.grad.zero_()
w -= learning_rate * w.grad
b -= learning_rate * b.grad

Solution

1. Step 1: Understand gradient update with no_grad()

   Parameter updates must be done without tracking gradients, so use torch.no_grad() context.

2. Step 2: Zero gradients after update

   After updating, gradients must be reset with grad.zero_() to avoid accumulation.

3. Final Answer:

   Use loss.backward(), update inside torch.no_grad(), then zero gradients. -> Option A

4. Quick Check:

   Update params inside no_grad, then zero grads [OK]

Hint: Update params inside no_grad, then zero grads [OK]

Common Mistakes:

• Updating params outside no_grad() causes errors
• Not zeroing gradients after update
• Setting grad to None instead of zero_()