Machine Learning con Scikit Learn

Por Jose R. Zapata

Ultima actualizacion: 2/Nov/2024

Scikit-learn es una biblioteca de código abierto de Python que implementa una gran variedad de algoritmos de aprendizaje automático, Preprocesamiento, validación cruzada y visualización.

Instalación

pip install scikit-learn

import sklearn
print(f"Sklearn version: {sklearn.__version__}")

'Sklearn version: 1.5.2'

Proceso de un Proyecto de Machine Learning

En este link encuentran un listado de los pasos a realizar en un proyecto de machine Learning:

https://medium.com/@joserzapata/paso-a-paso-en-un-proyecto-machine-learning-bcdd0939d387

• 1. Definir el problema y mirar el panorama general.
• 2. Obténer los datos
• 3. Explorar los datos para obtener información.
• 4. Preparación de los datos.
• 5. Exploración y selección de modelos
• 6. Afinar los modelos.
• 7. Interpretabilidad del modelo.
• 8. Presentacion de la solución.
• 9. Desplegar, monitorear y mantener el sistema.

Pasos para la construccion y seleccion de un Modelo de Machine Learning

1. Preparacion de los datos
2. Division de los datos entre datos de Entrenamiento (Para seleccionar el modelo, 80%) y datos de Test (para probar el modelo final, 20%)
3. Se selecciona la medida de Evaluacion segun la aplicacion
4. Usando solo los datos de Entrenamiento se selecciona los mejores modelos utilizando cross validation y comparando sus resultados
5. Se toman los mejores modelos (1, 2 o 3 dependiendo de su rendimiento) y se ajustan los Hiper Parametros
6. Se toman los parametros del mejor modelo y se entrena con todos los datos de Entrenamiento y se evalua su rendimiento con los datos de TEST
7. Si hay un buen resultado se pasa a la etapa de Implementacion (Deployment), en caso contrario segun sea el problema, se prueba con otros modelos o se devuelve a la etapa de Feature Engineering.

Ejemplo de clasificacion Completo con un modelo

Ejemplo de pasos completo usando Scikit learn con un solo modelo

• Division de datos
• Preprocesamiento
• Cross-validation
• Evaluacion
• Hiperparametrizacion
• Entrenamiento final

en estos pasos falta el proceso de seleccion de modelo (escoger un modelo entre varias opciones de algoritmos)

import pandas as pd
from sklearn.datasets import fetch_openml

# Download the iris dataset from openml.org
iris = fetch_openml(name='iris', version=1, parser='auto')

# Convert the iris dataset to a pandas DataFrame
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
iris_df['species'] = iris.target
iris_df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):
 #   Column       Non-Null Count  Dtype
---  ------       --------------  -----
 0   sepallength  150 non-null    float64
 1   sepalwidth   150 non-null    float64
 2   petallength  150 non-null    float64
 3   petalwidth   150 non-null    float64
 4   species      150 non-null    category
dtypes: category(1), float64(4)
memory usage: 5.1 KB

iris_df.sample(5)

Importar librerias Machine Learning

## Importar Librerias
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.pipeline import Pipeline
from sklearn import set_config

from sklearn.decomposition import PCA

from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_validate
from sklearn.model_selection import KFold

from sklearn.metrics import accuracy_score

from sklearn.ensemble import RandomForestClassifier

Encode Columna Target

le = LabelEncoder()
iris_df['target'] = le.fit_transform(iris_df['species'])
le.classes_

array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object)

le.transform(le.classes_)

array([0, 1, 2])

le_name_mapping = dict(zip(le.classes_, le.transform(le.classes_)))
print(le_name_mapping)

