Machine Learning con Scikit Learn

Por Jose R. Zapata

Ultima actualizacion: 11/Nov/2023

Invitame a un Cafe

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

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

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

Construir Modelo

  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

En este Ejemplo se asume que los datos ya estan limpios de:

  • Valores nulos o faltantes
  • Las columnas estan en el formato correcto (numericos, categoricos, etc)
  • No hay valores atipicos (outliers)
  • No hay valores duplicados

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)

sepallengthsepalwidthpetallengthpetalwidthspecies
1046.53.05.82.2Iris-virginica
1126.83.05.52.1Iris-virginica
205.43.41.70.2Iris-setosa
1366.33.45.62.4Iris-virginica
756.63.04.41.4Iris-versicolor

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)

sepallengthsepalwidthpetallengthpetalwidthspeciestarget
726.32.54.91.5Iris-versicolor1
805.52.43.81.1Iris-versicolor1
1097.23.66.12.5Iris-virginica2
285.23.41.40.2Iris-setosa0
795.72.63.51.0Iris-versicolor1
iris_df.drop(['species'], axis=1, inplace=True)
iris_df.sample(5)

sepallengthsepalwidthpetallengthpetalwidthtarget
374.93.11.50.10
294.73.21.60.20
825.82.73.91.21
134.33.01.10.10
1064.92.54.51.72

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())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

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]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# 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
# informacion 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])
# informacion 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

Problemas de Data Leakage

la “fuga de datos” o " data leakage" en estadística y aprendizaje automático se produce cuando se utiliza información que no estaría disponible al momento de hacer una predicción. Esto puede hacer que el modelo parezca más preciso de lo que realmente es, lo que podría llevar a errores y selección de modelos subóptimos. Es difícil detectar y evitar la fuga de datos, y es importante utilizar sólo la información que estaría disponible al momento de hacer una predicción en la vida real para evitar este problema.

Referencias: https://machinelearningmastery.com/data-preparation-without-data-leakage/

https://scikit-learn.org/stable/common_pitfalls.html

https://towardsdatascience.com/five-hidden-causes-of-data-leakage-you-should-be-aware-of-e44df654f185

Datos Duplicados

Problemas de Datos duplicados

La presencia de datos duplicados en un conjunto de datos de entrenamiento (train) y prueba (test) en el aprendizaje automático puede tener varios efectos negativos, como los siguientes:

  1. Sesgo en la evaluación del modelo: Si los datos duplicados están presentes en ambos conjuntos de datos (entrenamiento y prueba), entonces el modelo podría haber memorizado esos datos y tener un desempeño mejor de lo que sería en realidad. Esto se debe a que el modelo ya ha visto esos datos durante el entrenamiento y, por lo tanto, puede sobreajustarse a ellos, lo que llevaría a una evaluación sesgada de su rendimiento.

  2. Disminución de la generalización: La presencia de datos duplicados en el conjunto de entrenamiento puede reducir la capacidad del modelo para generalizar y aprender patrones verdaderamente útiles en los datos. Esto se debe a que el modelo puede centrarse demasiado en los datos duplicados y no aprender de manera efectiva de la diversidad de los datos.

  3. Reducción de la eficiencia del entrenamiento: Si hay muchos datos duplicados en el conjunto de entrenamiento, el modelo tendrá que procesarlos varias veces, lo que puede aumentar el tiempo y los recursos necesarios para entrenar el modelo. Esto puede ser especialmente problemático si el conjunto de datos es grande y los datos duplicados son muchos.

  4. Pérdida de confiabilidad en la evaluación: Si el conjunto de prueba contiene datos duplicados, esto puede hacer que la evaluación del modelo sea menos confiable, ya que los resultados de la evaluación pueden depender en gran medida de los datos duplicados. Si hay muchos datos duplicados con buen desempeño en el conjunto de prueba, las metricas de evaluacion del modelo pueden ser demasiado optimistas y si hay muchos datos duplicados con mal desempeño en el conjunto de prueba, las metricas de evaluacion del modelo pueden ser demasiado pesimistas.

En resumen, la presencia de datos duplicados en los conjuntos de datos de entrenamiento y prueba puede afectar negativamente el desempeño del modelo, su capacidad para generalizar y la eficiencia del entrenamiento. Por lo tanto, es importante prestar atención a la limpieza de datos y evitar duplicados.

