Aprender los conceptos clave

1

Procesamiento de Datos con Scikit-Learn para Machine Learning

2

Aprendizaje Supervisado: Datos y Observación

3

Modelos de Clasificación y Regresión con Scikit-learn

4

Matemáticas clave para dominar Machine Learning

Iniciar un proyecto con sklearn

5

Configuración Avanzada de Entornos de Desarrollo en Visual Studio Code

6

Verificación de Librerías para Desarrollo en Python

7

Análisis de Datos para la Felicidad y Salud Cardiaca

Optimización de features

8

Elementos Clave para Mejorar Modelos de Machine Learning

9

Reducción de Dimensionalidad: Análisis de Componentes Principales

10

Optimización de Modelos en Python: Uso de PCA y Regresión Logística

11

Clasificación Binaria con PCA y Regresión Logística

12

Análisis de Kernel: Modelos de Clasificación Avanzada

13

Regularización en Machine Learning: Lasso y Ridge

14

Regularización: Lasso y Ridge para predicción efectiva

15

Regresión Lineal: Minimización de Pérdidas y Coeficientes

16

Regularización ElasticNet: Combinando Lasso y Ridge en Scikit-learn

Regresiones robustas

17

Identificación de datos atípicos en análisis estadístico

18

Regresiones robustas: técnicas para manejar valores atípicos

19

Regresión Lineal y Máquinas de Soporte: Lidando con Datos Corruptos

20

Automatización de Código para Modelos Predictivos en Python

Métodos de ensamble aplicados a clasificación

21

Esamblaje de Modelos de Machine Learning: Bagging y Boosting

22

Clasificación Binaria con Bagging Classifier en Scikit-Learn

23

Implementación de métodos de ensamble en Python

24

Clasificación con Gradient Boosting en Datos de Enfermedades Cardíacas

Clustering

25

Agrupamiento de Datos: Clustering No Supervisado

26

"Algoritmos de Clustering: Agrupación de Datos con K-Means"

27

Agrupamiento de Datos Usando MeanShift en Python

Optimización paramétrica

28

Validación Cruzada en Modelos de Aprendizaje Automático

29

Validación Cruzada con Scikit-learn y Árboles de Decisión

30

Optimización de Modelos con Grid Search y Random Search

31

Optimización de Modelos con Random Forest en Python

32

Auto-sklearn: Optimización Automática de Modelos de Machine Learning

Salida a producción

33

Estructura de Proyecto en Python: Organiza y Optimiza tu Código

34

Programación Orientada a Objetos con Python Avanzado

35

Creación de Servidor Web con Flask en Python

36

Modelos de Machine Learning: Selección y Optimización

37

Python para Análisis de Datos Financieros

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Regresión Lineal: Minimización de Pérdidas y Coeficientes

15/37
Recursos

Aportes 21

Preguntas 7

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Veo un inconveniente con la explicación del resultado. Si miramos el resultado de la perdida para el modelo lineal, aparece en pantalla algo como 9.11362706964361e-08 (el resultado que me arroja cercano al del video) que es igual a 0.00000009113… , es decir, que en realidad el modelo que genera menor perdida es el lineal. Por otro lado al comparar los coeficientes para la variable “corruption” en todos los modelos, se observa que el coeficiente para el modelo lineal es de 0.9996… , osea casi 1!!. Luego esto indicaría que la variable es estadisticamente muy significativa y por tanto el modelo lasso nos estaría llevando hacia un resultado erróneo. Me gustaría escuchar su opinión.

Cierto lo que dice joahnR, en realidad el modelo con mejor desempeño es el Lineal, ya que su valor de MSE es muy cercano a 0 (6.182e-08), es decir, la media del cuadrado de las diferencias entre los valores de y reales (y_test) y los valores predichos (y_pred) es muy pequeña, lo cual es muy bueno.

Esto lo podemos visualizar graficando los valores y_test frente a los valores y_pred de cada modelo. O, mejor aún, graficando los valores de los mínimos cuadrados:

Dejo el código:

import seaborn as sns
import matplotlib.pyplot as plt