{'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}

iris_df.sample(5)

iris_df.drop(['species'], axis=1, inplace=True)
iris_df.sample(5)

Eliminar datos Duplicados exactos del dataset

iris_df = iris_df.drop_duplicates()

Division datos de entrenamiento y test

## X es igual a todo el dataframe menos la
## la columna de salida

X_data = iris_df.drop(columns=['target'])
y_target = iris_df['target']



## Division del dataset en datos de entrenamiento y de prueba
## datos stratificados bassados en la columna y
X_train, X_test, y_train, y_test = train_test_split(X_data, y_target,
                                                    test_size=0.2,
                                                    stratify=y_target,
                                                    random_state=42)

Eliminar datos duplicados del dataset

Este paso es necesario si el numero de columnas que se van a usar son menos que las que tiene el dataset inicialmente, ya que pueden quedar filas duplicadas por este motivo.

# en este ejemplo se van a usar exactamente las mismas columnas,
# entonces el siguiente procedimiento no es necesario
# pero se deja como ejemplo de como se puede hacer
features = ['sepallength', 'sepalwidth', 'petallength', 'petalwidth']

# Eliminar duplicados datos de entrenamiento
X = pd.concat([X_train[features], y_train], axis='columns')
X = X.drop_duplicates()
X_train = X.drop(columns=['target'])
y_train = X['target']

# Eliminar duplicados datos de test
y = pd.concat([X_test[features], y_test], axis='columns')
y = y.drop_duplicates()
X_test = y.drop(columns=['target'])
y_test = y['target']

Pipeline Procesamiento de datos

El Feature Engineering se debe realizar como un proceso iterativo, donde se prueba el modelo y se vuelve a la etapa de Feature Engineering para mejorar el modelo.

pipeline_data = Pipeline([
    ('scaler3', StandardScaler()),
    ('pca3', PCA(n_components=3))
])

Modelo

model_rf = RandomForestClassifier()

Pipeline transformacion y modelo

pipeline_transform_model = Pipeline([
    ('pipeline_datos', pipeline_data),
    ('modelo', model_rf)
])

# Visualizar el pipeline
set_config(display="diagram")
pipeline_transform_model

Pipeline(steps=[('pipeline_datos',
                 Pipeline(steps=[('scaler3', StandardScaler()),
                                 ('pca3', PCA(n_components=3))])),
                ('modelo', RandomForestClassifier())])

Pipeline(steps=[('pipeline_datos',
                 Pipeline(steps=[('scaler3', StandardScaler()),
                                 ('pca3', PCA(n_components=3))])),
                ('modelo', RandomForestClassifier())])

Pipeline(steps=[('scaler3', StandardScaler()), ('pca3', PCA(n_components=3))])

StandardScaler()

PCA(n_components=3)

RandomForestClassifier()

Cross validation

scoring = 'accuracy'
kfold = KFold(n_splits=5)
cv_results = cross_validate(pipeline_transform_model,
                            X_train,
                            y_train,
                            cv=kfold,
                            scoring=scoring)
print(f"Resultado Promedio = {cv_results['test_score'].mean()}")
print(f"Resultado STD = {cv_results['test_score'].std()}")

Resultado Promedio = 0.9148550724637682
Resultado STD = 0.060757315409433583

Hiperparametrizacion

from sklearn.model_selection import GridSearchCV
# hiperparametros especificos del modelo random forest classifier
param_grid = {
    'modelo__n_estimators': [100, 200, 500],
    'modelo__max_depth': [3, 5, 10, None],
    'modelo__max_features': ['sqrt', 'log2', None]
}

grid_search = GridSearchCV(pipeline_transform_model,
                           param_grid=param_grid,
                           cv=kfold)
grid_search.fit(X_data,y_target)

GridSearchCV(cv=KFold(n_splits=5, random_state=None, shuffle=False),
             estimator=Pipeline(steps=[('pipeline_datos',
                                        Pipeline(steps=[('scaler3',
                                                         StandardScaler()),
                                                        ('pca3',
                                                         PCA(n_components=3))])),
                                       ('modelo', RandomForestClassifier())]),
             param_grid={'modelo__max_depth': [3, 5, 10, None],
                         'modelo__max_features': ['sqrt', 'log2', None],
                         'modelo__n_estimators': [100, 200, 500]})

GridSearchCV(cv=KFold(n_splits=5, random_state=None, shuffle=False),
             estimator=Pipeline(steps=[('pipeline_datos',
                                        Pipeline(steps=[('scaler3',
                                                         StandardScaler()),
                                                        ('pca3',
                                                         PCA(n_components=3))])),
                                       ('modelo', RandomForestClassifier())]),
             param_grid={'modelo__max_depth': [3, 5, 10, None],
                         'modelo__max_features': ['sqrt', 'log2', None],
                         'modelo__n_estimators': [100, 200, 500]})

Pipeline(steps=[('pipeline_datos',
                 Pipeline(steps=[('scaler3', StandardScaler()),
                                 ('pca3', PCA(n_components=3))])),
                ('modelo', RandomForestClassifier())])

Pipeline(steps=[('scaler3', StandardScaler()), ('pca3', PCA(n_components=3))])

StandardScaler()

PCA(n_components=3)

RandomForestClassifier()

# mejor parametros
grid_search.best_params_

{'modelo__max_depth': 5,
 'modelo__max_features': None,
 'modelo__n_estimators': 200}

print(f'Mejor Resultado = {grid_search.best_score_}')
print(f"Resultado STD = {grid_search.cv_results_['std_test_score'][grid_search.best_index_]}")

Mejor Resultado = 0.8965517241379309
Resultado STD = 0.10229239292545743

Evaluacion de los mejores hiperparametros contra Test

# entrenar modelo
mejor_transform_modelo = pipeline_transform_model.set_params(**grid_search.best_params_)
mejor_transform_modelo.fit(X_train,y_train)

#prediccion de los datos de prueba
y_pred = mejor_transform_modelo.predict(X_test)

# Evaluacion
accuracy_score(y_test, y_pred)

0.9

Modelo Final

modelo_final = pipeline_transform_model.set_params(**grid_search.best_params_)
modelo_final.fit(X_data,y_target)

#accuracy final
# Evaluacion
accuracy_score(y_target, modelo_final.predict(X_data))

1.0

Almacenar modelo Final

from joblib import dump # libreria de serializacion

# grabar el pipeline del transformador y modelo en un archivo
dump(pipeline_transform_model, 'pipeline_transform_model.joblib')

['pipeline_transform_model.joblib']

Cargar modelo Final y hacer predicciones

from joblib import load # libreria de deserializacion

# cargar el pipeline del transformador y modelo desde un archivo
pipeline_transform_model = load('pipeline_transform_model.joblib')

# prediccion con un solo dato
# información del label encoder {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}
pred_unico = pipeline_transform_model.predict([[5.1, 3.5, 1.4, 0.2]])
pred_unico

/Users/jzapata/Sites/JoseRZapata.github.io/.venv/lib/python3.9/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but StandardScaler was fitted with feature names
  warnings.warn(





array([0])

# información del label encoder {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}
pred_varios = pipeline_transform_model.predict(X_test)
pred_varios

array([1, 1, 2, 0, 2, 1, 1, 0, 2, 2, 0, 0, 0, 1, 2, 0, 1, 0, 2, 0, 1, 2,
       0, 0, 1, 1, 2, 2, 2, 1])

Data Leakage

Datos Duplicados

Transformador vs Estimador

Un transformador en scikit-learn es una clase que se utiliza para preprocesar o transformar los datos de entrada. Su función principal es aplicar una serie de operaciones o manipulaciones a los datos sin alterar su estructura subyacente. Los transformadores son especialmente útiles para realizar tareas como normalización, codificación de variables categóricas, selección de características y extracción de características. Estos transformadores se ajustan a los datos de entrenamiento y luego se pueden utilizar para transformar los datos de prueba o nuevos datos de entrada de manera coherente.

Por otro lado, un estimador en scikit-learn se utiliza para aprender a partir de los datos y hacer predicciones o inferencias. Representa un modelo que puede aprender patrones y relaciones en los datos de entrenamiento y utilizar ese conocimiento para hacer predicciones sobre nuevos datos. Los estimadores incluyen algoritmos como regresión lineal, clasificación de vectores de soporte (SVM), árboles de decisión y muchos otros. Estos estimadores se ajustan a los datos de entrenamiento utilizando un método llamado “fit” y luego pueden hacer predicciones utilizando el método “predict”.

En resumen, los transformadores se utilizan para preprocesar y transformar los datos, mientras que los estimadores se utilizan para aprender a partir de los datos y hacer predicciones. Estos dos componentes trabajan juntos en scikit-learn para construir modelos de aprendizaje automático y aplicarlos a diferentes problemas y conjuntos de datos.

Un Ejemplo comparativo

Preprocesamiento de Datos

https://scikit-learn.org/stable/modules/preprocessing.html

Aquí tienes la tabla completa con los métodos de preprocesamiento, sus descripciones en español, importaciones y código asociado:

Entre los métodos mencionados, algunos de los más utilizados son:

1. StandardScaler: Se utiliza ampliamente para estandarizar características eliminando la media y escalando a varianza unitaria. Es especialmente útil en algoritmos sensibles a la escala de características, como la regresión lineal y los algoritmos basados en la distancia, como el K-means.

2. MinMaxScaler: Es comúnmente utilizado para transformar características escalándolas a un rango específico, generalmente entre 0 y 1. Esto es útil cuando se desea preservar la forma relativa de la distribución original de los datos y cuando se utilizan algoritmos sensibles a la escala.

3. OneHotEncoder: Se utiliza en el procesamiento de características categóricas para codificarlas como una matriz numérica “one-hot”. Esencialmente, crea una columna separada para cada categoría posible y asigna valores binarios (1 o 0) para indicar la presencia o ausencia de una categoría.

4. LabelEncoder: Es utilizado para codificar etiquetas categóricas en valores numéricos enteros. Esto es especialmente útil cuando se trabaja con algoritmos que requieren etiquetas numéricas en lugar de categóricas, como algunos algoritmos de clasificación.

5. Scale: Se utiliza para estandarizar un conjunto de datos a lo largo de cualquier eje. Aplica una transformación que centra los datos en cero y los escala dividiéndolos por la desviación estándar.

6. Normalize: Se utiliza para escalar vectores de entrada individualmente a una norma unitaria (longitud del vector). Esto puede ser útil cuando se trabaja con algoritmos basados en la distancia.

7. OrdinalEncoder: Se utiliza para codificar características categóricas como una matriz entera. Asigna un número entero único a cada categoría, permitiendo que el algoritmo interprete las relaciones de orden entre las categorías.

La selección de los métodos de preprocesamiento dependerá del tipo de datos, el problema específico y los requisitos del modelo que se va a usar. Siempre es importante evaluar y experimentar con diferentes métodos para determinar cuáles son los más adecuados para tu caso particular.

Ejemplo de un preprocesamiento de datos que se pueden hacer con scikit-learn

Ejemplo de Standardizacion

from sklearn.preprocessing import StandardScaler

# Se entrena el transformador con los datos de entrenamiento
scaler = StandardScaler().fit(X_train)

# Se transforman los datos de entrenamiento
standardized_X = scaler.transform(X_train)

 # Se transforman los datos de prueba con el transformador entrenado con los datos de entrenamiento
standardized_X_test = scaler.transform(X_test)

El mismo resultado usando .fit_transform()

from sklearn.preprocessing import StandardScaler

# Se instancia el transformador
scaler = StandardScaler()

# Se aprende y se transforman los datos de entrenamiento
standardized_X = scaler.fit_transform(X_train)

 # Se transforman los datos de prueba con el transformador entrenado con los datos de entrenamiento
standardized_X_test = scaler.transform(X_test)

Entrenamiento de Modelos

Ejemplos de algunos modelos supervizados y no supervizados

Regresion

Regresion con Ensambles

Ejemplo para importar Random Forest

from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(n_estimators = 10, random_state = 0) # los parametros son opcionales

Clasificacion

Clasificacion con Ensambles

Ejemplo para importar Clasificador Random Forest

from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0) # los parametros son opcionales

Clustering

Reduccion de Dimensionalidad

Evaluacion de los Modelos

Metricas de Regresion

https://scikit-learn.org/stable/modules/model_evaluation.html#regression-metrics

Metricas de Clasificacion

https://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics

Metricas de Clustering

https://scikit-learn.org/stable/modules/model_evaluation.html#clustering-metrics

Seleccion de Modelos

Division datos de Entrenamiento y Prueba

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=0)

