Loss functions are specific to supervised learning, whose training tasks assume the existence of a correct answer: the ground truth. Conventional unsupervised learning algorithms, such as clustering or association, do not involve “right” or “wrong” answers, as they solely seek to discover intrinsic patterns in unlabeled data.

Supervised learning requires labeled data sets, in which manual annotations provide ground truth for each training sample. For example, image segmentation models require training samples with each pixel annotated according to its correct class. In self-supervised learning, which masks or transforms parts of unlabeled data samples and tasks models with reconstructing them, the original sample itself serves as ground truth.

Loss functions are not simply evaluation metrics. Their explicit purpose is not only to measure model success, but also serve as input to an algorithm that optimizes the model’s parameters to minimize loss.

Optimization algorithms such as gradient descent typically use the gradient of the loss function. The gradient is the derivative of a function with multiple variables. Essentially, a derivative describes the rate and amount that the output of a function is changing at any point. Therefore, it’s important for loss functions to be differentiable: in other words, to have a derivative at all points.

Machine learning models learn to make accurate predictions through adjustments to certain model parameters. For example, a simple linear regression algorithm models data with the function y = wx+b, where y is the model output, x is the input, w is a weight and b is bias. The model learns by updating the weight and bias terms until the loss function has been sufficiently minimized. 

Using the gradient of the loss function, optimization algorithms determine which direction to “step” model parameters in order to move down the gradient and thereby reduce loss.

Deep learning models employ large artificial neural networks, comprising layers of interconnected neurons that each have their own nonlinear activation function, rather than relying on a singular function. To differentiate the entire network requires calculating the partial derivatives of hundreds, thousands or even millions of separate variables and activation functions with respect to the others.

 To do so, neural networks use backpropagation to find the gradient of the loss function after a forward pass that ends with a prediction on a data point from the training data set. Short for backward propagation of error, backpropagation begins with the output of the loss function. In a backwards pass through the network from output layer to input layer, backpropagation uses the chain rule to calculate how each individual weight and bias in the network contributed to overall loss. 

The resulting gradient of partial derivatives for the entire network can then be used by gradient descent algorithms to iteratively update the network weights until loss has been sufficiently minimized.

Though models are trained and validated by making predictions on a training data set, performing well on training examples is not the ultimate objective. The true goal of machine learning is to train models that generalize well to new examples.

Relying solely on the minimization of a singular loss function is called “empirical risk minimization.” While it has an obvious, simple appeal, it runs the risk of a model overfitting the training data and thus generalizing poorly. To reduce this risk, among other purposes, many algorithms and architectures introduce regularization terms that modify the primary loss function.

For example, mean absolute error (MAE)—which in this context is called L1 regularization—can be used to enforce sparsity by penalizing the number of activated neurons in a neural network or the magnitude of their activation.

The mean squared error loss function, also called L2 loss or quadratic loss, is generally the default for most regression algorithms. As its name suggests, MSE is calculated as the average of the squared differences between the predicted value and the true value across all training examples. The formula for calculating the MSE across n data points is written as $\frac{1}{n}\sum _{i=1}^n(y_i-\widehat{y_i}{)}^2$, in which y is the true value and ŷ is the predicted value.

Squaring the error means that the resulting value is always positive: as such, MSE evaluates only the magnitude of error and not its direction. Squaring the error also gives large mistakes a disproportionately heavy impact on overall loss, which strongly punishes outliers and incentivizes the model to reduce them. MSE is thus suitable when the target outputs are assumed to have a normal (Gaussian) distribution.

MSE is always differentiable, making it practical for optimizing regression models through gradient descent.
 

Mean squared logarithmic error (MSLE)
For regression problems where the target outputs have a very wide range of potential values, such as those involving exponential growth, heavy penalization of large errors might be counterproductive. Mean squared logarithmic error (MSLE) offsets this problem by averaging the squares of the natural logarithm of the differences between the predicted and average values. However, it's worth noting that MSLE assigns a greater penalty to predictions that are too low than to predictions that are too high.

The formula for MSLE is written as $\frac{1}{n}\sum _{i=1}^n\left({\log }_e\right(1+y_i)-{\log }_e(1+\widehat{y_i}){)}^2$

Root mean squared error (RMSE)
Root mean squared error is the square root of the MSE, which makes it closely related to the formula for standard deviations. Specifically, RMSE is calculated as  $\sqrt{\frac{\sum _{i=1}^n(y_i-\widehat{y_i}{)}^2}{n}}$ .

RMSE thus largely mirrors the qualities of MSE in terms of sensitivity to outliers but is easier to interpret because it expresses loss in the same units as the output value itself. This benefit is somewhat tempered by the fact that calculating RSME requires another step compared to calculating MSE, which increases computation costs.

Mean absolute error or L1 loss, measures the average absolute difference between the predicted value and actual value. Like MSE, MAE is always positive and doesn’t distinguish between estimates that are too high or too low. It’s calculated as the sum of the absolute value of all errors divided by the sample size:  $\frac{1}{n}\sum _{i=1}^n|y_i-\widehat{y_i}|$

Because it doesn’t square each loss value, MAE is more robust to outliers than MSE. MAE is thus ideal when the data might contain some extreme values that shouldn’t overly impact the model. L1 loss also penalizes small errors more than L2 loss.  

The MAE loss function is not differentiable in cases where the predicted output matches the actual output. Therefore, MAE requires more workaround steps during optimization.

