Nota: el dataset de “whr2017” lo encontramos en los archivos del curso como “felicidad”
Aprender los conceptos clave
Curso Completo de Machine Learning con Scikit-learn para Principiantes
Tipos de Aprendizaje en Machine Learning: Supervisado, No Supervisado y por Refuerzo
Problemas de Clasificación, Regresión y Clustering con Scikit-learn
Fundamentos Matemáticos para Machine Learning Avanzado
Iniciar un proyecto con sklearn
Configuración Profesional de Entorno de Trabajo para Python
Instalación y configuración de librerías para Python
Análisis de Datos para el Bienestar y la Felicidad Humana
Optimización de features
Selección de Variables en Modelos de Aprendizaje Automático
Reducción de Dimensionalidad con Análisis de Componentes Principales
Reducción de Dimensionalidad y Regresión Logística con Python
Clasificación de Enfermedad Cardiaca con PCA y Regresión Logística
Funciones Kernel en la Clasificación de Datos Complejos
Regularización en Modelos de Machine Learning
Implementación de Regularización en Modelos de Regresión Lineal
Análisis de Resultados en Modelos de Regresión Ridge y Lasso
Regularización ElasticNet con Scikit-learn: Conceptos y Aplicación
Regresiones robustas
Identificación de Valores Atípicos en Datos para Modelos Predictivos
Técnicas de Regresión Robusta: RANSAC y Huber en Scikit-Learn
Regresión Lineal y Soporte Vectorial: Manejo de Datos Atípicos
Automatización de Modelos de Predicción en Python
Métodos de ensamble aplicados a clasificación
Métodos de Ensamble: Bagging y Boosting en Machine Learning
Implementación de Bagging Classifier con SAIC en Análisis Cardiaco
Métodos de Ensamble para Mejorar Clasificación en Machine Learning
Implementación de Gradient Boosting para Clasificación de Datos
Clustering
Agrupamiento de Datos en Aprendizaje No Supervisado
Agrupamiento de Caramelos con K-Means y Pandas
Agrupamiento de Datos con Algoritmo Mean Shift
Optimización paramétrica
Validación Cruzada en Modelos de Machine Learning
Validación Cruzada con Scikit-learn: Cruz Vales Cor y KFold
Optimización de Modelos con Búsqueda en Grilla y Aleatoria
Automatización de Parámetros en Modelos de Regresión con Random Forest
Optimización Automática de Modelos con Auto-sklearn
Salida a producción
Estructuración Modular de Código Python para Machine Learning
Automatización de Modelos Machine Learning con Python
Publicación de Modelos de IA con Flask y Python
Optimización de Modelos de Machine Learning para Producción
Recursos para Aprender Machine Learning y Data Science
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
El uso de técnicas de regularización es esencial en la construcción de modelos predictivos sólidos en machine learning. En esta clase, nos enfocamos en implementar dichas técnicas utilizando regresores lineales que ya están integrados en scikit-learn, un módulo muy potente en Python para aprender máquinas. En particular, se trabaja con un conjunto de datos del Reporte de la Felicidad Mundial 2017, que incluye variables de diferentes países como el índice de corrupción y la expectativa de vida.
Antes de comenzar con cualquier modelo, es crucial tener un entorno de desarrollo bien configurado. Aquí se utilizan librerías esenciales como pandas para la gestión de datos, y scikit-learn para los modelos predictivos. A través de pandas, se cargan los datos en un DataFrame, que permite manipular y explorar la información de manera efectiva mediante funciones como describe()
, que ofrece descripciones estadísticas de las columnas.
import pandas as pd
import sklearn
from sklearn.linear_model import LinearRegression, Lasso, Ridge
...
data = pd.read_csv('data/world_happiness_report_2017.csv')
print(data.describe())
Dividir los datos en conjuntos de entrenamiento y prueba es fundamental para evaluar la eficacia de un modelo. Esta separación te permite no solo ajustar el modelo, sino también validarlo con datos que no ha visto anteriormente.
from sklearn.model_selection import train_test_split
# Definición de características (features) y la variable objetivo (target)
X = data[['gdp_per_capita', 'family', 'lifespan', 'freedom', 'corruption', 'generosity', 'dystopia']].values
y = data['happiness_score'].values
# Dividiendo los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
Scikit-learn ofrece varios modelos de regresión lineal, entre los que destacan el modelo lineal básico, Lasso y Ridge. Cada uno tiene sus particularidades en relación con cómo manejan la regularización.
# Modelo de regresión lineal
linear_model = LinearRegression()
linear_model.fit(X_train, y_train)
y_pred_linear = linear_model.predict(X_test)
# Modelo de regresión Lasso
lasso_model = Lasso(alpha=1.0)
lasso_model.fit(X_train, y_train)
y_pred_lasso = lasso_model.predict(X_test)
# Modelo de regresión Ridge
ridge_model = Ridge(alpha=1.0)
ridge_model.fit(X_train, y_train)
y_pred_ridge = ridge_model.predict(X_test)
La evaluación de los modelos se hace mediante el cálculo del error cuadrático medio (MSE), que mide la diferencia promedio al cuadrado entre los valores reales y las predicciones realizadas por el modelo.
from sklearn.metrics import mean_squared_error
# Cálculo del MSE para cada modelo
mse_linear = mean_squared_error(y_test, y_pred_linear)
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
mse_ridge = mean_squared_error(y_test, y_pred_ridge)
print('MSE Linear:', mse_linear)
print('MSE Lasso:', mse_lasso)
print('MSE Ridge:', mse_ridge)
Los coeficientes en los modelos de regresión reflejan la importancia de cada característica. En Lasso, ciertos coeficientes pueden reducirse a cero, eliminando de facto algunas características. Por otro lado, Ridge ajusta los coeficientes hacia valores cercanos a cero, pero sin descartarlos por completo, lo que ayuda a manejar la multicolinealidad.
print('Coeficientes Linear:', linear_model.coef_)
print('Coeficientes Lasso:', lasso_model.coef_)
print('Coeficientes Ridge:', ridge_model.coef_)
Este análisis de los coeficientes y la comparación de los MSE entre diferentes modelos te permitirá seleccionar el más adecuado, teniendo en cuenta cuán bien se ajusta el modelo a los datos y su capacidad de generalización a nuevas muestras.
¡Adelante! Continúa explorando y aprendiendo sobre machine learning. Cada paso es un avance hacia el dominio de esta poderosa tecnología.
Aportes 20
Preguntas 6
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
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
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?