bias and variance are two important concepts in machine learning that describe the sources of error in a model's predictions. bias refers to the error that results from oversimplifying the underlying relationship between the input features and the output variable. at the same time, variance refers to the error that results from being too sensitive to fluctuations in the training data.

in machine learning, we strive to minimize both bias and variance in order to build a model that can accurately predict on unseen data. a high-bias model may be too simplistic and underfit the training data. in contrast, a model with high variance may overfit the training data and fail to generalize to new data.

generally, a machine learning model shows three types of error - bias, variance, and irreducible error. there is a tradeoff between bias and variance errors. decreasing the bias leads to increasing the variance and vice versa.

what is bias?

bias is calculated as the difference between average prediction and actual value. in machine learning, bias (systematic error) occurs when a model makes incorrect assumptions about data.

a model with high bias does not match well training data as well as test data. it leads to high errors in training and test data.

while the model with low bias matches the training data well (high training accuracy or less error in training). it leads to low error in training data but high error in test data.

types of bias

high bias − high bias occurs due to erroneous assumptions in the machine learning model. models with high bias cannot capture the hidden pattern in the training data. this leads to underfitting.his leads to underfitting. features of high bias are a highly simplified model, underfitting, and high error in training and test data.
low bias − models with low bias can capture the hidden pattern in the training data. low bias leads to high variance and, eventually, overfitting. low bias generally occurs due to the ml model being overly complex.

below figure shows pictorial representation of the high and low bias error.

example of bias in models

a linear regression model trying to fit the non-linear data will show a high bias. some examples of models with high bias are linear regression and logistic regression. some examples of models with low bias are decision trees, k-nearest neighbors, and support vector machines.

impact of bias on model performance

high bias can lead to poor performance on both training and test datasets. high-bias models will not be able to generalize on the new, unseen data.

what is variance?

variance is a measure of the spread or dispersion of numbers in a given set of observations with respect to the mean. it basically measures how a set of numbers is spread out from the average. in statistics and probability, variance is defined as the expectation of the squared deviation of a random variable from the sample mean.

in machine learning, variance is the variability of model prediction on different datasets. the variance shows how much model prediction varies when there is a slight variation in data. if model accuracies on training and test data vary greatly, the model has high variance.

a model with high variance can even fit noises on training data but lacks generalization to new, unseen data.

types of variance

high variance − high variance models capture noise along with hidden pattern. it leads to overfitting. high variance models show high training accuracy but low test accuracy. some features of a high variance model are an overly complex model, overfitting, low error on training data, and high error or test data.
low variance − a model with low variance is unable to capture the hidden pattern in the data. low variance may occur when we have a very small amount of data or use a very simplified model. low variance leads to underfitting.

below figure shows pictorial representation of the high and low variance examples.

example of variance in models

a decision tree with many branches that fits the training data perfectly but does not fit properly on test data is an example of high variance. examples of high variance: k-nearest neighbors, decision trees, and support vector machines (svms).

impact of variance on model performance

a high variance can lead to a model that performs well with training data but fails to perform well on training data. during training, high-variance models fit the training data so well that they even capture the noises as actual patterns. models with high variance errors are known as overfitting models.

bias-variance tradeoff

the bias-variance tradeoff is finding a balance between the error introduced by bias and the error introduced by variance. with increased model complexity, the bias will decrease, but the variance will increase. however, when we decrease the model complexity, the bias will increase, and the variance will decrease. so we need a balance between bias and variance so total prediction error is minimized.

a machine learning model will not perform well on new, unseen data if it has a high bias or variance in training. a good model should not have either high bias or variance. we can't reduce both bias and variance at the same time. when bias reduces, variance will increase. so we need to find an optimal bias and variance such that the prediction error is minimized.

in machine learning, bias-variance tradeoff is important because a model with high bias or high.

graphical representation

the following graph represents the tradeoff between bias and variance graphically.

in the above graph, the x-axis represents the model complexity, and the y-axis represents the prediction error. the total error is the sum of bias error and variance error. the optimal region shows the area with the balance between bias and variance, showing optimal model complexity with minimum error.

mathematical representation

the prediction error in the machine learning model can be written mathematically as follows −

error = bias² + variance + irreducible error.

to minimize the model prediction error, we need to choose model complexity in such a way so that a balance between these two errors can be met.

the main objective of the bias-variance tradeoff is to find optimal values of bias and variance (model complexity) that minimize the error.

techniques to balance bias and variance

there are different techniques to balance bias and variance to achieve an optimal prediction error.

1. reducing high bias

