Aprender los conceptos clave

1

Todo lo que aprenderás sobre MA con Scikit-Learn

2

¿Cómo aprenden las máquinas?

3

Problemas que podemos resolver con Scikit-learn

4

Las matemáticas que vamos a necesitar

Iniciar un proyecto con sklearn

5

Configuración de nuestro entorno Python

6

Instalación de librerías en Python

7

Datasets que usaremos en el curso

Optimización de features

8

¿Cómo afectan nuestros features a los modelos de Machine Learning?

9

Introducción al PCA

10

Preparación de datos para PCA e IPCA

11

Implementación del algoritmo PCA e IPCA

12

Kernels y KPCA

13

¿Qué es la regularización y cómo aplicarla?

14

Implementación de Lasso y Ridge

15

Explicación resultado de la implementación

16

ElasticNet: Una técnica intermedia

Regresiones robustas

17

El problema de los valores atípicos

18

Regresiones Robustas en Scikit-learn

19

Preparación de datos para la regresión robusta

20

Implementación regresión robusta

Métodos de ensamble aplicados a clasificación

21

¿Qué son los métodos de ensamble?

22

Preparación de datos para implementar métodos de ensamble

23

Implementación de Bagging

24

Implementación de Boosting

Clustering

25

Estrategias de Clustering

26

Implementación de Batch K-Means

27

Implementación de Mean-Shift

Optimización paramétrica

28

Validación de nuestro modelo usando Cross Validation

29

Implementación de K-Folds Cross Validation

30

Optimización paramétrica

31

Implementación de Randomized

32

Bonus: Auto Machine Learning

Salida a producción

33

Revisión de nuestra arquitectura de código

34

Importar y exportar modelos con Sklearn

35

Creación de una API con Flask para el modelo

36

Cierre del curso

37

Material adicional para consultar

No tienes acceso a esta clase

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

Explicación resultado de la implementación

15/37
Recursos

Aportes 19

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.

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

“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’.

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.

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.

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

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.

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.

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

ALpha = 0.0010
ta de un mejor score

**¿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.
# ⚠️ **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.