Scikit-Learn en Python: guía para principiantes

Scikit-Learn es una de las bibliotecas más accesibles para comenzar con aprendizaje automático en Python. Proporciona una interfaz coherente para preparar datos, entrenar modelos, realizar predicciones, medir resultados, seleccionar variables y ajustar parámetros.

Esta guía explica el flujo completo: separar variables y objetivo, dividir los datos, entrenar clasificación y regresión, interpretar métricas, utilizar pipelines y evitar errores como la fuga de información.

Qué es el aprendizaje automático

En un programa tradicional, el desarrollador escribe reglas explícitas. En machine learning, un modelo aprende patrones a partir de ejemplos y utiliza esos patrones para estimar resultados en datos nuevos.

• Clasificación: predecir una categoría.
• Regresión: predecir un número continuo.
• Clustering: agrupar observaciones sin etiquetas conocidas.
• Reducción de dimensionalidad: representar los datos con menos variables.

Las referencias principales son la guía oficial de Scikit-Learn y la guía oficial de inicio.

Instalar Scikit-Learn

python -m venv .venv

# Windows
.venv\Scripts\activate

# macOS o Linux
source .venv/bin/activate

python -m pip install scikit-learn pandas matplotlib

El artículo sobre entornos virtuales explica cómo aislar dependencias. Scikit-Learn trabaja habitualmente con NumPy y Pandas, por lo que también conviene revisar las guías de NumPy y Pandas.

Features, target y muestras

Cada fila es una muestra. Las columnas de entrada son las características, normalmente guardadas en X. El valor que queremos predecir es el objetivo, guardado en y.

import pandas as pd

data = pd.DataFrame({
    "hours_studied": [1, 2, 3, 4, 5, 6, 7, 8],
    "practice_tests": [0, 1, 1, 2, 2, 3, 4, 5],
    "passed": [0, 0, 0, 1, 1, 1, 1, 1],
})

X = data[["hours_studied", "practice_tests"]]
y = data["passed"]

Dividir entrenamiento y prueba

Evaluar el modelo con los mismos datos usados para entrenar produce una estimación poco realista. Reserva un conjunto de prueba.

from sklearn.model_selection import train_test_split

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

random_state hace reproducible la división. stratify ayuda a mantener la proporción de clases cuando el conjunto es suficientemente grande.

Entrenar un clasificador

La regresión logística es una buena línea base para clasificación binaria.

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)

predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)[:, 1]

La mayoría de los estimadores siguen el patrón fit() para aprender y predict() para aplicar el modelo.

Métricas de clasificación

from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
)

print("Accuracy:", accuracy_score(y_test, predictions))
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))

• Accuracy: proporción total de aciertos.
• Precision: entre los positivos predichos, cuántos eran correctos.
• Recall: entre los positivos reales, cuántos fueron detectados.
• F1: equilibrio entre precision y recall.
• Matriz de confusión: recuento de aciertos y errores por clase.

La métrica adecuada depende del coste de cada error. En fraude puede ser más grave perder un caso real; en otra aplicación, un falso positivo puede causar una intervención innecesaria.

Entrenar una regresión

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

regressor = LinearRegression()
regressor.fit(X_train, y_train)

predictions = regressor.predict(X_test)

print("MAE:", mean_absolute_error(y_test, predictions))
print("MSE:", mean_squared_error(y_test, predictions))
print("R²:", r2_score(y_test, predictions))

El error absoluto medio conserva la unidad del objetivo. El error cuadrático penaliza más los fallos grandes. R² compara el modelo con una referencia sencilla, pero no debe interpretarse de forma aislada.

Escalar variables numéricas

Algunos algoritmos son sensibles a la escala. Ajusta el escalador solamente con los datos de entrenamiento.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

Ajustar el escalador con todo el conjunto introduce información de prueba durante el entrenamiento.

Codificar categorías

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler

numeric_features = ["age", "income"]
categorical_features = ["city", "plan"]