choosing a more complex model − as we have seen in the above diagram, choosing a more complex model may reduce the bias error of the model prediction.
adding more features − adding mode features can increase the complexity of the model that can capture even better hidden patterns that will decrease the bias error of the model.
reducing regularization − regularization prevents overfitting, but while decreasing the variance, it can increase bias. so, reducing the regularization parameters or removing regularization overall can reduce bias errors.

2. reducing high variance

applying regularization techniques − regularization techniques add penalty to complex model that will eventually result in reduced complexity of the model. a less complex model will show less variance.
simplifying model complexity − a less complex model will have low variance. you can reduce the variance by using a simpler algorithm.
adding more data − adding more data to the dataset can help the model to perform better showing less variance.
cross-validation − cross-validation can be useful to identify overfitting by comparing the performance on training and validation sets of the datasets.

bias and variance examples using python

let's implement some practical examples using python programming language. we have provided here four examples. the first three examples show some level of high/ low bias or variance. the fourth example shows the optimal value of both bias and variance.

example of high bias

below is an implementation example in python that illustrates how bias and variance can be analyzed using the boston housing dataset −

import numpy as np
import pandas as pd
from sklearn.datasets import load_boston

boston = load_boston()
x = boston.data
y = boston.target
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2,
random_state=42)
from sklearn.linear_model import linearregression
from sklearn.metrics import mean_squared_error

lr = linearregression()
lr.fit(x_train, y_train)

train_preds = lr.predict(x_train)
train_mse = mean_squared_error(y_train, train_preds)
print("training mse:", train_mse)

test_preds = lr.predict(x_test)
test_mse = mean_squared_error(y_test, test_preds)
print("testing mse:", test_mse)

output

the output shows the training and testing mean squared errors (mse) of the linear regression model. the training mse is 21.64 and the testing mse is 24.29, indicating that the model has a high level of bias and moderate variance.

training mse: 21.641412753226312
testing mse: 24.291119474973456

example of low bias and high variance

let's try a polynomial regression model −

from sklearn.preprocessing import polynomialfeatures

poly = polynomialfeatures(degree=2)
x_train_poly = poly.fit_transform(x_train)
x_test_poly = poly.transform(x_test)

pr = linearregression()
pr.fit(x_train_poly, y_train)

train_preds = pr.predict(x_train_poly)
train_mse = mean_squared_error(y_train, train_preds)
print("training mse:", train_mse)

test_preds = pr.predict(x_test_poly)
test_mse = mean_squared_error(y_test, test_preds)
print("testing mse:", test_mse)

output

the output shows the training and testing mse of the polynomial regression model with degree=2. the training mse is 5.31 and the testing mse is 14.18, indicating that the model has a lower bias but higher variance compared to the linear regression model.

training mse: 5.31446956670908
testing mse: 14.183558207567042

example of low variance

to reduce variance, we can use regularization techniques such as ridge regression or lasso regression. in the following example, we will be using ridge regression −

from sklearn.linear_model import ridge

ridge = ridge(alpha=1)
ridge.fit(x_train_poly, y_train)

train_preds = ridge.predict(x_train_poly)
train_mse = mean_squared_error(y_train, train_preds)
print("training mse:", train_mse)

test_preds = ridge.predict(x_test_poly)
test_mse = mean_squared_error(y_test, test_preds)
print("testing mse:", test_mse)

output

the output shows the training and testing mse of the ridge regression model with alpha=1. the training mse is 9.03 and the testing mse is 13.88 compared to the polynomial regression model, indicating that the model has a lower variance but slightly higher bias.

training mse: 9.03220937860839
testing mse: 13.882093755326755

example of optimal bias and variance

we can further tune the hyperparameter alpha to find the optimal balance between bias and variance. let's see an example −

from sklearn.model_selection import gridsearchcv

param_grid = {'alpha': np.logspace(-3, 3, 7)}
ridge_cv = gridsearchcv(ridge(), param_grid, cv=5)
ridge_cv.fit(x_train_poly, y_train)

train_preds = ridge_cv.predict(x_train_poly)
train_mse = mean_squared_error(y_train, train_preds)
print("training mse:", train_mse)

test_preds = ridge_cv.predict(x_test_poly)
test_mse = mean_squared_error(y_test, test_preds)
print("testing mse:", test_mse)

output

the output shows the training and testing mse of the ridge regression model with the optimal alpha value.

training mse: 8.326082686584716
testing mse: 12.873907256619141

the training mse is 8.32 and the testing mse is 12.87, indicating that the model has a good balance between bias and variance.

Save or share this article