ElasticNet: Una técnica intermedia

Al comparar con distintos valores de alpha, al parecer lo que nos indica es que es mejor idea usar Ridge que lasso.

   # elasticnet model
    
    def modelElastic(alpha=1):
        modelElastic= ElasticNet(random_state=0, alpha=alpha)
        modelElastic.fit(X_train, y_train)
        y_predic_elastic=modelElastic.predict(X_test)
        # loss function
        elastic_loss = mean_squared_error(y_test, y_predic_elastic)
        return elastic_loss

    alphas = np.arange(0,1,0.01)
    loss_total = []
    for i in alphas:
        res = modelElastic(i)
        loss_total.append(res)

    loss_total = np.array(loss_total)
    plt.plot(alphas, loss_total)
    plt.xlabel('alphas')
    plt.ylabel('Loss Elastic')
    plt.text(0.02, 0.8, 'loss min:{}'.format(np.min(loss_total)), fontsize=7)
    plt.show()

Me hubiese gustado entender el alcance del modelo desde el punto de vista práctico, es decir, cómo el modelo está prediciendo la enfermedad y basado en qué parámetros, en la vida real. Ejecutar el algoritmo de manera mecánica ayuda a aprender el código y la sintaxis de las librerías, y conceptualmente se entiende que hace el modelo y que tan bueno es, pero no a ver la aplicación práctica. Es decir cuando ingreso algunos datos, que hace el modelo y qué conclusiones sacaría quién lo utilice para la vida práctica

Al agregar este algoritmo de regularización al ejercicio anterior, vemos que tiene da por resultados que los otros dos y que lo que hizo fue lleva todos los coeficientes a cero.

Linear Loss:  9.11362706964361e-08
Lasso Loss:  0.04613142141272012
Ridge Loss:  0.005158990858509752
ElasticNet Loss:  1.1991244060565747
================================

Coef Linear:  [[1.00012822 0.99987164 0.9999141  1.00013558 0.9996458  1.00007078
  0.99987976]]
Coef Lasso:  [1.35269253 0.86910384 0.37857477 0.83535984 0.         0.22914234
 0.90887934]
Coef Ridge:  [[1.08843372 0.95300018 0.84338277 0.90422291 0.64360573 0.76090281
  0.96456701]]
Coef Elastic:  [0. 0. 0. 0. 0. 0. 0.]

A continuación les dejo el código:

import pandas as pd
import sklearn

from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge
from sklearn.linear_model import ElasticNet

from sklearn. model_selection import train_test_split
from sklearn.metrics import mean_squared_error


