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

Convierte tus certificados en títulos universitarios en USA

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

19 Días
3 Hrs
21 Min
13 Seg

Implementación de Randomized

31/37
Recursos

Aportes 28

Preguntas 5

Ordenar por:

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

Hice algunas actualizaciones porque las funciones en la llave “criterion” están descontinuadas, así que el código queda de esta manera:

import pandas as pd

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestRegressor

if __name__ == "__main__":

    dataset = pd.read_csv('./data/felicidad.csv')

    print(dataset)

    X = dataset.drop(['country', 'rank', 'score'], axis=1)
    y = dataset[['score']].squeeze()

    reg = RandomForestRegressor()

    parametros = {
        'n_estimators' : range(4,16),
        'criterion' : ['squared_error', 'absolute_error'],
        'max_depth' : range(2,11)
    }

    rand_est = RandomizedSearchCV(reg, parametros , n_iter=10, cv=3, scoring='neg_mean_absolute_error').fit(X,y)

    print(rand_est.best_estimator_)
    print(rand_est.best_params_)
    print(rand_est.predict(X.loc[[0]]))

Impresionante! Esto ahorra mucho tiempo y con muy buena precisión.
Y sí, el profe se equivocó de número al final. En realidad era el siguiente de la izquierda.

Con respecto a la razón de eliminar el rank y el score, se hace porque generalmente lo que se quiere es que las features no tengan ninguna correlación entre ellas. Lo ideal es que exista correlación solo entre las features y la variable objetivo 😃

Dos cosas que ha prendido al momento y que hubiera deseado aprender hace unos años.

  • Siempre testear, probar nuevas cosas y mas con esta forma, ya se me quitó la pereza.

  • Todos los modelos son malos, solo que se busca el mejor. así que con esto se quiere siempre buscar el mejor, Obvio siempre llevare este curso en mi corazón porque en verdad he aprendido tanto

En realidad el score del primer pais no es el señalado en el video, ya que si se presta atencion al conteo de columnas y valores, se viendo el valor de high
Para saber el score en ese punto simplemente podemos imprimir el valor de y en esa misma posicion

y_hat = randomized.predict(x.loc[[0]])

print('Predict: {:.4}'.format(y_hat[0]))
print('Real:    {:.4}'.format(y[0]))
Predict: 7.507
Real:    7.537

Algunos parámetros del código de la clase fueron actualizados posteriormente y estaban generando un error y warnings en Visual Studio Code. Ajusté los cambios con los parámetros actualizados a hoy (27 de julio de 2023). Espero que a alguien le sirva.

import pandas as pd

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestRegressor

if __name__ == "__main__":

    dataset = pd.read_csv('./data/felicidad.csv')

    print(dataset)

    X = dataset.drop(['country', 'rank', 'score'], axis=1)
    y = dataset['score'].values.ravel()

    reg = RandomForestRegressor()

    parametros = {
        'n_estimators' : range(4,16),
        'criterion' : ['squared_error', 'absolute_error'],
        'max_depth' : range(2,11)
    }

    rand_est = RandomizedSearchCV(reg, parametros , n_iter=10, cv=3, scoring='neg_mean_absolute_error').fit(X,y)

    print(rand_est.best_estimator_)
    print(rand_est.best_params_)
    print(rand_est.predict(X.loc[[0]]))

    #implmentacion_randomizedSearchCV

Cambiaron ‘mse’ y ‘mae’ respectivamente

    parametros = {
        'n_estimators' : range(4,16),
        'criterion' : ['squared_error', 'absolute_error'],
        'max_depth' : range(2,11)
    }# definición de parámetros que vamos a revisar
