Implementación de Lasso y Ridge

Nota: el dataset de “whr2017” lo encontramos en los archivos del curso como “felicidad”

# Importamos las bibliotecas
import pandas as pd
import sklearn

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

# 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

if __name__ == "__main__":
    
    # Importamos el dataset del 2017 
    dataset = pd.read_csv('./data/whr2017.csv')
    # Mostramos el reporte estadistico
    print(dataset.describe())

    # Vamos a elegir los features que vamos a usar
    X = dataset[['gdp', 'family', 'lifexp', 'freedom' , 'corruption' , 'generosity', 'dystopia']]
    # Definimos nuestro objetivo, que sera nuestro data set, pero solo en la columna score 
    y = dataset[['score']]

    # Imprimimos los conjutos que creamos 
    # En nuestros features tendremos definidos 155 registros, uno por cada pais, 7 colunas 1 por cada pais 
    print(X.shape)
    # Y 155 para nuestra columna para nuestro target 
    print(y.shape)

    # Aquí vamos a partir nuestro entrenaminto en training y test, no hay olvidar el orden
    # Con el test size elejimos nuestro porcetaje de datos para training 
    X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.25)

    # Aquí definimos nuestros regresores uno por 1 y llamamos el fit o ajuste 
    modelLinear = LinearRegression().fit(X_train, y_train)
    # Vamos calcular la prediccion que nos bota con la funcion predict con la regresion lineal 
    # y le vamos a mandar el test 
    y_predict_linear = modelLinear.predict(X_test)

    # Configuramos alpha, que es valor labda y entre mas valor tenga alpha en lasso mas penalizacion 
    # vamos a tener y lo entrenamos con la función fit 
    modelLasso = Lasso(alpha=0.2).fit(X_train, y_train)
    # Hacemos una prediccion para ver si es mejor o peor de lo que teniamos en el modelo lineal sobre
    # exactamente los mismos datos que teníamos anteriormente 
    y_predict_lasso = modelLasso.predict(X_test)

    # Hacemos la misma predicción, pero para nuestra regresion ridge 
    modelRidge = Ridge(alpha=1).fit(X_train, y_train)
    # Calculamos el valor predicho para nuestra regresión ridge 
    y_predict_ridge = modelRidge.predict(X_test)

    # Calculamos la perdida para cada uno de los modelos que entrenamos, empezaremos con nuestro modelo 
    # lineal, con el error medio cuadratico y lo vamos a aplicar con los datos de prueba con la prediccion 
    # que hicimos 
    linear_loss = mean_squared_error(y_test, y_predict_linear)
    # Mostramos la perdida lineal con la variable que acabamos de calcular
    print("Linear loss: ", linear_loss) 
    
    # Mostramos nuestra perdida Lasso, con la variable lasso loss 
    lasso_loss = mean_squared_error(y_test, y_predict_lasso)
    print("Lasso Loss. ", lasso_loss) 

    # Mostramos nuestra perdida de Ridge con la variable lasso loss 
    ridge_loss = mean_squared_error(y_test, y_predict_ridge)
    print("Ridge loss: ", ridge_loss)

    # Imprimimos las coficientes para ver como afecta a cada una de las regresiones 
    # La lines "="*32 lo unico que hara es repetirme si simbolo de igual 32 veces 
    print("="*32)
    print("Coeficientes lasso: ")
    # Esta informacion la podemos encontrar en la variable coef_ 
    print(modelLasso.coef_)

    # Hacemos lo mismo con ridge 
    print("="*32)
    print("Coeficientes ridge:")
    print(modelRidge.coef_) 

Hola, una duda, porque aquí no normalizamos la información de los features, no me queda claro cuando si y cuado no escalar datos.
Gracias y saludos!

"For machine learning, every dataset does not require normalization. It is required only when features have different ranges"
Urvashi Jaitley

y si quisiera separar mis datos en train validation y test para aplicar mejores practicas cual seria la funcion?

version mas sencilla de seleccionar mismos features:

X = dt_felicidad.iloc[:,5:]

Comportamiento de los tres modelos diseñados, vs nuestro Y de prueba

Mejor rendimiento: LinearRegression
Peor rendimiento: Lasso

No se explica el método de regularización ElasticNet. Porque?
Es correcto que se amplíe la teoriía y ejemplos con este otro método y de esta menra saber cuando usar cada uno.

El alpha es el lambda que vieron en la formula.

Comparto un código ligeramente diferente, pero que puede motivar a varias personas a comparar varios algoritmos de clasificación al mismo tiempo.

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error as mse

# Esta función nos permite entrenar y evaluar a un modelo de forma simple
def fit_predict_score(model, x_train, y_train, x_test, y_test, metric) -> float:
    model.fit(x_train, y_train)
    y_predict = model.predict(x_test)
    score = metric(y_test, y_predict)
    return score


def main():
    dataset = pd.read_csv("../datasets/happines.csv")
    print(dataset.describe())
    # Vamos a elegir los features que vamos a usar
    X = dataset[['gdp', 'family', 'lifexp', 'freedom',
                 'corruption', 'generosity', 'dystopia']]
    # Definimos nuestro objetivo, que sera nuestro data set, pero solo en la columna score
    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)
    # Todos los modelos que vayamos a comparar los ponemos dentro de un diccionario donde asociamos el nombre del modelo a la instancia del mismo.
    models = {"Linear Regression": LinearRegression(),
              "Lasso": Lasso(alpha=0.2),
              "Ridge": Ridge(alpha=1)}

    for name, model in models.items():
        score = fit_predict_score(model, X_train, y_train, X_test, y_test, mse)
        print(f"{name} loss: {score}")
    print("="*32)
    for name, model in models.items():
        print(f"Coef {name}: {model.coef_}")


if __name__ == '__main__':
    main()

Les recuerdo que el comando de Ubuntu (Linux en general) para activar el entorno es

source entorno/bin/activate

Y para desactivarlo:

deactivate

alguien sabe por que me da erro
yo se q es por que Y es de dif tipo que X