Referencias:

https://www.kaggle.com/questions-and-answers/200598

https://stats.stackexchange.com/questions/428191/should-i-remove-duplicates-from-my-dataset-for-my-machine-learning-problem


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.

TransformadoresEstimadores
Preprocesamiento de datosModelado y predicción de datos
.fit(X) aprende de los datos para transformarlos.fit(X, y) Aprende de los datos para hacer predicciones
.transform(X) transforma los datos.predict(X) Realiza predicciones
Ej:Normalizar características antes de entrenar un modeloEj: Entrenar un modelo de arboles de decision

Un Ejemplo comparativo

TransformadoresEstimadores
StandardScalerLogisticRegression
.fit(X) calcula el promedio, la desviacion standard de la columna.fit(X, y) Aprende los coeficientes de la formula de la regresion logistica
.transform(X) substrae el promedio y luego divide por la desviacion Standard.predict(X) Hace predicciones de las clases entrenadas

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:

MétodoDescripciónImportacionCodigo
BinarizerBinaria los datos (establece los valores de características en 0 o 1) según un umbral.from sklearn.preprocessing import Binarizerbinarizer = Binarizer(threshold=0.5)
FunctionTransformerConstruye un transformador a partir de una función arbitraria.from sklearn.preprocessing import FunctionTransformertransformer = FunctionTransformer(func=my_function)
KBinsDiscretizerDivide los datos continuos en intervalos (bins).from sklearn.preprocessing import KBinsDiscretizerdiscretizer = KBinsDiscretizer(n_bins=3, strategy='uniform')
KernelCentererCentra una matriz de kernel arbitraria.from sklearn.preprocessing import KernelCenterercenterer = KernelCenterer()
LabelBinarizerBinariza las etiquetas en un enfoque uno-contra-todos.from sklearn.preprocessing import LabelBinarizerbinarizer = LabelBinarizer()
LabelEncoderCodifica las etiquetas de destino con valores entre 0 y n_classes-1.from sklearn.preprocessing import LabelEncoderencoder = LabelEncoder()
MultiLabelBinarizerTransforma entre un conjunto iterable de conjuntos iterables y un formato de etiquetas múltiples.from sklearn.preprocessing import MultiLabelBinarizerbinarizer = MultiLabelBinarizer()
MaxAbsScalerEscala cada característica por su valor absoluto máximo.from sklearn.preprocessing import MaxAbsScalerscaler = MaxAbsScaler()
MinMaxScalerTransforma las características escalando cada una al rango dado.from sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler(feature_range=(0, 1))
NormalizerNormaliza las muestras individualmente a una norma unitaria.from sklearn.preprocessing import Normalizernormalizer = Normalizer(norm='l2')
OneHotEncoderCodifica características categóricas como una matriz numérica one-hot.from sklearn.preprocessing import OneHotEncoderencoder = OneHotEncoder()
OrdinalEncoderCodifica características categóricas como una matriz entera.from sklearn.preprocessing import OrdinalEncoderencoder = OrdinalEncoder()
PolynomialFeaturesGenera características polinómicas e interacciones.from sklearn.preprocessing import PolynomialFeaturestransformer = PolynomialFeatures(degree=2)
PowerTransformerAplica una transformación de potencia a las características para que los datos se asemejen más a una distribución gaussiana.from sklearn.preprocessing import PowerTransformertransformer = PowerTransformer(method='yeo-johnson')
QuantileTransformerTransforma las características utilizando información de cuantiles.from sklearn.preprocessing import QuantileTransformertransformer = QuantileTransformer(n_quantiles=100)
RobustScalerEscala las características utilizando estadísticas que son robustas a los valores atípicos.from sklearn.preprocessing import RobustScalerscaler = RobustScaler()
SplineTransformerGenera bases de splines univariadas para características.from sklearn.preprocessing import SplineTransformertransformer = SplineTransformer(n_knots=5, degree=3)
StandardScalerEstandariza las características eliminando la media y escalando a varianza unitaria.from sklearn.preprocessing import StandardScalerscaler = StandardScaler()
add_dummy_featureAumenta el conjunto de datos con una característica ficticia adicional.from sklearn.preprocessing import add_dummy_featureX_new = add_dummy_feature(X)
binarizeRealiza una binarización booleana de una matriz o matriz dispersa de tipo array-like.from sklearn.preprocessing import binarizeX_bin = binarize(X, threshold=0.5)
label_binarizeBinariza las etiquetas en un enfoque uno-contra-todos.from sklearn.preprocessing import label_binarizey_bin = label_binarize(y, classes=[0, 1, 2])
maxabs_scaleEscala cada característica al rango [-1, 1] sin romper la dispersión.from sklearn.preprocessing import maxabs_scaleX_scaled = maxabs_scale(X)
minmax_scaleTransforma las características escalando cada una al rango dado.from sklearn.preprocessing import minmax_scaleX_scaled = minmax_scale(X, feature_range=(0, 1))
normalizeEscala vectores de entrada individualmente a una norma unitaria (longitud del vector).from sklearn.preprocessing import normalizeX_normalized = normalize(X, norm='l2')
quantile_transformTransforma las características utilizando información de cuantiles.from sklearn.preprocessing import quantile_transformX_transformed = quantile_transform(X, n_quantiles=100)
robust_scaleEstandariza un conjunto de datos a lo largo de cualquier eje, utilizando estadísticas que son robustas a los valores atípicos.from sklearn.preprocessing import robust_scaleX_scaled = robust_scale(X)
scaleEstandariza un conjunto de datos a lo largo de cualquier eje.from sklearn.preprocessing import scaleX_scaled = scale(X)
power_transformTransformación paramétrica y monótona para que los datos se asemejen más a una distribución gaussiana.from sklearn.preprocessing import power_transformX_transformed = power_transform(X, method='yeo-johnson')

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

