Machine Learning con Scikit Learn

Por Jose R. Zapata

Ultima actualizacion: 12/Feb/2026

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.

Es la librería más utilizada para Machine Learning clásico en Python y proporciona una API consistente y fácil de usar para todos sus algoritmos, lo que facilita experimentar con diferentes modelos y técnicas de preprocesamiento.

Documentación oficial: https://scikit-learn.org/stable/

Instalación

pip install scikit-learn

Importar librerías

import pandas as pd
import sklearn

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

Sklearn version: 1.6.1

Transformador vs Estimador

Antes de trabajar con scikit-learn, es fundamental entender la diferencia entre sus dos componentes principales: Transformadores y Estimadores.

Un transformador es una clase que se utiliza para preprocesar o transformar los datos de entrada. Su función principal es aplicar operaciones a los datos sin alterar su estructura subyacente. Los transformadores son útiles para tareas como normalización, codificación de variables categóricas, selección de características y extracción de características.

Un estimador es una clase que se utiliza para aprender a partir de los datos y hacer predicciones. Representa un modelo que puede aprender patrones en los datos de entrenamiento y utilizar ese conocimiento para hacer predicciones sobre nuevos datos.

Ejemplo comparativo:

Proceso de un Proyecto de Machine Learning

Un proyecto de Machine Learning sigue un proceso iterativo que se puede resumir en los siguientes pasos:

1. Definir el problema y mirar el panorama general
2. Obtener los datos y explorarlos para obtener información
3. Preparar los datos (limpieza, transformación, feature engineering)
4. Seleccionar y entrenar modelos usando validación cruzada
5. Afinar los hiperparámetros del mejor modelo
6. Evaluar el modelo final con los datos de prueba
7. Desplegar y monitorear el sistema

Pasos para la construcción y selección de un Modelo

En la práctica, los pasos 3 a 6 siguen este flujo:

1. Preparación de los datos
2. División de los datos entre datos de Entrenamiento (80%) y datos de Test (20%)
3. Se selecciona la métrica de evaluación según la aplicación
4. Usando solo los datos de Entrenamiento se seleccionan los mejores modelos utilizando cross validation
5. Se toman los mejores modelos y se ajustan los hiperparámetros
6. Se entrena el mejor modelo con todos los datos de Entrenamiento y se evalúa con los datos de Test
7. Si hay un buen resultado se pasa a la etapa de despliegue (deployment)

Consideraciones Importantes

Antes de realizar el ejemplo práctico, es importante tener en cuenta algunos problemas comunes que pueden afectar negativamente el rendimiento y la confiabilidad de un modelo de Machine Learning.

Data Leakage

Datos Duplicados

Desbalance de Clases

Overfitting y Underfitting

Selección de Métrica Equivocada

Ejemplo Completo de Clasificación con un Modelo

A continuación se presenta un ejemplo completo de un flujo de Machine Learning para clasificación. Este ejemplo sigue los pasos descritos anteriormente y demuestra el uso de las herramientas principales de scikit-learn.

Los pasos que vamos a seguir son:

1. Cargar y explorar los datos
2. Codificar la variable objetivo
3. Eliminar datos duplicados
4. Dividir datos en entrenamiento y prueba
5. Crear pipeline de preprocesamiento y modelo
6. Evaluar con validación cruzada (cross-validation)
7. Buscar mejores hiperparámetros (GridSearchCV)
8. Entrenar modelo final y evaluar con datos de test
9. Guardar y cargar el modelo

1. Cargar y explorar los datos

Usaremos el dataset Iris, un dataset clásico de clasificación que contiene 150 muestras de 3 especies de flores Iris, con 4 características cada una (largo y ancho del sépalo y pétalo).

from sklearn.datasets import fetch_openml

# Descargar el dataset iris desde openml.org
iris = fetch_openml(name="iris", version=1, parser="auto")

# Convertir a DataFrame de pandas
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)

2. Codificar la variable objetivo (Label Encoding)

Los algoritmos de Machine Learning trabajan con números, por lo que necesitamos convertir las categorías de texto (Iris-setosa, Iris-versicolor, Iris-virginica) a valores numéricos. Para esto usamos LabelEncoder.

from sklearn.preprocessing import LabelEncoder

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

# Mapeo de categorías a números
le_name_mapping = dict(zip(le.classes_, le.transform(le.classes_), strict=False))
print(le_name_mapping)

{'Iris-setosa': np.int64(0), 'Iris-versicolor': np.int64(1), 'Iris-virginica': np.int64(2)}

# Eliminar la columna de texto (species) ya que tenemos la columna numérica (target)
iris_df.drop(["species"], axis=1, inplace=True)
iris_df.sample(5)

3. Eliminar datos duplicados

Como se mencionó anteriormente, los datos duplicados pueden causar problemas en la evaluación del modelo. Es importante eliminarlos antes de dividir los datos.