Huber loss, also called smooth L1 loss, aims to balance the strengths of both MAE and MSE. It incorporates an adjustable hyperparameter, δ, that acts as a transition point: for loss values below or equal to δ, Huber loss is quadratic (such as MSE); for loss values greater than δ, Huber loss is linear (such as MAE).

 $L_{\delta }=\{<!--\; -->\begin{array}{cc}\frac{1}{2}(y-\hat{y}{)}^2& if\left|(y-\hat{y})\right|<\delta \\ \delta (\left|(y-\hat{y})\right|-\frac{1}{2}\delta )& otherwise\end{array}$

Huber loss thus offers a fully differentiable function with MAE’s robustness to outliers and MSE’s ease of optimization through gradient descent. The transition from quadratic to linear behavior at δ also results in an optimization less prone to problems such as vanishing or exploding gradients when compared to MSE loss.

These benefits are tempered by the need to carefully define δ, adding complexity to model development. Huber loss is most appropriate when neither MSE nor MAE can yield satisfactory results, such as when a model should be robust to outliers but still harshly penalize extreme values that are beyond some specific threshold.

Multi-class classification problems can be approached in two ways. One approach is to compute the relative probability of a data point belonging to each potential category, then select the category assigned the highest probability. This approach is typically employed by neural networks, using a softmax activation function for neurons in the output layer. The alternative approach is to divide the problem into a series of binary classification problems.

In most cases, classification loss is calculated in terms of entropy. Entropy, in plain language, is a measure of uncertainty within a system. For an intuitive example, compare flipping coins to rolling dice: the former has lower entropy, as there are fewer potential outcomes in a coin flip (2) than in a dice toss (6).

In supervised learning, model predictions are compared to the ground truth classifications provided by data labels. Those ground truth labels are certain and thus have low or no entropy. As such, we can measure loss in terms of the difference in certainty we’d have using the ground truth labels to the certainty of the labels predicted by the model.

The formula for cross-entropy loss (CEL) is derived from that of Kullback-Leibler divergence (KL divergence), which measures the difference between two probability distributions. Ultimately, minimizing loss entails minimizing the difference between the ground truth distribution of probabilities assigned to each potential label and the relative probabilities for each label predicted by the model.

Binary cross-entropy (log loss)
Binary cross-entropy loss, also called log loss, is used for binary classification. Binary classification algorithms typically output a likelihood value between 0 and 1. For example, in an email spam detection model, email inputs that result in outputs closer to 1 might be labeled “spam.” Inputs yielding outputs closer to 0 would be classified as “not spam.” An output of 0.5 would indicate maximum uncertainty or entropy. 

Though the algorithm will output values between 0 and 1, the ground truth values for the correct predictions are exactly “0” or “1.” Minimizing binary cross-entropy loss thus entails not only penalizing incorrect predictions but also penalizing predictions with low certainty. This incentivizes the model to learn parameters that yield predictions that are not only correct but also confident. Furthermore, focusing on the logarithms of predicted likelihood values results in the algorithm more heavily penalizing predictions that are confidently wrong.

To maintain the common convention of lower loss values meaning less error, the result is multiplied by -1. Log loss for a single example i is thus calculated as $–(y_i·\log (p\left(y_i\right))+(1-y_i)·\log (1-p\left(y_i\right)\left)\right)$ , where y_i is the true likelihood—either 0 or 1—and p(y_i) is the predicted likelihood. Average loss across an entire set of n training examples is thus calculated as  $–\frac{1}{n}\sum _{i=1}^n{y}_i·log\left(p\right(y_i\left)\right)+(1-y_i)·log(1-p(y_i\left)\right)$ .

Categorical cross-entropy loss
Categorical cross-entropy loss (CCEL) applies this same principle to multi-class classification. A multi-class classification model will usually output a value for each potential class, representing the probability of an input belonging to each respective category. In other words, they output predictions as a probability distribution.

In deep learning, neural network classifiers typically use a softmax activation function for neurons in the output layer. Each output neuron’s value is mapped to a number between 0 and 1, with the values collectively summing up to 1.

For example, in a data point containing only one potential category, the ground truth values for each prediction thus comprise “1” for the true class and “0” for each incorrect class. Minimizing CCEL entails increasing the output value for the correct class and decreasing output values for incorrect classes, thereby bringing the probability distribution closer to that of the ground truth. For each example, log loss must be calculated for each potential classification predicted by the model.

Hinge loss is an alternative loss function for binary classification problems, and is particularly well suited to optimizing support vector machine (SVM) models. Specifically, it’s an effective loss function for optimizing a decision boundary separating two classes: points can thereafter be classified according to which side of the decision boundary they fall on.

In algorithms using hinge loss, the ground truth value for each binary label is mapped to {-1, 1} rather than {0,1}. The hinge loss function ℓ is defined as ℓ(𝑦)=max(0,1−𝑡⋅𝑦), wherein t is the true label and y is the output of the classifier. The outcome of this equation is always non-negative: if 1−𝑡⋅𝑦 is negative—which is only possible when t and y are the same sign because the model predicted the correct class—loss is instead defined as 0.

This provides various possibilities and incentives:

• When model predictions are correct and confident—that is, when y is the correct sign and |y| ≥ 1—the value of 1–t⋅𝑦 will be negative and therefore ℓ = 0.
   

• When model predictions are correct, but not confident—that is, when y is the correct sign but |y| < 1—the value of ℓ will be positive, between 0 and 1. This disincentivizes unconfident predictions.
   

• When model predictions are incorrect—that is, when y is the incorrect sign—the value of ℓ will be greater than 1 and increase linearly with the value of |y|. This strongly disincentivizes incorrect predictions.