Aquí tienes el código implementado con `GridSearchCV`: ```js import pandas as pd from sklearn.model_selection import GridSearchCV from sklearn.ensemble import RandomForestRegressor if __name__ == "__main__": # Leer el dataset dataset = pd.read_csv('./data/felicidad.csv') # Imprimir el dataset para verificar la carga print(dataset) # Seleccionar características (X) y etiquetas (y) X = dataset.drop(['country', 'rank', 'score'], axis=1) y = dataset['score'] # Inicializar el regresor RandomForestRegressor reg = RandomForestRegressor() # Definir los parámetros para la búsqueda en cuadrícula parametros = { # Número de árboles en el bosque 'n_estimators': [10, 50, 100], # Criterio utilizado para medir la calidad de una división 'criterion': ['mse', 'mae'], # 'mse': error cuadrático medio, 'mae': error absoluto medio # Profundidad máxima de los árboles en el bosque 'max_depth': [None, 10, 20], # Número mínimo de muestras requeridas para dividir un nodo interno 'min_samples_split': [2, 5, 10], # Número mínimo de muestras requeridas para estar en un nodo hoja 'min_samples_leaf': [1, 2, 4], # Método para la selección de características en cada split 'max_features': ['auto', 'sqrt', 'log2'], # 'auto': sqrt(num_features), 'sqrt': sqrt(num_features), 'log2': log2(num_features) # Bootstrap muestras al construir árboles 'bootstrap': [True, False], # True: usar bootstrap samples, False: usar el dataset completo } # Realizar la búsqueda en cuadrícula de hiperparámetros grid_est = GridSearchCV(reg, parametros, cv=3, scoring='neg_mean_absolute_error').fit(X, y) # Imprimir el mejor estimador encontrado print("Mejor estimador:") print(grid_est.best_estimator_) # Imprimir los mejores parámetros encontrados print("Mejores parámetros:") print(grid_est.best_params_) # Realizar una predicción utilizando el mejor modelo encontrado print("Predicción para el primer ejemplo del dataset:") print(grid_est.predict(X.loc[[0]])) ```import pandas as pd from sklearn.model\_selection import GridSearchCV from sklearn.ensemble import RandomForestRegressor if \_\_name\_\_ == "\_\_main\_\_": \# Leer el dataset dataset = pd.read\_csv('./data/felicidad.csv') \# Imprimir el dataset para verificar la carga print(dataset) \# Seleccionar características (X) y etiquetas (y) X = dataset.drop(\['country', 'rank', 'score'], axis=1) y = dataset\['score'] \# Inicializar el regresor RandomForestRegressor reg = RandomForestRegressor() \# Definir los parámetros para la búsqueda en cuadrícula parametros = { \# Número de árboles en el bosque 'n\_estimators': \[10, 50, 100], \# Criterio utilizado para medir la calidad de una división 'criterion': \['mse', 'mae'], # 'mse': error cuadrático medio, 'mae': error absoluto medio \# Profundidad máxima de los árboles en el bosque 'max\_depth': \[None, 10, 20], \# Número mínimo de muestras requeridas para dividir un nodo interno 'min\_samples\_split': \[2, 5, 10], \# Número mínimo de muestras requeridas para estar en un nodo hoja 'min\_samples\_leaf': \[1, 2, 4], \# Método para la selección de características en cada split 'max\_features': \['auto', 'sqrt', 'log2'], # 'auto': sqrt(num\_features), 'sqrt': sqrt(num\_features), 'log2': log2(num\_features) \# Bootstrap muestras al construir árboles 'bootstrap': \[True, False], # True: usar bootstrap samples, False: usar el dataset completo } \# Realizar la búsqueda en cuadrícula de hiperparámetros grid\_est = GridSearchCV(reg, parametros, cv=3, scoring='neg\_mean\_absolute\_error').fit(X, y) \# Imprimir el mejor estimador encontrado print("Mejor estimador:") print(grid\_est.best\_estimator\_) \# Imprimir los mejores parámetros encontrados print("Mejores parámetros:") print(grid\_est.best\_params\_) \# Realizar una predicción utilizando el mejor modelo encontrado print("Predicción para el primer ejemplo del dataset:") print(grid\_est.predict(X.loc\[\[0]])) Este código utiliza `GridSearchCV` en lugar de `RandomizedSearchCV`. Los parámetros y su rango son especificados manualmente para realizar una búsqueda exhaustiva sobre todas las combinaciones posibles de parámetros dentro del rango especificado. Esto puede ser útil si la cantidad de combinaciones es manejable y no demasiado grande.

utilizando python 3.9 solo cuando cambié la forma de los datos objetivo quitando un par de corchetes pude correrlo adecuadamente (y=dataset[“score”])

