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

Importar y exportar modelos con Sklearn

34/37
Recursos

Aportes 15

Preguntas 2

Ordenar por:

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

o inicia sesión.

Nota:
grid_reg.best_score_ regresa el promedio del score por defecto del mejor estimador.

Hasta ahora, este ha sido el mejor curso desde el punto de vista de metodología.

Muy buenas la distribución de los archivos, clases y demás 😃

Excelente clase, estoy muy motivado para hacer mis propios modelos!

Con que así luce el código para producción!!!

Uno de los mejores cursos. Muy completo

¿Por qué se toma el valor absoluto del score en la línea 37? ¿Y por qué se considera que el mejor score es el más bajo? Estaba leyendo la documentación, y se supone que todos los scores siguen la convención de que entre mayor es, mejor. En este caso, creo que la métrica es R^2, que sí sigue esa regla.
https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter

Codigo actualizado.

main

import pandas as pd
import numpy as np
import sklearn
from utils import Utils
from models import Models

if __name__ == "__main__":

    utils = Utils()
    models = Models()

    data = utils.load_from_csv('./in/felicidad.csv')
    X, y = utils.features_target(data, ['score','rank', 'country'],['score'])

    models.grid_training(X,y)

    print(data)



Utils

import pandas as pd
import numpy as np
import sklearn
import joblib

class Utils:

    def load_from_csv(self, path):
        return pd.read_csv(path)

    def load_from_mysql(self):
        pass

    def features_target(self, dataset, drop_cols, y):
        X = dataset.drop(drop_cols, axis=1)
        y = dataset[y]
        return X,y

    def model_export(self, clf, score):
        print(score)
        joblib.dump(clf, './models/best_model.pkl')


Models

import pandas as pd
import numpy as np
import sklearn
from sklearn.svm import SVR
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import GridSearchCV

from utils import Utils

class Models:

    def __init__(self):
        self.reg = {
            'SVR' : SVR(),
            'GRADIENT' : GradientBoostingRegressor()
        }

        self.params = {
           'SVR' : {
               'kernel' : ['linear', 'poly', 'rbf'],
               'gamma' : ['auto', 'scale'],
               'C' : [1,5,10]
           }, 'GRADIENT' : {
               'loss' : ['squared_error', 'absolute_error'],
               'learning_rate' : [0.01, 0.05, 0.1]
           }
        }

    def grid_training(self, X,y):

        best_score = 999
        best_model = None

        for name, reg in self.reg.items():

            grid_reg = GridSearchCV(reg, self.params[name], cv=3).fit(X, y.values.ravel())
            score = np.abs(grid_reg.best_score_)

            if score < best_score:
                best_score = score
                best_model = grid_reg.best_estimator_


        utils = Utils()
        utils.model_export(best_model, best_score)


Estas 2 ultimas clases me han ayudado muchisimo ya que siempre tenia esa duda si me la tenia que vivir con puros script en Python con todas sus librearias, pero el crear un Framework con modelos, ordenaod y organizado te da un manetra de trabajar mas productivamente

Nunca habia tan aniamado hacer mis propios modelos, voy a empezar cada vez hacer cada vez más

Como se hace todo esto en Jupyter o Colab?
En Jupyter puse todo dentro de una carpeta, pero no reconoce a utils.

Acá les dejo mi implementación pero en vez de usar algoritmos para regresión use para clasificación

import pandas as pd
import numpy as np

from sklearn.svm import SVC
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import GridSearchCV

from utils import Utils

class Models:

    def __init__(self):
        self.reg = {
            'SVC' : SVC(),
            'GRADIENT' : GradientBoostingClassifier()
        }

        self.params = {
           'SVC' : {
               'kernel' : ['linear', 'poly', 'rbf'],
               'gamma' : ['auto', 'scale'],
               'C' : [1,5,10]
           }, 'GRADIENT' : {
               'loss' : ['deviance', 'exponential'],
               'learning_rate' : [0.01, 0.05, 0.1]
           }
        }

    def grid_training(self, X,y):

        best_score = 999
        best_model = None

        for name, reg in self.reg.items():

            grid_reg = GridSearchCV(reg, self.params[name], cv=3).fit(X, y.values.ravel())
            score = np.abs(grid_reg.best_score_)

            if score < best_score:
                best_score = score
                best_model = grid_reg.best_estimator_
        

        utils = Utils()
        utils.model_export(best_model, best_score)

Actualización febrero 2023, en el parámetro ‘loss’ ya no se aplica [‘ls’, ‘lad’] ahora es [‘absolute_error’, ‘squared_error’]

Línea para agregar el score al nombre del modelo que exportamos

joblib.dump(clf, './models/best_model_'+str(round(score,3))+'.pkl') 

Excelente clase!!!