# Calculamos los mínimos cuadrados
# es decir, el cuadrado de la diferencia entre los valoes
# predichos y los valores reales
y_test_values = y_test.values.ravel()

mins_lineal = (y_test_values - y_predict_linear)**2
mins_ridge = (y_test_values - y_predict_ridge)**2
mins_lasso = (y_test_values - y_predict_lasso)**2

# Graficamos
observaciones = range(len(y_test)) # Número de observaciones
# Plot con seaborn
sns.scatterplot(x, ms_lineal, label = 'Mod. Lineal (sin reg.)')
sns.scatterplot(x, ms_ridge, label = 'Mod. con Reg. Ridge')
sns.scatterplot(x, ms_lasso, label = 'Mod. con Reg. Ridge')
plt.xlabel('Observaciones del set de prueba')
plt.ylabel('Mínimos cuadrados (' + r'$(\hat{y} - y)^2$')
plt.show()

Como se observa en la gráfica, el modelo lineal tiene valores muy bajos, todos en cero prácticamente, lo que significa que lo predicho por el modelo (y_pred) se ajusta muy bien a los valores observados (los reales; y_test). En cambio, al regularizar con Lasso o Ridge, sí que hay diferencias entre los valores predichos y los observados. Por esto, al promediar todas estas diferencias, que es justo lo que hace el MSE (mean_square_error), el valor es más alto para estos dos modelos.

“Los arboles no te dejan ver el bosque”. Mucho analisis matematico (que lo hace la libraria por ti), sin entender lo que esta evaluando y sacando conclusiones sin validez.
Eso te hace cometer errores ’ no forzados’.

Se cometió un error gracias a la notación científica, así se observa mejor:

print( "%.10f" % float(linear_loss))
print( "%.10f" % float(lasso_loss))
print( "%.10f" % float(ridge_loss))

Entiendo que la regresión lineal “básica” no entra en competencia con Lasso y Ridge debido a que la premisa es que este modelo “sobreajusta” por eso solo evaluamos L1 y L2.

Aplicando un poco de lo que se conversó en las clases pasadas. Porque el modelo lineal no es el mejor. Al tener pocos datos como uds han comentado vamos a tener un modelo muy sobre ajustado, lo cual para próximas mediciones no nos da un correcto resultado. Es decir ese modelo tan sobre ajustado solo servirá para ese conjunto de datos, pero al tratar de predecir con otros datos no serviría. Por esa razón comenta el uso de regularización para evitar el sobre ajuste al tener pocos datos

Según puedo observar se utiliza el modelo lineal para comparar el trabajo que hacen los otros dos modelos, con el tema de “penalizar” aquellas variables que estarían aportando menos información.
El modelo lineal no penaliza nada y mantiene los valores de los coeficiente igual durante todo el proceso.
Aprovechamos el ejercicio para comparar lo que hacen Lasso y Ridge, aunque si es innegable que la perdida del modelo lineal, para este caso específico y para los features que escogimos, es la mas pequeña.

Yo utilice Kaggle para esta practica, les dejo mi
notebook .

Valores de Pérdida (Pérdida):

Linera_loss:

  • 1.0320887698413223e-07: El valor es extremadamente pequeño, en notación científica (e-07).
    Esto indica que el modelo de regresión lineal (sin regularización) se ajusta prácticamente a la perfección a los datos de prueba.
    Sin embargo, este valor puede indicar un posible sobreajuste en los datos de entrenamiento.

Lasso_Loss: 0.06832940807010227:

  • El valor es mayor que el de la regresión lineal. Indica que el modelo Lasso tiene un rendimiento ligeramente inferior al modelo de regresión
    lineal en términos de ajuste a los datos de prueba.
    Este valor se considera razonable y puede estar generalizando mejor.

Ridge Loss: 0.008008658393959037:

  • Este valor es más pequeño que el de Lasso.
    Indica que el modelo Ridge tiene un rendimiento superior en términos de ajuste a los datos de prueba.
    Ridge es capaz de reducir aún más la varianza en comparación con Lasso.