Modelo de RegresiónDescripciónImportarEjemplo de Código
Regresión LinealUn modelo que establece una relación lineal entre las características y la variable objetivo.from sklearn.linear_model import LinearRegressionmodel = LinearRegression()
Regresión RidgeUn modelo de regresión lineal que utiliza la regularización L2 para controlar la complejidad del modelo.from sklearn.linear_model import Ridgemodel = Ridge(alpha=0.5)
Regresión LassoUn modelo de regresión lineal que utiliza la regularización L1 para realizar selección de características y controlar la complejidad del modelo.from sklearn.linear_model import Lassomodel = Lasso(alpha=0.1)
Regresión ElasticNeUn modelo de regresión lineal que combina la regularización L1 y L2 para controlar la complejidad del modelo y realizar selección de características.from sklearn.linear_model import ElasticNetmodel = ElasticNet(alpha=0.5, l1_ratio=0.5)
Regresión PolinómicaUn modelo que agrega características polinómicas a la regresión lineal para capturar relaciones no lineales entre las características y la variable objetivo.from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
poly_features = PolynomialFeatures(degree=2)
X_poly = poly_features.fit_transform(X)
model = LinearRegression()
Support Vector RegressionUn modelo de regresión basado en Máquinas de Vectores de Soporte que encuentra un hiperplano óptimo para predecir los valores continuos de la variable objetivo.from sklearn.svm import SVRmodel = SVR(kernel='linear')
Redes Neuronales ArtificialesUn modelo de regresión basado en redes neuronales artificiales que utiliza capas ocultas para realizar predicciones.from sklearn.neural_network import MLPRegressormodel = MLPRegressor(hidden_layer_sizes=(100,))
Decision Tree RegressionUn modelo de regresión basado en árboles de decisión que divide el espacio de características en regiones para realizar predicciones.from sklearn.tree import DecisionTreeRegressormodel = DecisionTreeRegressor(max_depth=3)
Linear SVRUn modelo de regresión basado en Máquinas de Vectores de Soporte lineales que encuentra un hiperplano óptimo para predecir los valores continuos de la variable objetivo.from sklearn.svm import LinearSVRmodel = LinearSVR(epsilon=0.0)
Bayesian Ridge RegressionUn modelo de regresión bayesiano que utiliza la regresión lineal bayesiana para realizar predicciones.from sklearn.linear_model import BayesianRidgemodel = BayesianRidge()
K-Nearest Neighbors RegressorUn modelo de regresión basado en los vecinos más cercanos que predice el valor objetivo promediando los valores de sus vecinos más cercanos.from sklearn.neighbors import KNeighborsRegressormodel = KNeighborsRegressor(n_neighbors=5)
Gaussian Process RegressionUn modelo de regresión basado en procesos gaussianos que modela la distribución conjunta de las variables de entrada y objetivo para realizar predicciones.from sklearn.gaussian_process import GaussianProcessRegressormodel = GaussianProcessRegressor()