preprocessor = ColumnTransformer([
    ("numeric", StandardScaler(), numeric_features),
    (
        "categorical",
        OneHotEncoder(handle_unknown="ignore"),
        categorical_features,
    ),
])

handle_unknown="ignore" evita que una categoría nueva detenga la predicción, aunque sigue siendo necesario revisar su significado.

Utilizar un pipeline

Un pipeline une el preprocesamiento y el modelo, reduciendo diferencias entre entrenamiento y producción.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
    ("preprocess", preprocessor),
    ("model", LogisticRegression(max_iter=1000)),
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

Los pipelines son una de las mejores defensas contra la fuga de datos.

Valores ausentes

from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline

numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore")),
])

Antes de rellenar valores, investiga por qué faltan. La ausencia puede contener información relevante.

Validación cruzada

from sklearn.model_selection import cross_val_score

scores = cross_val_score(
    pipeline,
    X,
    y,
    cv=5,
    scoring="f1",
)

print(scores)
print(scores.mean())

La validación cruzada reduce la dependencia de una única división. Cuando el ajuste es extenso, conserva un conjunto final que no participe en la selección.

Ajustar hiperparámetros

from sklearn.model_selection import GridSearchCV

parameter_grid = {
    "model__C": [0.1, 1.0, 10.0],
    "model__class_weight": [None, "balanced"],
}

search = GridSearchCV(
    pipeline,
    parameter_grid,
    cv=5,
    scoring="f1",
    n_jobs=-1,
)

search.fit(X_train, y_train)
print(search.best_params_)

Ajustar muchos parámetros no compensa datos pequeños o poco representativos.

Árboles y random forests

from sklearn.ensemble import RandomForestClassifier

forest = RandomForestClassifier(
    n_estimators=300,
    max_depth=8,
    random_state=42,
    class_weight="balanced",
)

forest.fit(X_train, y_train)

Los modelos de árboles capturan relaciones no lineales, pero siguen necesitando una división correcta, métricas adecuadas y control de fuga.

Guardar el pipeline

import joblib

joblib.dump(pipeline, "modelo.joblib")
loaded_model = joblib.load("modelo.joblib")

Carga únicamente archivos confiables, porque la deserialización puede ejecutar código. Registra también versiones de paquetes y el esquema esperado.

Fuga de datos

Existe fuga cuando el entrenamiento utiliza información que no estaría disponible al predecir o datos del conjunto de evaluación.

• Escalar antes de dividir.
• Incluir una variable creada después del evento objetivo.
• Tener la misma persona en entrenamiento y prueba.
• Seleccionar variables usando todos los datos.
• Dividir aleatoriamente una serie temporal.

Overfitting y underfitting

Un modelo con underfitting es demasiado simple y falla incluso en entrenamiento. Un modelo con overfitting memoriza detalles y pierde rendimiento en datos nuevos. Compara resultados de entrenamiento y validación, reduce complejidad innecesaria y analiza errores concretos.

Visualizar resultados

Los gráficos ayudan a entender distribuciones, residuos y matrices de confusión. La guía de Matplotlib para principiantes muestra cómo construir visualizaciones estáticas.

Errores frecuentes

• Usar el conjunto de prueba repetidamente durante la selección.
• Evaluar solo accuracy en clases desequilibradas.
• Eliminar filas ausentes sin investigar.
• Utilizar identificadores como variables numéricas significativas.
• Guardar el estimador sin su preprocesamiento.
• Suponer que una buena predicción demuestra causalidad.
• No crear una línea base sencilla.

Conclusión

Un buen flujo con Scikit-Learn es más importante que elegir el algoritmo más llamativo. Define claramente el objetivo, crea una división realista, aprende el preprocesamiento solo con entrenamiento, utiliza pipelines, selecciona métricas relevantes y analiza los errores. Estas prácticas producen modelos más confiables y fáciles de mantener.