regularization in machine learning

in machine learning, regularization is a technique used to prevent overfitting, which occurs when a model is too complex and fits the training data too well, but fails to generalize to new, unseen data. regularization introduces a penalty term to the cost function, which encourages the model to have smaller weights and a simpler structure, thereby reducing overfitting.

there are several types of regularization techniques commonly used in machine learning, including l1 and l2 regularization, dropout regularization, and early stopping. in this article, we will focus on l1 and l2 regularization, which are the most commonly used techniques.

l1 regularization

l1 regularization, also known as lasso regularization, is a technique that adds a penalty term to the cost function, equal to the absolute value of the sum of the weights. the formula for the l1 regularization penalty is −

$$\lambda \times \sigma \left|w_{i} \right|$$

where is a hyperparameter that controls the strength of the regularization, and is the i-th weight in the model.

the effect of the l1 regularization penalty is to encourage the model to have sparse weights, that is, to eliminate the weights that have little or no impact on the output. this has the effect of simplifying the model and reducing overfitting.

example

to implement l1 regularization in python, we can use the lasso class from the scikit-learn library. here is an example of how to use l1 regularization for linear regression −

from sklearn.linear_model import lasso
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# load the boston housing dataset
boston = load_boston()

# split the data into training and test sets
x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2, random_state=42)

# create a lasso model with l1 regularization
lasso = lasso(alpha=0.1)

# train the model on the training data
lasso.fit(x_train, y_train)

# make predictions on the test data
y_pred = lasso.predict(x_test)

# calculate the mean squared error of the predictions
mse = mean_squared_error(y_test, y_pred)
print("mean squared error:", mse)

in this example, we load the boston housing dataset, split it into training and test sets, and create a lasso model with l1 regularization using an alpha value of 0.1. we then train the model on the training data and make predictions on the test data. finally, we calculate the mean squared error of the predictions.

output

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

mean squared error: 25.155593753934173

l2 regularization

l2 regularization, also known as ridge regularization, is a technique that adds a penalty term to the cost function, equal to the square of the sum of the weights. the formula for the l2 regularization penalty is −

$$\lambda \times \sigma\left (w_{i} \right )^{2}$$

where is a hyperparameter that controls the strength of the regularization, and wi is the ith weight in the model.

the effect of the l2 regularization penalty is to encourage the model to have small weights, that is, to reduce the magnitude of all the weights in the model. this has the effect of smoothing the model and reducing overfitting.

example

to implement l2 regularization in python, we can use the ridge class from the scikit-learn library. here is an example of how to use l2 regularization for linear regression −

from sklearn.linear_model import ridge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.datasets import load_boston
from sklearn.preprocessing import standardscaler
import numpy as np

# load the boston housing dataset
boston = load_boston()

# create feature and target arrays
x = boston.data
y = boston.target

# standardize the feature data
scaler = standardscaler()
x = scaler.fit_transform(x)

# split the data into training and testing sets
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

# define the ridge regression model with l2 regularization
model = ridge(alpha=0.1)

# fit the model on the training data
model.fit(x_train, y_train)

# make predictions on the testing data
y_pred = model.predict(x_test)

# calculate the mean squared error
mse = mean_squared_error(y_test, y_pred)
print("mean squared error: ", mse)

in this example, we first load the boston housing dataset and split it into training and testing sets. we then standardize the feature data using a standardscaler.

next, we define the ridge regression model and set the alpha parameter to 0.1, which controls the strength of the l2 regularization.

we fit the model on the training data and make predictions on the testing data. finally, we calculate the mean squared error to evaluate the performance of the model.

output

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

mean squared error: 24.29346250596107

Save or share this article