Coeficientes Lasso:

  • Los coeficientes del modelo Lasso son [1.27832505, 0.94626719, 0.49712179, 0.54420218, 0.0, 0.18702965, 0.89819832].
  • Esto significa que Lasso ha reducido algunos coeficientes a cero, lo que implica que algunas características no están contribuyendo
    significativamente a la predicción.
    Las características con coeficientes diferentes de cero son las que Lasso considera más relevantes para la predicción.

Coeficientes Ridge:

  • Los coeficientes del modelo Ridge son [1.06916508, 0.97360654, 0.86465538, 0.83804516, 0.6480948, 0.74175414, 0.96148902].

Los coeficientes de Ridge son más pequeños en general que los de Lasso.

  • Ridge busca minimizar la magnitud de los coeficientes, lo que ayuda a reducir la varianza en el modelo.

En resumen, estos resultados indican que Ridge está obteniendo el mejor rendimiento en términos de ajuste a los datos de prueba,
seguido de Lasso y luego el modelo de regresión lineal.

La diferencia de y_test y los algoritmos gráficamente:

Se aprecia claramente que Lasso difiere más.

Noté que hay mucha confusión con el error del modelo lineal. Da muy bajo y mucho piensan que se trata de overfitting o errores en los otros modelos, etc. Ninguna de esas es la causa, simplente la variable ‘score’ es la suma de las variable escogidas, es decir, hay una relación lineal perfecta entre las variables elegidas y la variable objetivo, con lo cual el modelo lineal es el mejor. Si prueban sumar las variables seleccionadas por el profesor, observarán los mismo valores de la variable score:

X = df_happiness[['gdp', 'family', 'lifexp', 'freedom', 'generosity', 'corruption', 'dystopia']]
y = df_happiness['score']
print(pd.concat([X.sum(axis=1).rename('suma'), y], axis=1))
         suma  score
0    7.537079  7.537
1    7.521835  7.522
2    7.503704  7.504
3    7.494366  7.494
4    7.469203  7.469
..        ...    ...
150  3.470759  3.471
151  3.461913  3.462
152  3.349075  3.349
153  2.904535  2.905
154  2.693061  2.693

y si chequean los coeficientes del modelo lineal son todos cercanos a 1:

model_linear = LinearRegression().fit(X_train, y_train)
y_predict_linear = model_linear.predict(X_test)
linear_loss = mean_squared_error(y_test, y_predict_linear)
print(f'Linear loss: {linear_loss}')
print('Linear coef:', model_linear.coef_, sep='\n')
Linear loss: 9.068971727801338e-08
Linear coef:
[1.00004716 0.99992617 0.99991259 1.0001198  1.00017723 1.000054495 1.00001989]

Espero les sirva mi aporte, y a seguir metiéndole para adelante antes de que nos coman las IAs!

¿Alguno de ustedes obtuvo unos resusltados parecidos a estos? La verdad, me sorprende que obtengamos unos scores casi perfectos.
Si estoy haciendo algo mal escribiendo las siguientes líneas de código, por favor coméntenmelo.

