Implementación de Lasso, Ridge y Elastic Net

En este artículo, veremos la implementación de diferentes técnicas de regularización. Primero, comenzaremos con una regresión lineal múltiple. Para eso, requerimos el entorno python3 con sci-kit learn y pandas preinstalados. También podemos usar Google Collaboratory o cualquier otro entorno de notebook jupyter.
Primero, necesitamos importar algunos paquetes a nuestro entorno.

Python3

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

Vamos a utilizar el conjunto de datos de predicción de casas de Boston. Este conjunto de datos está presente en el módulo de conjuntos de datos de la biblioteca sklearn (scikit-learn). Podemos importar este conjunto de datos de la siguiente manera.

Python3

# Loading pre-defined Boston Dataset
boston_dataset = datasets.load_boston()
print(boston_dataset.DESCR)

Producción:

Boston dataset description

Podemos concluir de la descripción anterior que tenemos 13 variables independientes y una variable dependiente (precio de la vivienda). Ahora necesitamos comprobar si hay una correlación entre la variable independiente y la dependiente. Podemos usar scatterplot/corrplot para esto.

Python3

# Generate scatter plot of independent vs Dependent variable
plt.style.use('ggplot')
fig = plt.figure(figsize = (18, 18))
 
for index, feature_name in enumerate(boston_dataset.feature_names):
    ax = fig.add_subplot(4, 4, index + 1)
    ax.scatter(boston_dataset.data[:, index], boston_dataset.target)
    ax.set_ylabel('House Price', size = 12)
    ax.set_xlabel(feature_name, size = 12)
 
plt.show()

El código anterior produce diagramas de dispersión de diferentes variables independientes con la variable objetivo como se muestra a continuación

scatter plots

Podemos observar a partir de los diagramas de dispersión anteriores que algunas de las variables independientes no están muy correlacionadas (ya sea positiva o negativamente) con la variable objetivo. Estas variables conseguirán que sus coeficientes se reduzcan en la regularización.
Código: código de Python para preprocesar los datos.

Python3

# Load the dataset into Pandas Dataframe
boston_pd = pd.DataFrame(boston_dataset.data)
boston_pd.columns = boston_dataset.feature_names
boston_pd_target = np.asarray(boston_dataset.target)
boston_pd['House Price'] = pd.Series(boston_pd_target)
 
# input
X = boston_pd.iloc[:, :-1]
 
#output
Y = boston_pd.iloc[:, -1]
 
print(boston_pd.head())

Ahora, aplicamos la división de prueba de tren para dividir el conjunto de datos en dos partes, una para entrenamiento y otra para prueba. Usaremos el 25% de los datos para las pruebas.

Python3

x_train, x_test, y_train, y_test = train_test_split(
    boston_pd.iloc[:, :-1], boston_pd.iloc[:, -1],
    test_size = 0.25)
 
print("Train data shape of X = % s and Y = % s : "%(
    x_train.shape, y_train.shape))
 
print("Test data shape of X = % s and Y = % s : "%(
    x_test.shape, y_test.shape))

Regresión múltiple (lineal)
Ahora es el momento adecuado para probar los modelos. Usaremos primero la regresión lineal múltiple. Entrenamos el modelo con datos de entrenamiento y calculamos el MSE en la prueba.

Python3

# Apply multiple Linear Regression Model
lreg = LinearRegression()
lreg.fit(x_train, y_train)
 
# Generate Prediction on test set
lreg_y_pred = lreg.predict(x_test)
 
# calculating Mean Squared Error (mse)
mean_squared_error = np.mean((lreg_y_pred - y_test)**2)
print("Mean squared Error on test set : ", mean_squared_error)
 
# Putting together the coefficient and their corresponding variable names
lreg_coefficient = pd.DataFrame()
lreg_coefficient["Columns"] = x_train.columns
lreg_coefficient['Coefficient Estimate'] = pd.Series(lreg.coef_)
print(lreg_coefficient)

Producción:

Tracemos un gráfico de barras de los coeficientes anteriores usando la biblioteca de trazado matplotlib.

Python3

# plotting the coefficient score
fig, ax = plt.subplots(figsize =(20, 10))
 
color =['tab:gray', 'tab:blue', 'tab:orange',
'tab:green', 'tab:red', 'tab:purple', 'tab:brown',
'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan',
'tab:orange', 'tab:green', 'tab:blue', 'tab:olive']
 
ax.bar(lreg_coefficient["Columns"],
lreg_coefficient['Coefficient Estimate'],
color = color)
 
ax.spines['bottom'].set_position('zero')
 
plt.style.use('ggplot')
plt.show()

Producción:

Como podemos observar que muchas de las variables tienen un coeficiente insignificante, estos coeficientes no contribuyeron mucho al modelo y es necesario regular o incluso eliminar algunas de estas variables.

Ridge Regression:
Ridge Regression agregó un término en la función de error de mínimos cuadrados ordinarios que regulariza el valor de los coeficientes de las variables. Este término es la suma de los cuadrados del coeficiente multiplicado por el parámetro. El motivo de agregar este término es penalizar la variable correspondiente a ese coeficiente poco correlacionada con la variable objetivo. Este término se denomina regularización L _{2 .}
Código: código de Python para usar la regresión de Ridge

Python3

# import ridge regression from sklearn library
from sklearn.linear_model import Ridge
 
# Train the model
ridgeR = Ridge(alpha = 1)
ridgeR.fit(x_train, y_train)
y_pred = ridgeR.predict(x_test)
 
