Aprender los conceptos clave

1

Curso Completo de Machine Learning con Scikit-learn para Principiantes

2

Tipos de Aprendizaje en Machine Learning: Supervisado, No Supervisado y por Refuerzo

3

Problemas de Clasificaci贸n, Regresi贸n y Clustering con Scikit-learn

4

Fundamentos Matem谩ticos para Machine Learning Avanzado

Iniciar un proyecto con sklearn

5

Configuraci贸n Profesional de Entorno de Trabajo para Python

6

Instalaci贸n y configuraci贸n de librer铆as para Python

7

An谩lisis de Datos para el Bienestar y la Felicidad Humana

Optimizaci贸n de features

8

Selecci贸n de Variables en Modelos de Aprendizaje Autom谩tico

9

Reducci贸n de Dimensionalidad con An谩lisis de Componentes Principales

10

Reducci贸n de Dimensionalidad y Regresi贸n Log铆stica con Python

11

Clasificaci贸n de Enfermedad Cardiaca con PCA y Regresi贸n Log铆stica

12

Funciones Kernel en la Clasificaci贸n de Datos Complejos

13

Regularizaci贸n en Modelos de Machine Learning

14

Implementaci贸n de Regularizaci贸n en Modelos de Regresi贸n Lineal

15

An谩lisis de Resultados en Modelos de Regresi贸n Ridge y Lasso

16

Regularizaci贸n ElasticNet con Scikit-learn: Conceptos y Aplicaci贸n

Regresiones robustas

17

Identificaci贸n de Valores At铆picos en Datos para Modelos Predictivos

18

T茅cnicas de Regresi贸n Robusta: RANSAC y Huber en Scikit-Learn

19

Regresi贸n Lineal y Soporte Vectorial: Manejo de Datos At铆picos

20

Automatizaci贸n de Modelos de Predicci贸n en Python

M茅todos de ensamble aplicados a clasificaci贸n

21

M茅todos de Ensamble: Bagging y Boosting en Machine Learning

22

Implementaci贸n de Bagging Classifier con SAIC en An谩lisis Cardiaco

23

M茅todos de Ensamble para Mejorar Clasificaci贸n en Machine Learning

24

Implementaci贸n de Gradient Boosting para Clasificaci贸n de Datos

Clustering

25

Agrupamiento de Datos en Aprendizaje No Supervisado

26

Agrupamiento de Caramelos con K-Means y Pandas

27

Agrupamiento de Datos con Algoritmo Mean Shift

Optimizaci贸n param茅trica

28

Validaci贸n Cruzada en Modelos de Machine Learning

29

Validaci贸n Cruzada con Scikit-learn: Cruz Vales Cor y KFold

30

Optimizaci贸n de Modelos con B煤squeda en Grilla y Aleatoria

31

Automatizaci贸n de Par谩metros en Modelos de Regresi贸n con Random Forest

32

Optimizaci贸n Autom谩tica de Modelos con Auto-sklearn

Salida a producci贸n

33

Estructuraci贸n Modular de C贸digo Python para Machine Learning

34

Automatizaci贸n de Modelos Machine Learning con Python

35

Publicaci贸n de Modelos de IA con Flask y Python

36

Optimizaci贸n de Modelos de Machine Learning para Producci贸n

37

Recursos para Aprender Machine Learning y Data Science

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Automatizaci贸n de Modelos Machine Learning con Python

34/37
Recursos

驴C贸mo extender nuestra arquitectura de c贸digo sin da帽ar la l贸gica existente?

Construir una arquitectura de c贸digo robusta y flexible es esencial para el desarrollo de soluciones efectivas en ciencia de datos y aprendizaje autom谩tico. El objetivo es poder extender el sistema f谩cilmente sin comprometer el c贸digo existente. Vamos a explorar c贸mo podemos lograrlo, comenzando con una implementaci贸n cuidadosa de las librer铆as necesarias y un an谩lisis detallado del c贸digo.

Preparaci贸n y carga de librer铆as

Para comenzar, debemos importar las librer铆as esenciales para nuestro desarrollo. En Python, es importante recordar que una vez cargada una librer铆a, no es necesario volver a cargarla en memoria, evitando as铆 desbordar innecesariamente la misma.

import pandas as pd
import numpy as np
from sklearn.svm import SVR
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import GridSearchCV
  • Pandas: Es fundamental para la manipulaci贸n de datos.
  • NumPy: Proporciona funciones matem谩ticas avanzadas.
  • Scikit-learn: Ofrece herramientas para modelos de aprendizaje autom谩tico, como SVR y GradientBoostingRegressor.

Definici贸n de la clase principal

La implementaci贸n de una clase principal nos permite estructurar mejor nuestro c贸digo. Esta clase emplea un constructor para la inicializaci贸n de variables y configuraciones necesarias.

class Models:
    def __init__(self):
        self.regressors = {
            'SVR': SVR(),
            'GradientBoosting': GradientBoostingRegressor()
        }
        self.parametros = {
            'SVR': {'kernel': ['linear', 'poly', 'rbf'], 'C': [1, 5, 10]},
            'GradientBoosting': {'loss': ['ls', 'lad'], 'learning_rate': [0.01, 0.05, 0.1]}
        }

Configuraci贸n de los modelos de aprendizaje autom谩tico