Yo le hice unas pequeñas variaciones para que el resultado en la terminal sea más legible: ```python import pandas as pd from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import RandomizedSearchCV if __name__ == "__main__": data = pd.read_csv('./data/felicidad.csv') X = data.drop(['country', 'rank', 'score'], axis=1) y = data['score'] reg = RandomForestRegressor() parametros = { 'n_estimators': range(4, 16), 'criterion': ['squared_error', 'absolute_error'], 'max_depth': range(2, 11) } rand_est = RandomizedSearchCV(reg, parametros, n_iter=10, cv=3, scoring='neg_mean_absolute_error').fit(X, y) print(f"The best estimators are {rand_est.best_estimator_}") print(f"The best params are {rand_est.best_params_}") print(f"The prediction of score to the firs country is {rand_est.predict(X.loc[[0]])}") print(data.head(3)) ``` ![](https://static.platzi.com/media/user_upload/image-fa63dd99-a5f4-4042-aa8c-6f7e1cd31050.jpg)

Falto realizar el SPLIT de los datos.

X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=0.25,
                                                    random_state=42)

Parametros de GridSearchCV

estimator: el modelo que está utilizando.
params_grid: el objeto de diccionario que contiene los hiperparámetros que desea probar.
scoring: métrica de evaluación
cv: número de validaciones cruzadas para cada conjunto de hiperparámetros
verbose: cuanto más alto, más mensajes se imprimirán.
n_jobs: número de trabajos que se ejecutarán en paralelo
pre_dispatch: controla el número de trabajos que se pueden realizar en paralelo (para evitar problemas de memoria)
iid: asume que los datos se distribuyen de forma idéntica e independiente. El valor predeterminado es falso.
refit: una vez que se encuentran los mejores parámetros, reajuste el estimador
error_score: valor para asignar al puntaje si ocurre un error al ajustar el estimador
return_train_score: incluya puntajes de tren en cv_results_

¡Acá por fin quitó la columna ‘rank’!

cross_val_score o KFold
¿Tienen una aplicación que no tenga que ver con la optimización de parámetros?