print(f"Filas antes de eliminar duplicados: {len(iris_df)}")
iris_df = iris_df.drop_duplicates()
print(f"Filas después de eliminar duplicados: {len(iris_df)}")

Filas antes de eliminar duplicados: 150
Filas después de eliminar duplicados: 147

4. División datos de entrenamiento y test

Dividimos los datos en dos conjuntos:

• Entrenamiento (80%): para seleccionar y ajustar el modelo
• Test (20%): para evaluar el modelo final (datos que el modelo nunca ha visto)

Usamos la opción stratify para que la proporción de clases se mantenga igual en ambos conjuntos.

Documentación: train_test_split

from sklearn.model_selection import train_test_split

# Separar características (X) y variable objetivo (y)
X_data = iris_df.drop(columns=["target"])
y_target = iris_df["target"]

# División estratificada
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
)

print(f"Datos de entrenamiento: {X_train.shape[0]} filas")
print(f"Datos de test: {X_test.shape[0]} filas")

Datos de entrenamiento: 117 filas
Datos de test: 30 filas

5. Crear Pipeline de preprocesamiento y modelo

Un Pipeline encadena una secuencia de transformaciones y un modelo final en un solo objeto. Esto tiene varias ventajas:

• Previene data leakage: las transformaciones se ajustan solo con datos de entrenamiento
• Simplifica el código: un solo .fit() y .predict() para todo el flujo
• Facilita la reproducibilidad: el pipeline completo se puede guardar y cargar

En este ejemplo, el pipeline incluye:

1. StandardScaler - Estandariza las características (media=0, varianza=1)
2. PCA - Reduce dimensionalidad a 3 componentes principales
3. RandomForestClassifier - Modelo de clasificación basado en árboles de decisión

from sklearn import set_config
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

# Pipeline de preprocesamiento de datos
pipeline_data = Pipeline(
    [
        ("scaler", StandardScaler()),
        ("pca", PCA(n_components=3)),
    ]
)

# Modelo
model_rf = RandomForestClassifier()

# Pipeline completo: transformación + 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=[('scaler', StandardScaler()),
                                 ('pca', PCA(n_components=3))])),
                ('modelo', RandomForestClassifier())])

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

Pipeline(steps=[('scaler', StandardScaler()), ('pca', PCA(n_components=3))])

StandardScaler()

PCA(n_components=3)

RandomForestClassifier()

6. Validación Cruzada (Cross-Validation)

La validación cruzada divide los datos de entrenamiento en K pliegues (folds) y realiza múltiples iteraciones de entrenamiento y evaluación. Esto da una estimación más confiable del rendimiento del modelo que una sola división de datos.

Usamos KFold con 5 pliegues y cross_validate para obtener las métricas.

from sklearn.model_selection import KFold, cross_validate

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():.4f}")
print(f"Resultado STD = {cv_results['test_score'].std():.4f}")

Resultado Promedio = 0.9319
Resultado STD = 0.0511

7. Búsqueda de Hiperparámetros (GridSearchCV)

Los hiperparámetros son configuraciones del modelo que no se aprenden de los datos (a diferencia de los parámetros). Ejemplos: número de árboles, profundidad máxima, etc.

El ajuste de hiperparámetros busca la combinación óptima evaluando el rendimiento con validación cruzada.

GridSearchCV prueba todas las combinaciones posibles de hiperparámetros definidos en una grilla.

from sklearn.model_selection import GridSearchCV

# Definir la grilla de hiperparámetros para el Random Forest
# Nota: se usa "modelo__" como prefijo porque el modelo está dentro del pipeline
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_train, y_train)

