forward method in PyTorch - Model Metrics & Evaluation

Metrics & Evaluation - forward method

Which metric matters for the forward method and WHY

The forward method in PyTorch defines how input data moves through the model to produce output predictions. To evaluate if this method works well, we look at loss and accuracy during training and testing.

Loss tells us how far the model's predictions are from the true answers. A lower loss means the forward method is producing better outputs.

Accuracy shows how many predictions are correct. It helps us understand if the forward method is making useful decisions.

These metrics matter because the forward method directly controls the model's output. If it is wrong, the model cannot learn well.

Confusion matrix example for forward method output

Imagine a simple model classifying images as cats or dogs. After running the forward method on test data, we get this confusion matrix:

      | Predicted Cat | Predicted Dog |
      |---------------|---------------|
      | True Cat: 40  | False Negative: 10 |
      | False Positive: 5  | True Dog: 45  |
    

Here:

• TP (True Positive) = 40 (correct cat predictions)
• FP (False Positive) = 5 (dog predicted as cat)
• FN (False Negative) = 10 (cat predicted as dog)
• TN (True Negative) = 45 (correct dog predictions)

These numbers come from the forward method's output compared to true labels.

Precision vs Recall tradeoff in forward method outputs

The forward method outputs predictions that affect precision and recall.

Precision = TP / (TP + FP) measures how many predicted positives are actually correct.

Recall = TP / (TP + FN) measures how many actual positives were found.

For example, in a spam filter model, the forward method should favor high precision to avoid marking good emails as spam.

In a disease detector, the forward method should favor high recall to catch as many sick patients as possible.

Adjusting the forward method's output threshold changes this tradeoff.

Good vs Bad metric values for forward method outputs

Good forward method outputs produce:

• Low loss (e.g., below 0.1 on training data)
• High accuracy (e.g., above 90%)
• Balanced precision and recall (both above 80%) depending on use case

Bad outputs show:

• High loss (e.g., above 1.0)
• Low accuracy (e.g., below 50%)
• Very low precision or recall (below 50%) indicating poor predictions

These values tell us if the forward method is correctly transforming inputs to useful outputs.

Common pitfalls in evaluating forward method outputs

• Ignoring loss trends: A forward method might produce outputs that seem okay but loss does not decrease, meaning learning is not happening.
• Overfitting: Forward method outputs may be perfect on training data but fail on new data.
• Data leakage: If test data leaks into training, forward method outputs look better than reality.
• Wrong metric use: Using accuracy alone on imbalanced data can mislead about forward method quality.

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

No, this is not good for fraud detection.

Even though accuracy is high, the forward method misses 88% of fraud cases (low recall). This means many frauds go undetected.

For fraud, recall is critical because missing fraud is costly. The forward method needs adjustment to improve recall.

Key Result

The forward method's quality is best judged by loss and balanced precision-recall metrics reflecting correct output predictions.

Practice

1. What is the main purpose of the forward method in a PyTorch model?

easy

A. To define how input data passes through the model layers

B. To initialize model weights

C. To save the model to disk

D. To load data from a dataset

Solution

1. Step 1: Understand the role of forward in PyTorch

   The forward method specifies the computation performed on input data as it passes through the model.

2. Step 2: Differentiate from other methods

   Initialization and saving/loading are handled by other methods, not forward.

3. Final Answer:

   To define how input data passes through the model layers -> Option A

4. Quick Check:

   forward defines data flow [OK]

Hint: Remember: forward = data flow through model [OK]

Common Mistakes:

• Confusing forward with initialization
• Thinking forward saves or loads data
• Assuming forward is called manually

2. Which of the following is the correct way to define the forward method inside a PyTorch nn.Module subclass?

easy

A. def Forward(self, x): return x * 2

B. def forward(self, x): return x * 2

C. def forward(x): return x * 2

D. def forward(self): return x * 2

Solution

1. Step 1: Check method signature requirements

   The forward method must have self as the first argument and input data as the second.

2. Step 2: Validate method name and parameters

   def forward(self, x): return x * 2 correctly uses lowercase forward and includes self and x. Others have wrong case, missing self, or missing input.

3. Final Answer:

   def forward(self, x): return x * 2 -> Option B

4. Quick Check:

   Correct method name and parameters = def forward(self, x): return x * 2 [OK]

Hint: Always use lowercase 'forward' with self and input args [OK]

Common Mistakes:

• Capitalizing 'Forward' instead of 'forward'
• Omitting 'self' parameter
• Missing input argument in method

3. Given the following PyTorch model code, what will be the output when calling model(torch.tensor([2.0]))?

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)
        self.linear.weight.data.fill_(2.0)
        self.linear.bias.data.fill_(1.0)
    def forward(self, x):
        return self.linear(x)

model = SimpleModel()

medium

A. tensor([5.0])

B. tensor([4.0])

C. tensor([2.0])

D. tensor([1.0])

Solution

1. Step 1: Calculate linear layer output

   The linear layer output is weight * input + bias = 2.0 * 2.0 + 1.0 = 5.0.

2. Step 2: Confirm output tensor

   The model returns tensor([5.0]) as output.

3. Final Answer:

   tensor([5.0]) -> Option A

4. Quick Check:

   Output = 2*2 + 1 = 5 [OK]

Hint: Output = weight * input + bias in linear layer [OK]

Common Mistakes:

• Ignoring bias term
• Using wrong weight value
• Confusing input tensor shape

4. Identify the error in this PyTorch model's forward method:

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(3, 1)
    def forward(self, x):
        x = self.fc
        return x

medium

A. Input tensor shape is incorrect

B. Missing call to super().__init__() in __init__

C. The forward method should not have a return statement

D. The forward method returns the layer object, not the output

Solution

1. Step 1: Analyze the forward method code

   The line x = self.fc assigns the layer object to x instead of calling it.

2. Step 2: Identify correct usage

   To get output, the layer must be called with input: x = self.fc(x).

3. Final Answer:

   The forward method returns the layer object, not the output -> Option D

4. Quick Check:

   Layer must be called with input, not assigned [OK]

Hint: Call layers with input inside forward, don't assign layer itself [OK]

Common Mistakes:

• Assigning layer instead of calling it
• Forgetting to call super().__init__()
• Ignoring input tensor shape

5. You want to create a PyTorch model that applies two linear layers sequentially in the forward method, with a ReLU activation in between. Which forward method implementation is correct?

class TwoLayerModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 3)
        self.fc2 = nn.Linear(3, 2)
        self.relu = nn.ReLU()

    def forward(self, x):
        ?

hard

A. x = self.fc1(x)
x = self.fc2(x)
x = self.relu(x)
return x

B. x = self.relu(self.fc1(x))
return self.fc2(x)

C. x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x

D. x = self.fc1(x)
return self.fc2(self.relu(x))

Solution

1. Step 1: Understand the desired layer order

   The model should apply fc1, then ReLU, then fc2 in sequence.

2. Step 2: Check each option's order

   x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x correctly applies fc1, then ReLU, then fc2. Others change the order or skip activation between layers.

3. Final Answer:

   x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x -> Option C

4. Quick Check:

   Layer1 -> ReLU -> Layer2 sequence = x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x [OK]

Hint: Apply activation between layers, not after last layer [OK]

Common Mistakes:

• Applying activation after last layer
• Skipping activation between layers
• Incorrect order of operations