La clase se centró en la implementación de la optimización paramétrica utilizando el método Randomized, específicamente aplicado a un modelo de regresión con Random Forest en scikit-learn. Se abordaron los pasos para cargar datos, definir un estimador y crear una grilla de parámetros para optimización. La técnica permite ahorrar tiempo en la selección de modelos, usando validación cruzada y métricas adecuadas para evaluar el rendimiento. Se realizó una predicción para validar el modelo optimizado, destacando su eficacia en comparación con estimaciones previas.
Aquí tienen el código optimizado con más parámetros y bien explicado:import pandas as pd from sklearn.model\_selection import RandomizedSearchCV from sklearn.ensemble import RandomForestRegressor if \_\_name\_\_ == "\_\_main\_\_": # Leer el dataset dataset = pd.read\_csv('./data/felicidad.csv') # Imprimir el dataset para verificar la carga print(dataset) # Seleccionar características (X) y etiquetas (y) X = dataset.drop(\['country', 'rank', 'score'], axis=1) y = dataset\['score'] # Inicializar el regresor RandomForestRegressor reg = RandomForestRegressor() # Definir los parámetros para la búsqueda aleatoria parametros = { # Número de árboles en el bosque 'n\_estimators': range(4, 16), # Criterio utilizado para medir la calidad de una división 'criterion': \['mse', 'mae'], # 'mse': error cuadrático medio, 'mae': error absoluto medio # Profundidad máxima de los árboles en el bosque 'max\_depth': range(2, 11), # Número mínimo de muestras requeridas para dividir un nodo interno 'min\_samples\_split': range(2, 10), # Número mínimo de muestras requeridas para estar en un nodo hoja 'min\_samples\_leaf': range(1, 10), # Método para la selección de características en cada split 'max\_features': \['auto', 'sqrt', 'log2', None], # 'auto': sqrt(num\_features), 'sqrt': sqrt(num\_features), 'log2': log2(num\_features), None: num\_features # Bootstrap muestras al construir árboles 'bootstrap': \[True, False], # True: usar bootstrap samples, False: usar el dataset completo # Método para la selección de muestras cuando se construyen los árboles 'oob\_score': \[True, False], # True: permitir out-of-bag estimation, False: no permitir out-of-bag estimation # Criterio utilizado para elegir los nodos en el crecimiento del árbol 'splitter': \['best', 'random'] # 'best': el mejor split, 'random': el mejor split aleatorio } # Realizar la búsqueda aleatoria de hiperparámetros rand\_est = RandomizedSearchCV(reg, parametros, n\_iter=10, cv=3, scoring='neg\_mean\_absolute\_error').fit(X, y) # Imprimir el mejor estimador encontrado print("Mejor estimador:") print(rand\_est.best\_estimator\_) # Imprimir los mejores parámetros encontrados print("Mejores parámetros:") print(rand\_est.best\_params\_) # Realizar una predicción utilizando el mejor modelo encontrado print("Predicción para el primer ejemplo del dataset:") print(rand\_est.predict(X.loc\[\[0]])) ```python import pandas as pd from sklearn.model_selection import RandomizedSearchCV from sklearn.ensemble import RandomForestRegressor if __name__ == "__main__": # Leer el dataset dataset = pd.read_csv('./data/felicidad.csv') # Imprimir el dataset para verificar la carga print(dataset) # Seleccionar características (X) y etiquetas (y) X = dataset.drop(['country', 'rank', 'score'], axis=1) y = dataset['score'] # Inicializar el regresor RandomForestRegressor reg = RandomForestRegressor() # Definir los parámetros para la búsqueda aleatoria parametros = { # Número de árboles en el bosque 'n_estimators': range(4, 16), # Criterio utilizado para medir la calidad de una división 'criterion': ['mse', 'mae'], # 'mse': error cuadrático medio, 'mae': error absoluto medio # Profundidad máxima de los árboles en el bosque 'max_depth': range(2, 11), # Número mínimo de muestras requeridas para dividir un nodo interno 'min_samples_split': range(2, 10), # Número mínimo de muestras requeridas para estar en un nodo hoja 'min_samples_leaf': range(1, 10), # Método para la selección de características en cada split 'max_features': ['auto', 'sqrt', 'log2', None], # 'auto': sqrt(num_features), 'sqrt': sqrt(num_features), 'log2': log2(num_features), None: num_features # Bootstrap muestras al construir árboles 'bootstrap': [True, False], # True: usar bootstrap samples, False: usar el dataset completo # Método para la selección de muestras cuando se construyen los árboles 'oob_score': [True, False], # True: permitir out-of-bag estimation, False: no permitir out-of-bag estimation # Criterio utilizado para elegir los nodos en el crecimiento del árbol 'splitter': ['best', 'random'] # 'best': el mejor split, 'random': el mejor split aleatorio } # Realizar la búsqueda aleatoria de hiperparámetros rand_est = RandomizedSearchCV(reg, parametros, n_iter=10, cv=3, scoring='neg_mean_absolute_error').fit(X, y) # Imprimir el mejor estimador encontrado print("Mejor estimador:") print(rand_est.best_estimator_) # Imprimir los mejores parámetros encontrados print("Mejores parámetros:") print(rand_est.best_params_) # Realizar una predicción utilizando el mejor modelo encontrado print("Predicción para el primer ejemplo del dataset:") print(rand_est.predict(X.loc[[0]])) ```
Que tal, Respecto a `max_depht`. Me sirvió entenderlo mejor con las siguientes analogías para no confundirlo con otros parámetros: **Qué no hace max depht?** * *"Qué tan grande será el árbol y cuántas ramas tendrá"*: Esto más bien **se refiere al número total de nodos en un árbol**. Lo cuál se relaciona otros parámetros como: `min_samples_split` y `min_samples_leaf.` max\_depth no controla directamente el número total de nodos o ramas en el árbol, sino más bien la profundidad máxima desde la raíz hasta una hoja. **Qué sí hace max depht ?** * *"Qué tan grandes son las ramas de los árboles y la cantidad de ramas chiquitas en su composición"*: Influye directamente en la longitud y estructura de las ramas del árbol, o sea: **cuántas divisiones se realizan antes de llegar a una hoja**. Un valor mayor permite que las ramas del árbol sean más largas, más subdivisiones y nodos internos Fun fact: al limitar la profundidad del árbol, ayuda a prevenir el overfitting. Generalizando mejor los datos no vistos.