Regresion con Ensambles

Modelo de RegresiónDescripciónImportarEjemplo de Código
Random Forest RegressionUn modelo de regresión basado en ensamble que utiliza múltiples árboles de decisión para realizar predicciones y promediar los resultados.from sklearn.ensemble import RandomForestRegressormodel = RandomForestRegressor(n_estimators=100)
Gradient Boosting RegressionUn modelo de regresión basado en ensamble que construye los árboles de decisión de forma secuencial, corrigiendo los errores del modelo anterior para mejorar las predicciones.from sklearn.ensemble import GradientBoostingRegressormodel = GradientBoostingRegressor(n_estimators=100)
AdaBoost RegressionUn modelo de regresión basado en ensamble que ajusta varios modelos de regresión débiles secuencialmente, poniendo más énfasis en los ejemplos mal ajustados en cada iteración.from sklearn.ensemble import AdaBoostRegressormodel = AdaBoostRegressor(n_estimators=100)
Bagging RegressionUn modelo de regresión basado en ensamble que entrena varios modelos de regresión independientes en diferentes subconjuntos de los datos de entrenamiento y promedia sus predicciones.from sklearn.ensemble import BaggingRegressormodel = BaggingRegressor(n_estimators=100)
XGBoost RegressionUn modelo de regresión basado en ensamble optimizado para mejorar el rendimiento y la velocidad, utiliza el algoritmo de boosting para construir un modelo de regresión.from xgboost import XGBRegressormodel = XGBRegressor(n_estimators=100)
LightGBM RegressionUn modelo de regresión basado en ensamble optimizado para grandes conjuntos de datos y velocidad de entrenamiento rápida, utiliza el algoritmo de boosting para construir un modelo de regresión.from lightgbm import LGBMRegressormodel = LGBMRegressor(n_estimators=100)
CatBoost RegressionUn modelo de regresión basado en ensamble optimizado para conjuntos de datos con características categóricas, utiliza el algoritmo de boosting para construir un modelo de regresión.from catboost import CatBoostRegressormodel = CatBoostRegressor(n_estimators=100)
Ejemplo para importar Random Forest
from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(n_estimators = 10, random_state = 0) # los parametros son opcionales

Clasificacion

Modelo de ClasificaciónDescripciónImportarEjemplo de Código
Regresión Logística (LogisticRegression)Un modelo que utiliza la regresión logística para la clasificación binaria y multiclase.from sklearn.linear_model import LogisticRegressionmodel = LogisticRegression()
Support Vector Machines (SVC)Un modelo que utiliza Máquinas de Vectores de Soporte para la clasificación binaria y multiclase.from sklearn.svm import SVCmodel = SVC()
Naive Bayes (GaussianNB)Un modelo que utiliza el teorema de Bayes y asume una distribución gaussiana de las características para la clasificación.from sklearn.naive_bayes import GaussianNBmodel = GaussianNB()
k-Nearest Neighbors (KNeighborsClassifier)Un modelo que clasifica los puntos de datos según la mayoría de votos de sus vecinos más cercanos.from sklearn.neighbors import KNeighborsClassifiermodel = KNeighborsClassifier()
Decision Trees (DecisionTreeClassifier)Un modelo que utiliza árboles de decisión para la clasificación binaria y multiclase.from sklearn.tree import DecisionTreeClassifiermodel = DecisionTreeClassifier()
Perceptron (Perceptron)Un modelo que implementa un perceptrón para la clasificación binaria y multiclase.from sklearn.linear_model import Perceptronmodel = Perceptron()
Quadratic Discriminant Analysis (QuadraticDiscriminantAnalysis)Un modelo que utiliza análisis discriminante cuadrático para la clasificación.from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysismodel = QuadraticDiscriminantAnalysis()
Linear Discriminant Analysis (LinearDiscriminantAnalysis)Un modelo que utiliza análisis discriminante lineal para la clasificación.from sklearn.discriminant_analysis import LinearDiscriminantAnalysismodel = LinearDiscriminantAnalysis()
Ridge Classifier (RidgeClassifier)Un modelo que utiliza regresión ridge para la clasificación binaria y multiclase.from sklearn.linear_model import RidgeClassifiermodel = RidgeClassifier()
SGD Classifier (SGDClassifier)Un modelo que implementa clasificadores lineales mediante el descenso de gradiente estocástico (SGD).from sklearn.linear_model import SGDClassifiermodel = SGDClassifier()
Bernoulli Naive Bayes (BernoulliNB)Un modelo que implementa el algoritmo de Naive Bayes para datos distribuidos según una distribución de Bernoulli.from sklearn.naive_bayes import BernoulliNBmodel = BernoulliNB()
Multinomial Naive Bayes (MultinomialNB)Un modelo que implementa el algoritmo de Naive Bayes para datos distribuidos según una distribución multinomial.from sklearn.naive_bayes import MultinomialNBmodel = MultinomialNB()

