Loss Functions for Autoencoders (MSE, BCE)

The main job of an autoencoder is to take some input data, pass it through a compression (encoding) and then a decompression (decoding) process, and try to make the final output as identical as possible to the original input. How is the autoencoder's performance at this reconstruction task actually measured? This is where loss functions come into play.

Think of a loss function as a way to score the autoencoder's performance. If the reconstructed output is very different from the original input, the loss function gives a high score (high loss), indicating a poor job. If the reconstruction is very similar to the original, the loss function gives a low score (low loss), meaning the autoencoder is doing well. The entire learning process for an autoencoder is about trying to minimize this loss score.

The loss function takes both the original input and the autoencoder's reconstruction to compute an error score.

Let's look at two common loss functions used for training autoencoders: Mean Squared Error (MSE) and Binary Cross-Entropy (BCE).

Mean Squared Error (MSE)

Mean Squared Error is a very common loss function, especially when your input data (and thus your expected output data) consists of continuous numerical values. For example, if your autoencoder is learning to reconstruct grayscale images where pixel values range from 0 (black) to 255 (white), or perhaps normalized values between 0.0 and 1.0, MSE is a good candidate.

MSE calculates the average of the squared differences between each individual element of the original input and the reconstructed output. Here's how it looks mathematically:

$$L(x, \hat{x}) = \frac{1}{n} \sum_{i=1}^{n} (x_i - \hat{x}_i)^2$$

Let's break this down:

• $x$ represents the original input (e.g., a vector of pixel values).
• $\hat{x}$ (pronounced "x-hat") represents the reconstructed output from the autoencoder.
• $x_i$ is the value of the $i$-th element (e.g., $i$-th pixel) in the original input.
• $\hat{x}_i$ is the value of the $i$-th element in the reconstructed output.
• $(x_i - \hat{x}_i)$ is the difference, or error, for that specific element.
• $(x_i - \hat{x}_i)^2$ is that difference squared. We square it for two main reasons:
  1. It ensures that the result is always positive. We care about the magnitude of the error, not whether the prediction was higher or lower.
  2. It penalizes larger errors more heavily. An error of 2 becomes 4 when squared, while an error of 0.5 becomes 0.25. This means the autoencoder will work harder to fix big mistakes.
• $\sum_{i=1}^{n}$ means we sum up these squared differences for all $n$ elements in our input (e.g., for all pixels in an image).
• $\frac{1}{n}$ means we take the average of these summed squared differences. This makes the loss value independent of the number of elements, which is helpful when comparing performance across different input sizes.

When to Use MSE:

• When your input data (and thus your desired output) consists of real-valued numbers where the magnitude of differences is meaningful (e.g., image pixel intensities, sensor readings).
• It's often paired with output layers in the decoder that can produce any real number (like a linear activation) or values in a specific range if the data is normalized (e.g., using Tanh for [-1,1] or Sigmoid for [0,1], though Sigmoid is more commonly associated with BCE for probabilistic outputs).

A smaller MSE value means the reconstructed output is, on average, very close to the original input. A larger MSE indicates a poorer reconstruction.

Binary Cross-Entropy (BCE)

Binary Cross-Entropy, often abbreviated as BCE, is another popular loss function. It's particularly well-suited when the input data (and therefore the target output) can be thought of as probabilities, or when the data is binary (consisting of only two values, like 0 or 1).

For instance, if you're working with black and white images where each pixel is either 0 (black) or 1 (white), or if your input pixel values are normalized to be between 0.0 and 1.0 and you want the autoencoder's output to also represent probabilities for each pixel, BCE is a strong choice.

The formula for Binary Cross-Entropy is:

$$L(x, \hat{x}) = - \frac{1}{n} \sum_{i=1}^{n} [x_i \log(\hat{x}_i) + (1-x_i) \log(1-\hat{x}_i)]$$

Let's decode this one:

• $x_i$ is the true value of the $i$-th element in the input. For BCE, $x_i$ is typically either 0 or 1.
• $\hat{x}_i$ is the autoencoder's predicted probability that the $i$-th element is 1. This value should be between 0 and 1 (usually ensured by a Sigmoid activation function in the decoder's final layer).
• $\log$ refers to the natural logarithm.

The formula looks a bit more complex, but its behavior is quite intuitive:

• If the true value $x_i$ is 1: The second part of the sum, $(1-x_i) \log(1-\hat{x}_i)$, becomes $0 \cdot \log(1-\hat{x}_i) = 0$. So, the loss for this element is just $-x_i \log(\hat{x}_i) = -\log(\hat{x}_i)$. To minimize this (make it a small positive number, since loss is usually positive), we need $\hat{x}_i$ to be as close to 1 as possible. If $\hat{x}_i$ is close to 1, $\log(\hat{x}_i)$ is close to 0. If $\hat{x}_i$ is close to 0 (a bad prediction), $\log(\hat{x}_i)$ becomes a large negative number, and $-\log(\hat{x}_i)$ becomes a large positive number (high loss).
• If the true value $x_i$ is 0: The first part of the sum, $x_i \log(\hat{x}_i)$, becomes $0 \cdot \log(\hat{x}_i) = 0$. So, the loss for this element is $-(1-x_i) \log(1-\hat{x}_i) = -\log(1-\hat{x}_i)$. To minimize this, we need $1-\hat{x}_i$ to be close to 1, which means $\hat{x}_i$ must be close to 0. If $\hat{x}_i$ is close to 0 (a good prediction), $1-\hat{x}_i$ is close to 1, and $\log(1-\hat{x}_i)$ is close to 0. If $\hat{x}_i$ is close to 1 (a bad prediction), $1-\hat{x}_i$ is close to 0, $\log(1-\hat{x}_i)$ becomes a large negative number, and $-\log(1-\hat{x}_i)$ becomes a large positive number (high loss).

The $\frac{1}{n}$ at the beginning again averages the loss across all $n$ elements. The negative sign at the very front ensures that the overall loss is positive, as log probabilities are negative or zero.

When to Use BCE:

• When your input data is binary (0s and 1s).
• When your input data is normalized to the range [0, 1] and can be interpreted as probabilities (e.g., pixel intensities of an image where 0 is black, 1 is white, and values in between are shades of gray that you want to model probabilistically).
• It is almost always paired with a Sigmoid activation function in the output layer of the decoder, as Sigmoid squashes output values into the [0, 1] range, making them suitable as inputs for the log function in BCE.

BCE is effective because it heavily penalizes predictions that are confidently wrong (e.g., predicting a probability near 0 when the true value is 1, or vice versa).

Choosing Your Loss Function

The choice between MSE and BCE (or other loss functions) largely depends on the nature of your data and what you want the autoencoder to learn:

• If your data values are continuous and spread across a wide range (or normalized to a range like [-1, 1] or [0, 1] but not strictly probabilities), MSE is often a sensible default.
• If your data is binary, or if your data is normalized to [0, 1] and you're treating the outputs as probabilities of being "active" (like a pixel being white), BCE is generally preferred. This often matches well with a Sigmoid activation in the decoder's output layer.

Understanding these loss functions is a significant step because the entire training process of an autoencoder revolves around minimizing the value calculated by the chosen loss function. In the next sections, we'll see how the autoencoder uses this loss value to adjust its internal parameters and get better at reconstruction.