X_test
print("Score Lineal")
print(modelLinear.score(X_test, Y_test))
print("Score Lasso")
print(modelLasso.score(X_test, Y_test))
print("Score Ridge")
print(modelRidge.score(X_test, Y_test))
Score Lineal
0.9999999231608282
Score Lasso
0.9658608399998099
Score Ridge
0.9964192911779547
**¿Cómo interpretar los resultados?** Cuando aplica diferentes técnicas de regularización en modelos de aprendizaje automático, es crucial interpretar los resultados para comprender cómo afectan la complejidad del modelo y su capacidad para generalizar a datos nuevos. Aquí hay algunos enfoques avanzados para interpretar los resultados de diferentes regularizaciones: 1. **Análisis de pérdida y métricas de rendimiento** **(Loss and Performance Metrics Analysis)**: * Compara la función de pérdida o el error de validación entre diferentes modelos entrenados con diferentes técnicas de regularización. * Observa cómo la regularización afecta la convergencia del modelo durante el entrenamiento y si hay signos de sobreajuste o subajuste. * Evalúa métricas de rendimiento como la precisión, el área bajo la curva ROC (AUC), o cualquier otra métrica relevante para tu problema específico en conjuntos de datos de prueba o validación. 2. **Análisis de coeficientes de variables** **(Variable Coefficients Analysis)**: * Examina los coeficientes de las variables para entender cómo la regularización influye en la importancia relativa de cada característica en la predicción. * Con Lasso (L1), observa qué características tienen coeficientes no nulos, ya que Lasso tiende a hacer que algunos coeficientes sean exactamente cero, lo que sugiere una selección de características automática. * Con Ridge (L2), observa cómo la magnitud de los coeficientes se ve afectada por la regularización. Ridge tiende a reducir la magnitud de todos los coeficientes por igual. 3. **Visualización de coeficientes y trayectorias de regularización** **(Visualization of Coefficients and Regularization Paths)**: * Grafica los coeficientes de las variables en función del parámetro de regularización (como el inverso de la fuerza de regularización) para ver cómo cambian a medida que ajustas la fuerza de la regularización. * Observa cómo las trayectorias de regularización difieren entre L1 y L2. Con L1, es probable que veas que los coeficientes se vuelven exactamente cero en algún punto, mientras que con L2, los coeficientes disminuyen gradualmente. 4. **Análisis de importancia de características** **(Feature Importance Analysis)**: * Utiliza técnicas como la importancia de características basada en árboles (como el método feature\_importances\_ en Random Forest o Gradient Boosting) para evaluar la importancia relativa de las características en el modelo final. 5. **Validación cruzada y búsqueda de hiperparámetros** **(Cross-Validation and Hyperparameter Tuning)**: * Realiza validación cruzada para evaluar el rendimiento de los modelos regularizados en múltiples particiones de datos y asegurarte de que los resultados sean consistentes. * Realiza una búsqueda de hiperparámetros para encontrar el valor óptimo del parámetro de regularización utilizando técnicas como la búsqueda en malla (grid search) o la búsqueda aleatoria (random search). Al interpretar los resultados de diferentes regularizaciones, es esencial considerar tanto el rendimiento predictivo del modelo como la interpretación de la importancia de las características. Experimenta con diferentes técnicas y ajusta los hiperparámetros para encontrar el equilibrio adecuado entre la capacidad predictiva y la interpretabilidad del modelo.

Aplique Cross Validation para poder ver realmente cual de los 3 era el modelo más estable. Cross Validation lo que hace es hacer n número de samples de todos tus registros y les aplica el modelo que le pases, lo que te devuelve un arreglo con todos las puntuaciones de r2.

from sklearn.model_selection import cross_val_score

cv_linear_model = LinearRegression()
cv_linear_scores = cross_val_score(cv_linear_model, X, y, cv=5)
cv_lasso_model = Lasso(alpha=0.02)
cv_lasso_scores = cross_val_score(cv_lasso_model, X, y, cv=5)
cv_ridge_model = Ridge(alpha=1)
cv_ridge_scores = cross_val_score(cv_ridge_model, X, y, cv=5)

print('Linear model: ', cv_linear_scores)
print('Lasso model: ', cv_lasso_scores)
print('Ridge model: ', cv_ridge_scores)
Linear model:  [0.99999952 0.99999737 0.99999628 0.99999831 0.99999934]
Lasso model:  [-1.62604841  0.49859277 -0.30365239 -0.33227323  0.37685477]
Ridge model:  [0.56354766 0.94846975 0.86066884 0.89743481 0.92261616]

Esto se puede interpretar como que el modelo linear está haciendo overfitting siempre al tener un valor casi 1 en todos los casos. Y en este caso se podría decir que el mejor modelo sería con el ridge ya que es el más estable de los 3 sin caer en el overfitting. Aunque si se va modificando el valor de alpha del modelo lasso puedes llegar a un mejor resultado.

Pero hay otro problema y es que como se mencionó en otro comentario, la variable score es la suma de las demás variables por lo que eso explicaría el porque el overfitting del modelo linear.

