Loss functions (MSELoss, CrossEntropyLoss) in PyTorch

Introduction

Loss functions tell us how wrong our model's predictions are. They help the model learn by showing it what to fix.

When predicting continuous numbers like house prices (use MSELoss).

When classifying images into categories like cats or dogs (use CrossEntropyLoss).

When training a model to guess probabilities for multiple classes.

When you want to measure how close your predicted values are to real values.

When you want to improve your model step-by-step by minimizing errors.

Syntax

PyTorch

import torch.nn as nn

# For regression tasks (continuous values)
loss_fn = nn.MSELoss()

# For classification tasks (multiple classes)
loss_fn = nn.CrossEntropyLoss()

MSELoss stands for Mean Squared Error Loss. It measures the average squared difference between predicted and true values.

CrossEntropyLoss combines softmax and negative log likelihood. It is used for classification tasks with class labels.

Examples

This example calculates MSE loss between predicted and true continuous values.

PyTorch

import torch
import torch.nn as nn

loss_fn = nn.MSELoss()
predictions = torch.tensor([2.5, 0.0, 2.0, 8.0])
true_values = torch.tensor([3.0, -0.5, 2.0, 7.0])
loss = loss_fn(predictions, true_values)
print(loss.item())

This example calculates CrossEntropy loss for two samples with three classes each.

PyTorch

import torch
import torch.nn as nn

loss_fn = nn.CrossEntropyLoss()
predictions = torch.tensor([[1.0, 2.0, 0.5], [0.5, 0.2, 2.1]])  # raw scores (logits)
true_labels = torch.tensor([1, 2])  # class indices
loss = loss_fn(predictions, true_labels)
print(loss.item())

Sample Model

This program shows how to use MSELoss for a regression example and CrossEntropyLoss for a classification example. It prints the loss values.

PyTorch

import torch
import torch.nn as nn

# Example with MSELoss (regression)
loss_fn_mse = nn.MSELoss()
pred_mse = torch.tensor([1.5, 2.0, 3.5])
true_mse = torch.tensor([2.0, 2.0, 3.0])
loss_mse = loss_fn_mse(pred_mse, true_mse)
print(f"MSE Loss: {loss_mse.item():.4f}")

# Example with CrossEntropyLoss (classification)
loss_fn_ce = nn.CrossEntropyLoss()
pred_ce = torch.tensor([[2.0, 1.0, 0.1], [0.1, 0.2, 3.0]])  # logits
true_ce = torch.tensor([0, 2])  # class labels
loss_ce = loss_fn_ce(pred_ce, true_ce)
print(f"CrossEntropy Loss: {loss_ce.item():.4f}")

Important Notes

For CrossEntropyLoss, input predictions should be raw scores (logits), not probabilities.

MSELoss expects predictions and targets to have the same shape and be continuous values.

Loss values help guide the model to improve by minimizing them during training.

Summary

Loss functions measure how far predictions are from true values.

MSELoss is for continuous value prediction (regression).

CrossEntropyLoss is for classification with class labels.

Practice

1. Which loss function in PyTorch is best suited for predicting continuous values like house prices?

easy

A. torch.nn.MSELoss

B. torch.nn.CrossEntropyLoss

C. torch.nn.BCELoss

D. torch.nn.NLLLoss

Solution

1. Step 1: Understand the type of prediction

   Predicting house prices is a regression problem where output is continuous.

2. Step 2: Match loss function to problem type

   MSELoss calculates mean squared error, ideal for continuous outputs. CrossEntropyLoss is for classification, not regression.

3. Final Answer:

   torch.nn.MSELoss -> Option A

4. Quick Check:

   Regression uses MSELoss = C [OK]

Hint: Use MSELoss for continuous outputs, CrossEntropyLoss for classes [OK]

Common Mistakes:

• Choosing CrossEntropyLoss for regression tasks
• Confusing BCELoss with MSELoss
• Using NLLLoss without log probabilities

2. Which of the following is the correct way to create a CrossEntropyLoss object in PyTorch?

easy

A. loss = torch.nn.CrossEntropy()