GridSearchCV(cv=KFold(n_splits=5, random_state=None, shuffle=False),
             estimator=Pipeline(steps=[('pipeline_datos',
                                        Pipeline(steps=[('scaler',
                                                         StandardScaler()),
                                                        ('pca',
                                                         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=[('scaler',
                                                         StandardScaler()),
                                                        ('pca',
                                                         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=[('scaler', StandardScaler()),
                                 ('pca', PCA(n_components=3))])),
                ('modelo',
                 RandomForestClassifier(max_depth=5, max_features=None,
                                        n_estimators=200))])

Pipeline(steps=[('scaler', StandardScaler()), ('pca', PCA(n_components=3))])

StandardScaler()

PCA(n_components=3)

RandomForestClassifier(max_depth=5, max_features=None, n_estimators=200)

# Mejores hiperparámetros encontrados
print(f"Mejores parámetros: {grid_search.best_params_}")
print(f"Mejor resultado CV: {grid_search.best_score_:.4f}")
print(
    f"STD del mejor resultado: "
    f"{grid_search.cv_results_['std_test_score'][grid_search.best_index_]:.4f}"
)

Mejores parámetros: {'modelo__max_depth': 5, 'modelo__max_features': None, 'modelo__n_estimators': 200}
Mejor resultado CV: 0.9319
STD del mejor resultado: 0.0332

8. Evaluación contra datos de Test

Ahora entrenamos el modelo con los mejores hiperparámetros usando todos los datos de entrenamiento y evaluamos su rendimiento con los datos de test (que el modelo nunca ha visto).

Documentación: accuracy_score

from sklearn.metrics import accuracy_score

# Configurar el pipeline con los mejores hiperparámetros
mejor_transform_modelo = pipeline_transform_model.set_params(**grid_search.best_params_)

# Entrenar con datos de entrenamiento
mejor_transform_modelo.fit(X_train, y_train)

# Predecir con datos de test
y_pred = mejor_transform_modelo.predict(X_test)

# Evaluar
print(f"Accuracy en Test: {accuracy_score(y_test, y_pred):.4f}")

Accuracy en Test: 0.9000

9. Modelo Final

Una vez validado el rendimiento en test, entrenamos el modelo final con todos los datos disponibles (entrenamiento + test) para aprovechar al máximo la información antes de desplegarlo en producción.

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

# Verificación: accuracy sobre todos los datos (debe ser alto)
print(f"Accuracy (todos los datos): {accuracy_score(y_target, modelo_final.predict(X_data)):.4f}")

Accuracy (todos los datos): 1.0000

10. Guardar y cargar el modelo

Para usar el modelo en producción, podemos guardarlo en un archivo usando joblib. El pipeline completo (preprocesamiento + modelo) se serializa en un solo archivo.

from joblib import dump

# Guardar el pipeline completo
dump(modelo_final, "pipeline_transform_model.joblib")

['pipeline_transform_model.joblib']

from joblib import load

# Cargar el pipeline desde el archivo
modelo_cargado = load("pipeline_transform_model.joblib")

# Predicción con un solo dato nuevo
# Recordar: {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}
pred_unico = modelo_cargado.predict([[5.1, 3.5, 1.4, 0.2]])
print(f"Predicción para [5.1, 3.5, 1.4, 0.2]: {pred_unico} ({le.inverse_transform(pred_unico)[0]})")

Predicción para [5.1, 3.5, 1.4, 0.2]: [0] (Iris-setosa)


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

# Predicción con múltiples datos
pred_varios = modelo_cargado.predict(X_test)
print(f"Predicciones: {pred_varios}")

Predicciones: [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]

Preprocesamiento de Datos

Scikit-learn ofrece una gran variedad de transformadores para preprocesar los datos. La documentación completa se encuentra en: https://scikit-learn.org/stable/modules/preprocessing.html

Los transformadores más utilizados son:

Ejemplo de Estandarización

La estandarización se puede hacer de dos formas equivalentes:

from sklearn.preprocessing import StandardScaler

# Forma 1: fit() + transform() por separado
scaler = StandardScaler()
scaler.fit(X_train)  # Aprende media y std de los datos de entrenamiento
X_train_scaled = scaler.transform(X_train)  # Transforma entrenamiento
X_test_scaled = scaler.transform(X_test)  # Transforma test con los mismos parámetros

# Forma 2: fit_transform() (equivalente a fit + transform en un solo paso)
scaler2 = StandardScaler()
X_train_scaled2 = scaler2.fit_transform(X_train)
X_test_scaled2 = scaler2.transform(X_test)

Entrenamiento de Modelos

Scikit-learn incluye modelos para los tres tipos principales de problemas de Machine Learning. A continuación se listan algunos de los más utilizados con links a su documentación. Los capítulos siguientes de este curso profundizan en cada tipo.

Modelos de Regresión

Documentación: Modelos supervisados - Regresión

Ver también: XGBoost, LightGBM, CatBoost

Modelos de Clasificación

Documentación: Modelos supervisados - Clasificación

Ver también: XGBClassifier, LGBMClassifier, CatBoostClassifier

Modelos de Clustering

Documentación: Clustering

Evaluación de Modelos

La selección de la métrica de evaluación depende del tipo de problema y del objetivo del negocio.

Métricas de Regresión

Documentación: Métricas de Regresión

Métricas de Clasificación

Documentación: Métricas de Clasificación

Métricas de Clustering

Documentación: Métricas de Clustering

Selección de Modelos

Scikit-learn proporciona herramientas para comparar modelos y buscar hiperparámetros óptimos.

División de datos

Validación Cruzada

Búsqueda de Hiperparámetros

Librerías de Machine Learning en Python

Algunas de las librerías más utilizadas en Python son:

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

Referencias

• Documentación oficial de scikit-learn
• Cheatsheet scikit-learn (DataCamp)
• Errores Comunes y Recomendaciones (scikit-learn)
• Métricas de Regresión
• Métricas de Clasificación
• Métricas 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/