Cross-Validation

https://scikit-learn.org/stable/modules/cross_validation.html

La validación cruzada (cross-validation en inglés) es una técnica utilizada en aprendizaje automático para evaluar el rendimiento de un modelo en un conjunto de datos. Consiste en dividir el conjunto de datos en varios subconjuntos llamados pliegues (folds) y realizar múltiples iteraciones de entrenamiento y evaluación. En cada iteración, se entrena el modelo en una combinación de pliegues y se evalúa en el pliegue restante. Luego, se promedian las métricas de evaluación obtenidas en todas las iteraciones para obtener una estimación más confiable del rendimiento del modelo. La validación cruzada es especialmente útil cuando se dispone de un conjunto de datos limitado, ya que permite utilizar todos los datos tanto para el entrenamiento como para la evaluación, evitando así una evaluación sesgada del modelo.

knn = KNeighborsClassifier(n_neighbors=8)

scores = cross_val_score(knn, X_train, y_train, cv=5, scoring='accuracy')

Sintonizacion del Modelo (Hyper - parametrizacion)

https://scikit-learn.org/stable/modules/grid_search.html4

El ajuste de hiperparámetros, o hiperparameter tuning en inglés, se refiere al proceso de encontrar la combinación óptima de hiperparámetros para un modelo de aprendizaje automático. Los hiperparámetros son configuraciones externas al modelo que afectan su rendimiento, como la tasa de aprendizaje, el número de árboles en un bosque aleatorio o el valor de regularización. El ajuste de hiperparámetros implica probar diferentes combinaciones de estos valores y evaluar el rendimiento del modelo utilizando técnicas como la validación cruzada. El objetivo es encontrar la configuración de hiperparámetros que produzca el mejor rendimiento y generalización del modelo en datos no vistos, optimizando así su capacidad de predicción y ajuste al problema específico.