Clasificacion con Ensambles

Modelo de ClasificaciónDescripciónImportarEjemplo de Código
Random Forest Classifier (RandomForestClassifier)Un modelo de clasificación basado en árboles de decisión que utiliza el método de ensamble de bagging para realizar predicciones.from sklearn.ensemble import RandomForestClassifiermodel = RandomForestClassifier(n_estimators=100)
Gradient Boosting Classifier (GradientBoostingClassifier)Un modelo de clasificación basado en el algoritmo de boosting que construye un conjunto de modelos débiles para realizar predicciones.from sklearn.ensemble import GradientBoostingClassifiermodel = GradientBoostingClassifier(n_estimators=100)
AdaBoost Classifier (AdaBoostClassifier)Un modelo de clasificación basado en el algoritmo de boosting que asigna pesos a las instancias para corregir los errores de predicción de los modelos anteriores.from sklearn.ensemble import AdaBoostClassifiermodel = AdaBoostClassifier(n_estimators=100)
Bagging Classifier (BaggingClassifier)Un modelo de clasificación basado en el método de ensamble de bagging que entrena múltiples modelos en diferentes subconjuntos de datos para realizar predicciones.from sklearn.ensemble import BaggingClassifiermodel = BaggingClassifier(n_estimators=100)
XGBoost Classifier (XGBClassifier)Un modelo de clasificación basado en el algoritmo de boosting llamado XGBoost que utiliza árboles de decisión mejorados para realizar predicciones.from xgboost import XGBClassifiermodel = XGBClassifier(n_estimators=100)
LightGBM Classifier (LGBMClassifier)Un modelo de clasificación basado en el algoritmo de boosting llamado LightGBM que utiliza árboles de decisión optimizados para realizar predicciones.from lightgbm import LGBMClassifiermodel = LGBMClassifier(n_estimators=100)
CatBoost Classifier (CatBoostClassifier)Un modelo de clasificación basado en el algoritmo de boosting llamado CatBoost que utiliza árboles de decisión y características categóricas para realizar predicciones.from catboost import CatBoostClassifiermodel = CatBoostClassifier(iterations=100)
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

Modelo de ClusteringDescripciónImportarEjemplo de Código
K-Means (KMeans)Un modelo de clustering que agrupa los datos en k clusters utilizando la distancia euclidiana como medida de similitud.from sklearn.cluster import KMeansmodel = KMeans(n_clusters=3)
Mean Shift (MeanShift)Un modelo de clustering que estima la densidad de los datos y busca los modos de esa densidad para identificar los clusters.from sklearn.cluster import MeanShiftmodel = MeanShift()
Agglomerative Clustering (AgglomerativeClustering)Un modelo de clustering jerárquico que fusiona iterativamente los clusters más cercanos hasta obtener el número deseado de clusters.from sklearn.cluster import AgglomerativeClusteringmodel = AgglomerativeClustering(n_clusters=3)
DBSCAN (DBSCAN)Un modelo de clustering que utiliza la densidad de los puntos para identificar regiones densas y separarlas de regiones menos densas.from sklearn.cluster import DBSCANmodel = DBSCAN(eps=0.5, min_samples=5)
Gaussian Mixture (GaussianMixture)Un modelo de clustering que modela los datos como una mezcla de distribuciones gaussianas y asigna puntos a los clusters en función de su probabilidad.from sklearn.mixture import GaussianMixturemodel = GaussianMixture(n_components=3)
Spectral Clustering (SpectralClustering)Un modelo de clustering que utiliza la matriz de afinidad de los datos para realizar el agrupamiento espectral.from sklearn.cluster import SpectralClusteringmodel = SpectralClustering(n_clusters=3)
Birch (Birch)Un modelo de clustering que construye una estructura de árbol para agrupar los datos en clusters de forma eficiente.from sklearn.cluster import Birchmodel = Birch(n_clusters=3)