if __name__ == "__main__":
    dataset = pd.read_csv('./dataset/felicidad.csv')
    # print(dataset.describe())

    X = dataset[['gdp', 'family', 'lifexp', 'freedom',
                 'corruption', 'generosity', 'dystopia']]
    y = dataset[['score']]

    # print(X.shape)
    # print(y.shape)

    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.25, random_state=0)

    modelLinear = LinearRegression().fit(X_train, y_train)
    y_pred_linear = modelLinear.predict(X_test)

    modelLasso = Lasso(alpha=0.02).fit(X_train, y_train)
    y_pred_lasso = modelLasso.predict(X_test)

    modelRidge = Ridge(alpha=1).fit(X_train, y_train)
    y_pred_ridge = modelRidge.predict(X_test)

    modelElasticNet = ElasticNet(random_state=0).fit(X_train, y_train)
    y_pred_elastic = modelElasticNet.predict(X_test)

    linear_loss = mean_squared_error(y_test, y_pred_linear)
    print('Linear Loss: ', linear_loss)

    lasso_loss = mean_squared_error(y_test, y_pred_lasso)
    print('Lasso Loss: ', lasso_loss)

    ridge_loss = mean_squared_error(y_test, y_pred_ridge)
    print('Ridge Loss: ', ridge_loss)

    elastic_loss = mean_squared_error(y_test, y_pred_elastic)
    print('ElasticNet Loss: ', elastic_loss)

    print('='*32, '\n')
    print("Coef Linear: ", modelLinear.coef_)
    print("Coef Lasso: ", modelLasso.coef_)
    print("Coef Ridge: ", modelRidge.coef_)
    print("Coef Elastic: ", modelElasticNet.coef_)```

Probando el modelo ElasticNet obtuve estos scores:

Loss Modelo Lineal: 9.113627069637195e-08
Loss Modelo Lasso: 0.04613142141272011
Loss Modelo Ridge: 0.005158990858509747
Loss Modelo ElasticNet: 1.1991244060565747

Una forma de comparar el error cuadrático medio variando el parámetro alpha para los 4 modelos distintos, puede ser la siguiente:

# Importamos las bibliotecas
import pandas as pd
import numpy as np
import sklearn

# Importamos los modelos de sklearn 
from sklearn.linear_model import LinearRegression, Lasso, Ridge, ElasticNet

# Importamos las metricas de entrenamiento y el error medio cuadrado
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
    
mse_lineal = []
mse_lasso = []
mse_ridge = []
mse_ElasticNet = []

dataset = pd.read_csv('data/felicidad.csv')
X = dataset[['gdp', 'family', 'lifexp', 'freedom' , 'corruption' , 'generosity', 'dystopia']]
y = dataset[['score']]
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.25, random_state=42)

# Lineal
modelLinear = LinearRegression().fit(X_train, y_train)
y_predict_linear = modelLinear.predict(X_test)
alphas = np.linspace(0.01,1,50)

for alpha in alphas:

    modelLasso = Lasso(alpha=alpha).fit(X_train, y_train)
    y_predict_lasso = modelLasso.predict(X_test)

    modelRidge = Ridge(alpha=alpha).fit(X_train, y_train)
    y_predict_ridge = modelRidge.predict(X_test)

    modelElasticNet = ElasticNet(random_state=0, alpha=alpha).fit(X_train, y_train)
    y_predict_ElasticNet = modelElasticNet.predict(X_test)
 
    mse_lineal.append(mean_squared_error(y_test, y_predict_linear))
    mse_lasso.append(mean_squared_error(y_test, y_predict_lasso))
    mse_ridge.append(mean_squared_error(y_test, y_predict_ridge))
    mse_ElasticNet.append(mean_squared_error(y_test, y_predict_ElasticNet))

plt.plot(alphas, mse_lineal)
plt.plot(alphas, mse_lasso)
plt.plot(alphas, mse_ridge)
plt.plot(alphas, mse_ElasticNet)

plt.legend(["Linear", "Lasso", "Ridge", "ElasticNet"])
plt.title('MSE')
plt.xlabel(r'$\alpha$')
plt.ylabel('Accuracy')
plt.axis
plt.show()

Al mio no le gusto ni una columna ajajaj.

Agregen esto: intenta con un alpha bajo.
ElasticNet(random_state=0, alpha = 0.02)

from sklearn.linear_model import ElasticNet

modelElasticNet = ElasticNet(random_state=0, alpha=0.02).fit(X_train, y_train)
y_pred_elastic = modelElasticNet.predict(X_test)

elastic_loss = mean_squared_error(y_test, y_pred_elastic)
print('ElasticNet Loss: ', elastic_loss)
import matplotlib.pyplot as plt
import numpy as np


residuals_l = np.subtract(y_test, y_predict_linear)
residuals_r = np.subtract(y_test, y_predict_ridge)
residuals_ls = np.subtract(y_test, y_predict_lasso.reshape((-1, 1)))
residuals_el = np.subtract(y_test, y_pred_elastic.reshape((-1, 1)))
plt.scatter(y_predict_linear, residuals_l,label='Linear Regression')
plt.scatter(y_predict_ridge, residuals_r,label='Ridge Regression')
plt.scatter(y_predict_lasso, residuals_ls,label='Lasso Regression')
plt.scatter(y_pred_elastic, residuals_el,label='ElasticNet')
plt.legend(frameon=True, fancybox=True, shadow=True, borderpad=1, loc='upper left')


plt.axhline(y=0, color='r', linestyle='--')  # Agregar la línea en el valor cero
plt.show()

Implementación de ElasticNet con Scikit-learn:

• Indica cómo importa la clase ElasticNetdel módulo linear_modelde Scikit-learn.
• Muestra cómo inicializar y entrenar un modelo ElasticNet con ElasticNet()y fit().

Resumiendo en pocas palabras, el texto de la clase nos da una explicación detallada de cómo funciona la regularización, especialmente enfocándose en ElasticNet. También proporciona una idea clara de cuándo y por qué podríamos preferir ElasticNet en comparación con

Resultados de trabajar con ElasticNet

ElasticNet Loss: 0.006499475630064783
Lasso Loss: 0.010312766264690335
Ridge Loss: 0.029278438946391875

Un humilde consejo, intenten probar los accuracy de cada uno.
En el caso de Elastic Net y utilizando el r2_score da un accuracy negativo. Esto se puede solucionar dandole un valor de aplha muy pequeño, con lo cual logramos que se aproxime a los que conseguimos Linear Regression que tuvo el mejor accuracy y menos perdida.
Ejemplo de calculo de precision:

y_predict_elastic_net = model_elastic_net.predict(X_test)
elastic_net_loss = mean_squared_error(y_test, y_predict_elastic_net)
elastic_net_accuracy = r2_score(y_test, y_predict_elastic_net)
print(f'Elastic Net loss: {elastic_net_loss}, accuracy: {(elastic_net_accuracy*100).round(4)}% and coef: {model_elastic_net.coef_}')

En este caso, las variables fueron escogidas a mano por lo que tiene sentido que estén altamente correlacionadas con la resolución del problema y por lo tanto una solución Ridge o una ElasticNet con un coeficiente cercano a 0 den buenos resultados. Sin embargo, en este caso en particular no parece haber overfitting de la predicción usando simplemente una regresión lineal ya que es la que obtuvo el mejor resultados de MSE

Siempre que tengan dudas, investigar directamente en la fuente, que sería https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html.

Resulta que lo que la información de esta clase está totalmente equivocada (Lo cual considero bastante mediocre e irresponsable de parte de una plataforma educativa). Uno puede ir variando de Lasso a Ridge cambiando el parámetro l1_ratio (donde l1_ratio=1 se refiere a un modelo full Lasso y l1_ratio=0 es un modelo full Ridge. Ojo que en la documentación dice que usar l1_ratio<0.01 no es confiable) .

Si están interesados en controlar especificamente la proporción de L1 y L2, se hace con las siguientes expresiones:

La pérdida es mucho mayor y el score me da negativo, a alguien más le ocurrió?