Definir un diccionario de diccionarios para los par谩metros de cada modelo nos facilita realizar un ajuste hiperpar谩metro con GridSearchCV.

Implementaci贸n del ajuste de hiperpar谩metros

def grid_training(self, x, y):
    best_score = float('inf')
    best_model = None
    for name, regressor in self.regressors.items():
        param_grid = self.parametros[name]
        grid_search = GridSearchCV(regressor, param_grid, cv=3)
        grid_search.fit(x, y)
        score = np.abs(grid_search.best_score_)
        if score < best_score:
            best_score = score
            best_model = grid_search.best_estimator_

    return best_model, best_score

Exportaci贸n del modelo

Una vez identificado el mejor modelo, es crucial exportarlo para su uso futuro. Implementamos una funci贸n en nuestras utilidades para lograr esto.

C贸digo para la exportaci贸n

def export_model(model, score):
    import joblib
    joblib.dump(model, f'models/best_model_{score}.pkl')

Integraci贸n con el archivo principal

Finalmente, conectamos nuestra l贸gica definida en modelos con nuestro archivo principal, asegurando la ejecuci贸n y generaci贸n correcta de modelos.

from models import Models

if __name__ == "__main__":
    model_instance = Models()
    x, y = obtain_features_and_target()  # Funci贸n ficticia para obtener datos.
    best_model, best_score = model_instance.grid_training(x, y)
    export_model(best_model, best_score)

Con esta arquitectura, hemos asegurado un flujo continuo y eficiente desde la carga de librer铆as hasta la exportaci贸n de modelos. La capacidad de identificar y utilizar el mejor modelo posible para una soluci贸n espec铆fica es un paso crucial en proyectos de ciencia de datos. Esta pr谩ctica no solo optimiza recursos, sino que tambi茅n garantiza precisiones mayores en las predicciones.

Aportes 20

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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.

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)


Muy buenas la distribuci贸n de los archivos, clases y dem谩s 馃槂

Con que as铆 luce el c贸digo para producci贸n!!!

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

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

驴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

Uno de los mejores cursos. Muy completo

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

S铆 les sale un error, tienen que cambiar en la carpeta models(punto)py en la funci贸n de GRADIENT cambiar los par谩metros de la funci贸n de perdida -loss- de la siguiente manera:

'loss' : ['squared_error', 'huber'],

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)

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

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

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

Importar y exportar modelos con Scikit-Learn es una tarea esencial cuando trabajas en proyectos de aprendizaje autom谩tico. Esto te permite guardar tus modelos entrenados y reutilizarlos en el futuro sin tener que volver a entrenarlos desde cero. Scikit-Learn proporciona herramientas para facilitar la importaci贸n y exportaci贸n de modelos.

Excelente clase!!!

Para que no les pase c贸mo a m铆 les paso el **JSON** de los diccionarios que tienen que tener ahora y no se les rompa el c贸digo: ```python self.reg = { 'SVR': SVR(), # Instanciar SVR 'GRADIENT': GradientBoostingRegressor() # Instanciar GradientBoostingRegressor } self.params = { 'SVR': { 'kernel': ['linear', 'poly', 'rbf'], 'gamma': ['auto', 'scale'], 'C': [1, 5, 10] }, 'GRADIENT': { 'loss': ['squared_error', 'absolute_error', 'huber', 'quantile'], 'learning_rate': [0.01, 0.05, 0.1] } } ```聽 聽 聽
Aqu铆 est谩 el c贸digo optimizado con comentarios a帽adidos para explicar la funcionalidad de cada secci贸n: **main.py:** ```js pythonCopy code import pandas as pd from utils import Utils from models import Models if __name__ == "__main__": # Inicializar instancias de Utils y Models utils = Utils() models = Models() # Cargar datos desde el archivo CSV data = utils.load_from_csv('./in/felicidad.csv') # Separar caracter铆sticas y etiquetas del dataset X, y = utils.features_target(data, ['score', 'rank', 'country'], ['score']) # Entrenar modelos y realizar b煤squeda en cuadr铆cula models.grid_training(X, y) # Imprimir el dataset print(data) ```**utils.py:** ```js pythonCopy code import pandas as pd import joblib class Utils: # M茅todo para cargar datos desde un archivo CSV def load_from_csv(self, path): return pd.read_csv(path) # M茅todo para seleccionar caracter铆sticas y etiquetas del dataset def features_target(self, dataset, drop_cols, y): X = dataset.drop(drop_cols, axis=1) y = dataset[y] return X, y # M茅todo para exportar el mejor modelo entrenado def model_export(self, clf, score): print(score) joblib.dump(clf, './models/best_model.pkl') ```**models.py:** ```js pythonCopy code import numpy as np 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): # Inicializar modelos y par谩metros para la b煤squeda en cuadr铆cula 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] } } # M茅todo para entrenar modelos y realizar b煤squeda en cuadr铆cula def grid_training(self, X, y): best_score = float('inf') 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_ # Exportar el mejor modelo utils = Utils() utils.model_export(best_model, best_score ```

Excelente curso !

Genial esta clase, como articul贸 todo lo aprendido y la aplicaci贸n de la modularidad con la implementaci贸n de clases!!Si no entendieron bien la metodolog铆a recomiendo ver:
Curso de Poo de Platzi