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

Implementación de Lasso y Ridge

14/37
Recursos

Aportes 14

Preguntas 5

Ordenar por:

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

o inicia sesión.

Nota: el dataset de “whr2017” lo encontramos en los archivos del curso como “felicidad”

<h3>Les dejo mi código comentado por su por alguna razón no les corre:</h3>
# 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

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

version mas sencilla de seleccionar mismos features:

X = dt_felicidad.iloc[:,5:]

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

Mejor rendimiento: LinearRegression
Peor rendimiento: Lasso

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.

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