Estos fueron mis resultados ! 😄

RandomForestRegressor(criterion='absolute_error', max_depth=10, n_estimators=4)
{'n_estimators': 4, 'max_depth': 10, 'criterion': 'absolute_error'}
[7.53325009]

RandomizedSearchCV es una técnica de búsqueda de hiperparámetros que realiza una búsqueda aleatoria en lugar de una búsqueda exhaustiva como GridSearchCV. Esto es útil cuando tienes una gran cantidad de posibles combinaciones de hiperparámetros y deseas encontrar una configuración de hiperparámetros óptima de manera más eficiente.

Si algunx tiene problemas para instalar auto-sklearn desde ubuntu o no tiene un sistema linux en deepnote se puede usar, solo hay que intalarlo con:

!pip install auto-sklearn

En la parte del código de los parámetros se debe reemplazar por este código, ya que los parámetros de criterion están descontinuados y sale error.

parametros = {
        'n_estimators' : range(4,16),
        'criterion' : ['poisson', 'friedman_mse', 'absolute_error', 'squared_error'],
        'max_depth' : range(2,11)
    }

Para evitar ciertos warnings en Jupyter Notebooks:

parametros = {
        'n_estimators' : range(4,16),
        'criterion' : ['squared_error', 'absolute_error'],
        'max_depth' : range(2,11)

Si en la actualidad les figura este error :
FutureWarning: Criterion ‘mae’ was deprecated in v1.0 and will be removed in version 1.2. Use criterion='absolute_error' which is equivalent.

les dejo lo que a mi me lo soluciono:

import pandas as pd

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestRegressor

if name == “main”:

dataset = pd.read_csv('../Data/felicidad.csv')

print(dataset)

X = dataset.drop(['country', 'rank', 'score'], axis=1)
y = dataset['score']

reg = RandomForestRegressor()

parametros = {
    'n_estimators' : range(4,16),
    'criterion' : ["absolute_error"],
    'max_depth' : range(2,11),
}

rand_est = RandomizedSearchCV(reg, parametros , n_iter=10, cv=3, scoring='neg_mean_absolute_error').fit(X,y)

print(rand_est.best_estimator_)

print(rand_est.best_params_)

print(rand_est.predict(X.loc[[0]]))

#implmentacion_randomizedSearchCV

import pandas as pd
from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestRegressor

dataset = pd.read_csv(‘felicidad.csv’)
X = dataset.drop([‘country’, ‘score’,‘rank’], axis=1)
y = dataset[‘score’]

modelo = RandomForestRegressor()

parametros = {
‘n_estimators’: range(4,15), #busque entre 4 y 15 arboles
’criterion’: [‘mse’,‘mae’],
‘max_depth’: range(2,11) #que tan profundo el arbol
}

#estimador 10 iteraciones maximo y divida en 3 grupos
#3 = 2 de training y 1 de test
#scoring = con que deseamos medir
rand_est = RandomizedSearchCV(modelo,parametros,n_iter=10, cv=3, scoring=‘neg_mean_absolute_error’).fit(X,y)

print("")
print("Mejores criterios a usar son ",rand_est.best_estimator_)
print("Mejores parametros a usar son ", rand_est.best_params_)
print(“Prediccion al primer pais [0] es “,rand_est.predict(X.loc[[0]]))
print(””)

OUTPUT:
Mejores criterios a usar son RandomForestRegressor(criterion=‘mae’, max_depth=5, n_estimators=4)
Mejores parametros a usar son {‘n_estimators’: 4, ‘max_depth’: 5, ‘criterion’: ‘mae’}
Prediccion al primer pais [0] es [7.51200008]

Mis resultados

{'criterion': 'mse', 'max_depth': 10, 'n_estimators': 6}

print('Predict: ', rand_est.predict(X.loc[[0]]))
print('Real: ', str(y[0]))

Predict:  [7.53700018]
Real:  7.537000179

Super acertado 🤩

Mis resultados:

================================================================
Best estimator: RandomForestRegressor(criterion='mae', max_depth=7, n_estimators=12)
================================================================
Best params: {'n_estimators': 12, 'max_depth': 7, 'criterion': 'mae'}
================================================================
predict: [7.50891674]