Reduccion de Dimensionalidad

Método de Reducción de DimensionalidadDescripciónImportarEjemplo de Código
Análisis de Componentes Principales (PCA)Un método de reducción de dimensionalidad que proyecta los datos en un nuevo espacio de menor dimensión utilizando las componentes principales.from sklearn.decomposition import PCApca = PCA(n_components=2)
X_transformed = pca.fit_transform(X)
Análisis Discriminante Lineal (LDA)Un método de reducción de dimensionalidad que maximiza la separabilidad de las clases al proyectar los datos en un nuevo espacio.from sklearn.discriminant_analysis import LinearDiscriminantAnalysislda = LinearDiscriminantAnalysis(n_components=2)
X_transformed = lda.fit_transform(X, y)
Factorización de Matriz No Negativa (NMF)Un método de reducción de dimensionalidad que descompone una matriz no negativa en dos matrices de menor rango para encontrar representaciones más simples de los datos.from sklearn.decomposition import NMFnmf = NMF(n_components=2)
X_transformed = nmf.fit_transform(X)
Análisis de Componentes Independientes (ICA)Un método de reducción de dimensionalidad que descompone una matriz de mezcla en componentes independientes, asumiendo que las señales originales son estadísticamente independientes.from sklearn.decomposition import FastICAica = FastICA(n_components=2)
X_transformed = ica.fit_transform(X)
Descomposición de Valor Singular (SVD)Un método de reducción de dimensionalidad que utiliza la descomposición de valor singular para encontrar las componentes principales de los datos.from sklearn.decomposition import TruncatedSVDsvd = TruncatedSVD(n_components=2)
X_transformed = svd.fit_transform(X)
Latent Dirichlet Allocation (LDA)Un método de reducción de dimensionalidad que se utiliza comúnmente en el análisis de texto para encontrar tópicos latentes en un corpus.from sklearn.decomposition import LatentDirichletAllocationlda = LatentDirichletAllocation(n_components=2)
X_transformed = lda.fit_transform(X)

Evaluacion de los Modelos

Metricas de Regresion

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

Métrica de Evaluación de RegresiónDescripciónSituaciones de UsoCódigo de Ejemplo
Error Cuadrático Medio (MSE)Mide el promedio de los errores al cuadrado entre las predicciones y los valores reales.Se utiliza para evaluar el nivel general de precisión del modelo de regresión.from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_true, y_pred)
Error Absoluto Medio (MAE)Mide el promedio de los errores absolutos entre las predicciones y los valores reales.Se utiliza cuando los errores individuales son igualmente importantes en la regresión.from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_true, y_pred)
Raíz del Error Cuadrático Medio (RMSE)Mide la raíz cuadrada del promedio de los errores al cuadrado entre las predicciones y los valores reales.Se utiliza para tener una métrica de error en la misma escala que la variable objetivo.from sklearn.metrics import mean_squared_error
rmse = mean_squared_error(y_true, y_pred, squared=False)
Coeficiente de Determinación (R^2)Mide la proporción de la varianza explicada por el modelo en relación a la varianza total.Se utiliza para evaluar la capacidad predictiva del modelo de regresión.from sklearn.metrics import r2_score
r2 = r2_score(y_true, y_pred)
Error Porcentual Absoluto Medio (MAPE)Mide el promedio de los errores absolutos en términos de un porcentaje del valor real.Se utiliza para evaluar el error relativo en la regresión cuando los errores absolutos son importantes.from sklearn.metrics import mean_absolute_percentage_error
mape = mean_absolute_percentage_error(y_true, y_pred)

Metricas de Clasificacion

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