Grid Search

from sklearn.model_selection import GridSearchCV
params = {"n_neighbors": np.arange(1,3),
          "metric": ["euclidean", "cityblock"]}

grid = GridSearchCV(estimator=knn,
                    param_grid=params)# 5 CV
grid.fit(X_train, y_train)
print(grid.best_score_)
print(grid.best_estimator_.n_neighbors)

Optimizacion Aleatoria de hiper Parametros

# Ejemplo
from sklearn.model_selection import RandomizedSearchCV
params = {"n_neighbors": range(1,5), "weights": ["uniform", "distance"]}

rsearch = RandomizedSearchCV(estimator=knn,
           param_distributions=params,
           cv=4,
           n_iter=8,
           random_state=5)
rsearch.fit(X_train, y_train)
print(rsearch.best_score_)
print(rsearch.best_params_)

knn = neighbors.KNeighborsClassifier(n_neighbors=2, weights = "uniform")
knn.fit(X_train, y_train)

Librerias de Machine Learning en Python

Algunas de las librerias mas utilizadas en Python son:

• scikit-learn https://scikit-learn.org/stable/
• catboost https://catboost.ai/
• xgboost https://xgboost.readthedocs.io/en/latest/
• lightgbm https://lightgbm.readthedocs.io/en/latest/
• Local Cascade Ensemble (LCE) https://pypi.org/project/lcensemble/

Referencias

• Cheatsheet scikit-learn https://images.datacamp.com/image/upload/v1676302389/Marketing/Blog/Scikit-Learn_Cheat_Sheet.pdf
• Errores Comunes y recomendaciones
• Metricas de Regresion
• Metricas de Clasificacion
• Metricas de Clustering
• Conceptos de machine learning Visuales
• Machine learning con Python y Scikit-learn - Joaquín Amat Rodrigo

Phd. Jose R. Zapata

• https://joserzapata.github.io/
• https://www.linkedin.com/in/jose-ricardo-zapata-gonzalez/