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()

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

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

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_}')

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:

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.

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