Métrica de Evaluación de ClasificaciónDescripciónSituaciones de UsoCódigo de Ejemplo
Exactitud (Accuracy)Mide la proporción de muestras clasificadas correctamente.Se utiliza para evaluar la precisión general del modelo de clasificación.from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_true, y_pred)
Precisión (Precision)Mide la proporción de verdaderos positivos entre los positivos predichos.Se utiliza cuando se busca minimizar los falsos positivos en la clasificación.from sklearn.metrics import precision_score
precision = precision_score(y_true, y_pred)
Recall (Sensibilidad)Mide la proporción de verdaderos positivos clasificados correctamente.Se utiliza cuando se busca minimizar los falsos negativos en la clasificación.from sklearn.metrics import recall_score
recall = recall_score(y_true, y_pred)
F1-ScoreCombina precisión y recall en una única medida ponderada.Se utiliza para evaluar el equilibrio entre precisión y recall en la clasificación.from sklearn.metrics import f1_score
f1 = f1_score(y_true, y_pred)
Área bajo la Curva ROC (AUC-ROC)Mide la capacidad de discriminación del modelo en términos de tasa de verdaderos positivos y tasa de falsos positivos.Se utiliza para evaluar la capacidad del modelo para distinguir entre clases positivas y negativas.from sklearn.metrics import roc_auc_score
auc_roc = roc_auc_score(y_true, y_pred_prob)
Matriz de Confusión (Confusion Matrix)Muestra el número de predicciones correctas e incorrectas para cada clase.Se utiliza para evaluar el desempeño detallado del modelo de clasificación.from sklearn.metrics import confusion_matrix
confusion_matrix = confusion_matrix(y_true, y_pred)
Reporte de Clasificación (Classification Report)Muestra un informe detallado de las métricas de evaluación para cada clase.Proporciona una visión general completa del desempeño del modelo de clasificación.from sklearn.metrics import classification_report
classification_report = classification_report(y_true, y_pred)

Metricas de Clustering

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

Métrica de Evaluación de ClusteringDescripciónSituaciones de UsoCódigo de Ejemplo
HomogeneidadMide la homogeneidad de los grupos asignados por el algoritmo de clustering.Se utiliza para evaluar la calidad de los grupos asignados por el algoritmo.from sklearn.metrics import homogeneity_score
homogeneity = homogeneity_score(labels_true, labels_pred)
CompletitudMide la completitud de los grupos asignados por el algoritmo de clustering.Se utiliza para evaluar si todos los elementos de la misma clase están en el mismo grupo.from sklearn.metrics import completeness_score
completeness = completeness_score(labels_true, labels_pred)
V-MeasureCombina la homogeneidad y completitud para calcular una puntuación equilibrada.Proporciona una medida única que tiene en cuenta tanto la homogeneidad como la completitud.from sklearn.metrics import v_measure_score
v_measure = v_measure_score(labels_true, labels_pred)
Índice Rand Ajustado (Adjusted Rand Index, ARI)Mide la similitud entre dos asignaciones de clustering, ignorando las permutaciones y asignaciones de etiquetas diferentes.Se utiliza para evaluar la similitud entre dos asignaciones de clustering.from sklearn.metrics import adjusted_rand_score
ari = adjusted_rand_score(labels_true, labels_pred)
Índice Rand Normalizado (Normalized Mutual Information, NMI)Mide la similitud entre dos asignaciones de clustering, normalizando el índice de información mutua.Se utiliza para evaluar la similitud entre dos asignaciones de clustering y tener en cuenta la aleatoriedad esperada.from sklearn.metrics import normalized_mutual_info_score
nmi = normalized_mutual_info_score(labels_true, labels_pred)
Coeficiente de Silueta (Silhouette Coefficient)Mide la cohesión y separación de los grupos en función de las distancias entre muestras.Se utiliza para evaluar la calidad de los grupos formados por el algoritmo de clustering.from sklearn.metrics import silhouette_score
silhouette = silhouette_score(X, labels)
Calinski-Harabasz ScoreCalcula la relación entre la dispersión dentro de los grupos y la dispersión entre los grupos.Se utiliza para evaluar la calidad de los grupos formados por el algoritmo de clustering.from sklearn.metrics import calinski_harabasz_score

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.

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:

Referencias

Phd. Jose R. Zapata