ALpha = 0.0010
ta de un mejor score

Como ver los coeficientes de ambas regresiones graficamente: ![](https://static.platzi.com/media/user_upload/image-e15c15b2-c1fd-4f0e-995b-bb031b127e87.jpg) Código: coef\_lasso\_ridge = pd.DataFrame(    {        'variables': \['gdp', 'family', 'lifexp', 'freedom', 'corruption',  'generosity', 'dystopia']        ,'Lasso': modelLasso.coef\_        ,'Ridge': modelRidge.coef\_      }) fig, ax = plt.subplots(1,2,figsize=(10, 5)) ax\[0].set\_title('Coeficientes de la regresion Lasso')sns.barplot(data=coef\_lasso\_ridge, x='variables', y='Lasso', ax = ax\[0])ax\[0].bar\_label(ax\[0].containers\[0], fontsize=10, fmt = '%.2f');plt.setp(ax\[0].get\_xticklabels(), rotation=90)  ax\[1].set\_title('Coeficientes de la regresion Ridge')sns.barplot(data=coef\_lasso\_ridge, x='variables', y='Ridge', ax = ax\[1])ax\[1].bar\_label(ax\[1].containers\[0], fontsize=10, fmt = '%.2f');plt.setp(ax\[1].get\_xticklabels(), rotation=90)  plt.show()```js coef_lasso_ridge = pd.DataFrame( { 'variables': ['gdp', 'family', 'lifexp', 'freedom', 'corruption', 'generosity', 'dystopia'] ,'Lasso': modelLasso.coef_ ,'Ridge': modelRidge.coef_ } ) fig, ax = plt.subplots(1,2,figsize=(10, 5)) ax[0].set_title('Coeficientes de la regresion Lasso') sns.barplot(data=coef_lasso_ridge, x='variables', y='Lasso', ax = ax[0]) ax[0].bar_label(ax[0].containers[0], fontsize=10, fmt = '%.2f'); plt.setp(ax[0].get_xticklabels(), rotation=90) ax[1].set_title('Coeficientes de la regresion Ridge') sns.barplot(data=coef_lasso_ridge, x='variables', y='Ridge', ax = ax[1]) ax[1].bar_label(ax[1].containers[0], fontsize=10, fmt = '%.2f'); plt.setp(ax[1].get_xticklabels(), rotation=90) plt.show() ```
Se puede observar el overfitting revisando los coeficientes, evidenciando que el modelo entrenado es incorrecto. ![](https://static.platzi.com/media/user_upload/image-f03cb7bb-7d89-4283-b46f-3057fb027c6d.jpg)
# ⚠️ **Importante:** # El resultado de `Linear Loss` esta expresado en **<u>Notacion Cientifica Exponencial</u>** ![](https://static.platzi.com/media/user_upload/image-8aaed4ed-78ec-4c96-bb39-a52e819bec9b.jpg) Esto implica que el valor de Linear Loss es: **0.00000008957319864766428** Es decir. Es un numero mucho más pequeño. … Aqui dejo un enelace para prufundizar más en notacion cientifica https://es.wikipedia.org/wiki/Notación\_científica

Un valor más bajo de la métrica de pérdida indica un mejor rendimiento del modelo. En este caso, el modelo con la menor pérdida es el modelo de regresión lineal (Linear Regression), ya que tiene una pérdida extremadamente baja de 9.438292979333945e-08.

El valor extremadamente bajo de la pérdida en el modelo de regresión lineal podría ser un indicador de sobreajuste.

dejo este codigo para entender mejor los resultado

# Crear un dataframe con los coeficientes de Lasso
df_lasso = pd.DataFrame({'columna': X.columns, 'coeficiente': modelLasso.coef_})

# Crear un dataframe con los coeficientes de Ridge
df_ridge = pd.DataFrame({'columna': X.columns, 'coeficiente': modelRidge.coef_[0]})

# Imprimir los dataframes
print('Coeficientes Lasso:')
print(df_lasso)

print('Coeficientes Ridge:')
print(df_ridge)

Revisar, el modelo con menor pérdida fue el modelo lineal.