cost function in machine learning

in machine learning, a cost function is a measure of how well a machine learning model is performing. it is a mathematical function that takes in the model's predicted values and the true values of the data and outputs a single scalar value that represents the cost or error of the model's predictions. the goal of training a machine learning model is to minimize the cost function.

the choice of cost function depends on the specific problem being solved. for example, in binary classification tasks, where the goal is to predict whether a data point belongs to one of two classes, the most commonly used cost function is the binary cross-entropy function. in regression tasks, where the goal is to predict a continuous value, the mean squared error function is commonly used.

cost functions for classification problems

classification problems are categorized as supervised machine learning tasks. the object of a supervised learning model is to find optimal parameter values that minimize the cost function. a classification problem can be binary classification or multi-class classification. for binary classification, the most commonly used cost function is binary cross-entropy function, and for multi-class classification, the most commonly used cost function is categorical cross-entropy function.

1. binary cross-entropy loss

let's take a closer look at the binary cross-entropy function. given a binary classification problem with two classes, let's call them class 0 and class 1, and let's denote the model's predicted probability of class 1 as "p(y=1|x)". the true label of each data point is either 0 or 1. we can define the binary cross-entropy cost function as follows −

for a single sample,

$$\mathrm{\text{bce} = -\left ( y\times log\left ( p \right )+\left ( 1-y \right )\times log\left ( 1-p \right ) \right )}$$

for whole dataset,

$$\mathrm{\text{bce} = -\frac{1}{n} \sum_{i=1}^n \left[ y_i \log(p_i) + (1 - y_i) \log(1 - p_i) \right]}$$

where "${n}$" is the number of data points, "${y_{i}}$" is the true label of ${i}$th data point, and "${p_{i}}$" is the corresponding predicted probability of class 1.

the binary cross-entropy function has several desirable properties. first, it is a convex function, which means that it has a unique global minimum that can be found using optimization techniques. second, it is a strictly positive function, which means that it penalizes incorrect predictions. third, it is a differentiable function, which means that it can be used with gradient-based optimization algorithms.

2. categorical cross-entropy loss

categorical cross-entropy loss is used for multi-class classification problems such as image classification, etc. it measures the dissimilarity between the predicted probability distribution and the true distribution for each class.

$$\mathrm{\text{cce} = -\frac{1}{n} \sum_{i=1}^n \sum_{j=1}^k y_{ij} \log(\hat{y}_{ij})}$$

cost functions for regression problems

the cost function for regression computes the differences between the actual values and the model's predicted values. there are different types of errors that can be used as a cost function. the most common cost functions for regression problems are mean absolute error (mae) and mean squared error (mse).

1. mean squared error (mse)

mean square error (mse) measures the average squared difference between the predicted and actual values.

$$\mathrm{\text{mse} = \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2}$$

2. mean absolute error (mae)

mean absolute error (mae) measures the average absolute difference between the predicted and actual values. it is less sensitive to outliers than mse.

$$\mathrm{ \text{mae} = \frac{1}{n} \sum_{i=1}^n |y_i - \hat{y}_i| }$$

implementation of binary cross-entropy loss in python

now let's see how to implement the binary cross-entropy function in python using numpy −

import numpy as np

def binary_cross_entropy(y_pred, y_true):
   eps = 1e-15
   y_pred = np.clip(y_pred, eps, 1 - eps)
   return -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)).mean()

in this implementation, we first clip the predicted probabilities to avoid numerical issues with logarithms. we then compute the binary cross-entropy loss using numpy functions and return the mean over all data points.

once we have defined a cost function, we can use it to train a machine learning model using optimization techniques such as gradient descent. the goal of optimization is to find the set of model parameters that minimizes the cost function.

example

here is an example of using the binary cross-entropy function to train a logistic regression model on the iris dataset using scikit-learn −

from sklearn.datasets import load_iris
from sklearn.linear_model import logisticregression
from sklearn.model_selection import train_test_split

# load the iris dataset
iris = load_iris()

# split the data into training and testing sets
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)

# train a logistic regression model
logreg = logisticregression()
logreg.fit(x_train, y_train)

# make predictions on the testing set
y_pred = logreg.predict(x_test)

# compute the binary cross-entropy loss
loss = binary_cross_entropy(logreg.predict_proba(x_test)[:, 1], y_test)
print('loss:', loss)

in the above example, we first load the iris dataset using the load_iris function from scikit-learn. we then split the data into training and testing sets using the "train_test _split" function. we train a logistic regression model on the training set using thelogisticregressionclass from scikit-learn. we then make predictions on the testing set using the "predict" method of the trained model.

to compute the binary cross-entropy loss, we use the predict_proba method of the logistic regression model to get the predicted probabilities of class 1 for each data point in the testing set. we then extract the probabilities for class 1 using indexing and pass them to our binary_cross_entropy function along with the true labels of the testing set. the function computes the loss and returns it, which we display on the terminal.

output

when you execute this code, it will produce the following output −

loss: 1.6312339784720309

the binary cross-entropy loss is a measure of how well the logistic regression model is able to predict the class of each data point in the testing set. a lower loss indicates better performance, and a loss of 0 would indicate perfect performance.

Save or share this article