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

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

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

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.