Implementación de Regularización en Modelos de Regresión Lineal

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

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

Mejor rendimiento: LinearRegression
Peor rendimiento: Lasso

14. Implementación de Lasso y Ridge

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.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

if __name__ == '__main__':
    # Load the dataset
    df = pd.read_csv('./data/felicidad.csv')
    print(df.describe())

    # Split the dataset into features (X) and target (y)
    X = df[['gdp', 'family', 'lifexp', 'freedom', 'corruption', 'generosity', 'dystopia']]
    y = df[['score']]

    # Print the shapes of X and y
    print(X.shape)
    print(y.shape)

    # Split the dataset into training and testing sets
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

    # Fit a linear regression model to the training data
    modelLinear = LinearRegression().fit(X_train, y_train)
    y_predict_linear = modelLinear.predict(X_test)

    # Fit a LASSO regression model to the training data
    modelLasso = Lasso(alpha=0.02).fit(X_train, y_train)
    y_predict_lasso = modelLasso.predict(X_test)

    # Fit a Ridge regression model to the training data
    modelRidge = Ridge(alpha=1).fit(X_train, y_train)
    y_predict_ridge = modelRidge.predict(X_test)

    # Calculate the mean squared error for each model
    linear_loss = mean_squared_error(y_test, y_predict_linear)
    print('Linear Loss: ', linear_loss)

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

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

    # Print the coefficients for the LASSO and Ridge models
    print('=' * 32)
    print('Coef LASSO')
    print(modelLasso.coef_)

    print('=' * 32)
    print('Coef RIDGE')
    print(modelRidge.coef_)

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

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Lasso, Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error

# Carga del conjunto de datos
data = pd.read_csv('felicidad.csv')

# Codificación one-hot para la columna 'country'
data = pd.get_dummies(data, columns=['country'], drop_first=True)

# Separación de características y etiquetas
X = data.drop(columns=['score'])
y = data['score']

# División en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Estandarización de características
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Aplicación de Lasso (L1)
lasso_model = Lasso(alpha=0.1)
lasso_model.fit(X_train_scaled, y_train)
y_pred_lasso = lasso_model.predict(X_test_scaled)
lasso_mse = mean_squared_error(y_test, y_pred_lasso)

# Aplicación de Ridge (L2)
ridge_model = Ridge(alpha=0.1)
ridge_model.fit(X_train_scaled, y_train)
y_pred_ridge = ridge_model.predict(X_test_scaled)
ridge_mse = mean_squared_error(y_test, y_pred_ridge)

print(f'MSE Lasso: {lasso_mse}')
print(f'MSE Ridge: {ridge_mse}')

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.

version mas sencilla de seleccionar mismos features:

X = dt_felicidad.iloc[:,5:]

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