# calculate mean square error
mean_squared_error_ridge = np.mean((y_pred - y_test)**2)
print(mean_squared_error_ridge)
 
# get ridge coefficient and print them
ridge_coefficient = pd.DataFrame()
ridge_coefficient["Columns"]= x_train.columns
ridge_coefficient['Coefficient Estimate'] = pd.Series(ridgeR.coef_)
print(ridge_coefficient)

Salida: el valor del error MSE y el marco de datos con coeficientes de cresta.

RidgRegcoefficient

El gráfico de barras de los datos anteriores es:

Regresión de cresta en $\alfa$ = 1

En el gráfico anterior tomamos $\alfa$ = 1.
Veamos otro gráfico de barras con $\alfa$ = 10

Regresión de cresta en $\alfa$ = 10

Como podemos observar en los gráficos anteriores, eso $\alfa$ ayuda a regularizar el coeficiente y hacer que converjan más rápido.
Tenga en cuenta que los gráficos anteriores pueden ser engañosos en el sentido de que muestran que algunos de los coeficientes se vuelven cero. En Ridge Regularization, los coeficientes nunca pueden ser 0, son demasiado pequeños para observarlos en los gráficos anteriores.

Regresión de lazo: La regresión
de lazo es similar a la regresión de Ridge, excepto que aquí agregamos el valor absoluto medio de los coeficientes en lugar del valor cuadrático medio. A diferencia de la regresión de Ridge, la regresión de Lasso puede eliminar completamente la variable al reducir el valor de su coeficiente a 0. El nuevo término que agregamos a Mínimos cuadrados ordinarios (OLS) se llama Regularización L _{1 .}
Código: código de Python que implementa la regresión de Lasso

Python3

# import Lasso regression from sklearn library
from sklearn.linear_model import Lasso
 
# Train the model
lasso = Lasso(alpha = 1)
lasso.fit(x_train, y_train)
y_pred1 = lasso.predict(x_test)
 
# Calculate Mean Squared Error
mean_squared_error = np.mean((y_pred1 - y_test)**2)
print("Mean squared error on test set", mean_squared_error)
lasso_coeff = pd.DataFrame()
lasso_coeff["Columns"] = x_train.columns
lasso_coeff['Coefficient Estimate'] = pd.Series(lasso.coef_)
 
print(lasso_coeff)

Salida: el valor del error de MSE y el marco de datos con coeficientes de Lasso.

Regresión de lazo con $\alfa$ = 1

El gráfico de barras de los coeficientes anteriores:

Regresión de lazo con $\alfa$ =1

La regresión de Lasso dio el mismo resultado que dio la regresión de cresta, cuando aumentamos el valor de $\alfa$ . Veamos otro gráfico en $\alfa$ = 10.

Red elástica:
en Regularización neta elástica, agregamos los dos términos de L ₁ y L ₂ para obtener la función de pérdida final. Esto nos lleva a reducir la siguiente función de pérdida:
$L_{elastic-Net}\left ( \hat\beta \right )= \left ( \sum \left ( y - x_i^J\hat{\beta} \right )^2 \right )/2n+\lambda \left ( (1 -\alpha )/2 * \sum_{j=1}^{m} \hat{\beta_{j}^{2}}+\alpha * \sum_{j=1}^{m} \left \| \hat{\beta_{j}} \right \| \right)$
donde $\alpha$ está entre 0 y 1. cuando $\alpha$ = 1, reduce el término de penalización a L ₁ penalización y si $\alpha$ = 0, reduce ese término a L ₂
penalización.
Código: código de Python que implementa Elastic Net

Python3

# import model
from sklearn.linear_model import ElasticNet
 
# Train the model
e_net = ElasticNet(alpha = 1)
e_net.fit(x_train, y_train)
 
# calculate the prediction and mean square error
y_pred_elastic = e_net.predict(x_test)
mean_squared_error = np.mean((y_pred_elastic - y_test)**2)
print("Mean Squared Error on test set", mean_squared_error)
 
e_net_coeff = pd.DataFrame()
e_net_coeff["Columns"] = x_train.columns
e_net_coeff['Coefficient Estimate'] = pd.Series(e_net.coef_)
e_net_coeff

Producción:

Red_elástica

Gráfico de barras de los coeficientes anteriores:

Elastic Net Plot

Conclusión:
del análisis anterior podemos llegar a la siguiente conclusión sobre los diferentes métodos de regularización:

La regularización se usa para reducir la dependencia de cualquier variable independiente en particular agregando el término de penalización a la función de pérdida. Este término evita que los coeficientes de las variables independientes tomen valores extremos.
Ridge Regression agrega el término de penalización de regularización L ₂ a la función de pérdida. Este término reduce los coeficientes pero no los convierte en 0 y, por lo tanto, no elimina por completo ninguna variable independiente. Se puede utilizar para medir el impacto de las diferentes variables independientes.
Lasso Regression agrega L ₁ término de penalización de regularización a la función de pérdida. Este término reduce los coeficientes y los convierte en 0, por lo que elimina completamente la variable independiente correspondiente. Se puede utilizar para la selección de funciones, etc.
Elastic Net es una combinación de las dos regularizaciones anteriores. Contiene tanto la L ₁ como la L ₂ como su término de sanción. Funciona mejor que Ridge and Lasso Regression para la mayoría de los casos de prueba.

Publicación traducida automáticamente

Artículo escrito por pawangfg y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Python3

Python3

Python3

Python3

Python3

Python3

Python3

Python3

Python3

Python3

Deja una respuesta Cancelar la respuesta