B. loss = torch.nn.MSELoss()

C. loss = torch.nn.CrossEntropyLoss()

D. loss = torch.CrossEntropyLoss()

Solution

1. Step 1: Recall PyTorch loss function syntax

   Loss functions are in torch.nn and instantiated with parentheses.

2. Step 2: Identify correct class name and module

   CrossEntropyLoss is the correct class name under torch.nn. Options A misses 'Loss' and C misses 'nn'.

3. Final Answer:

   loss = torch.nn.CrossEntropyLoss() -> Option C

4. Quick Check:

   Correct class and module = D [OK]

Hint: Use torch.nn.CrossEntropyLoss() exactly for classification loss [OK]

Common Mistakes:

• Missing parentheses when creating loss object
• Using torch.CrossEntropyLoss() instead of torch.nn.CrossEntropyLoss()
• Confusing MSELoss with CrossEntropyLoss

3. What will be the output loss value when using torch.nn.MSELoss on predictions tensor([2.0, 3.0]) and targets tensor([1.0, 5.0])?

medium

A. 2.5

B. 3.0

C. 1.5

D. 4.0

Solution

1. Step 1: Calculate squared differences

   Differences: (2.0-1.0)=1.0, (3.0-5.0)=-2.0; squared: 1.0, 4.0

2. Step 2: Compute mean of squared differences

   Mean = (1.0 + 4.0) / 2 = 2.5

3. Final Answer:

   2.5 -> Option A

4. Quick Check:

   MSE = mean squared error = 2.5 [OK]

Hint: Square errors, then average for MSELoss output [OK]

Common Mistakes:

• Forgetting to square the differences
• Summing without averaging
• Mixing up prediction and target order

4. Given this code snippet, what is the error?

import torch
loss_fn = torch.nn.CrossEntropyLoss()
pred = torch.tensor([[0.2, 0.8], [0.6, 0.4]])
target = torch.tensor([1, 0])
loss = loss_fn(pred, target)
print(loss.item())

medium

A. Loss function should be MSELoss for this target

B. Target tensor should be one-hot encoded

C. No error, code runs correctly

D. Predictions should be raw scores (logits), not probabilities

Solution

1. Step 1: Check input requirements for CrossEntropyLoss

   CrossEntropyLoss expects raw scores (logits), not probabilities.

2. Step 2: Analyze given predictions

   Predictions are probabilities (sum to 1), so applying CrossEntropyLoss directly causes incorrect loss calculation.

3. Final Answer:

   Predictions should be raw scores (logits), not probabilities -> Option D

4. Quick Check:

   CrossEntropyLoss needs logits = A [OK]

Hint: Use logits, not probabilities, with CrossEntropyLoss [OK]

Common Mistakes:

• Passing probabilities instead of logits to CrossEntropyLoss
• Using one-hot targets instead of class indices
• Confusing MSELoss with CrossEntropyLoss for classification

5. You have a multi-class classification problem with 4 classes. Your model outputs raw scores (logits) of shape (batch_size, 4). Which loss function and target format should you use in PyTorch?

hard

A. Use torch.nn.MSELoss with target as one-hot vectors

B. Use torch.nn.CrossEntropyLoss with target as class indices (0 to 3)

C. Use torch.nn.BCELoss with target as class indices

D. Use torch.nn.CrossEntropyLoss with target as one-hot vectors

Solution

1. Step 1: Identify loss function for multi-class classification

   CrossEntropyLoss is designed for multi-class classification with logits.

2. Step 2: Determine correct target format

   CrossEntropyLoss expects target as class indices (integers), not one-hot vectors.

3. Final Answer:

   Use torch.nn.CrossEntropyLoss with target as class indices (0 to 3) -> Option B

4. Quick Check:

   CrossEntropyLoss + class indices = B [OK]

Hint: CrossEntropyLoss needs logits and integer class labels [OK]

Common Mistakes:

• Passing one-hot vectors as targets to CrossEntropyLoss
• Using MSELoss for classification
• Using BCELoss for multi-class without sigmoid