Formación corporativa en Scikit Learn

Este módulo convierte los conceptos iniciales de aprendizaje automático en un flujo práctico: explorar un dataset con pandas, separar variables predictoras y objetivo, entrenar un primer estimador supervisado y evaluar sus predicciones con una métrica sencilla antes de entrar en preprocesados más completos.

El preprocesamiento de datos es una etapa esencial en el flujo de trabajo de aprendizaje automático, ya que los modelos suelen asumir ciertas propiedades de las características de entrada. En Scikit Learn, el submódulo sklearn.preprocessing proporciona utilidades para la limpieza, la normalización y la transformación de los datos en una forma adecuada para los distintos estimadores. A lo largo de este proceso, se pueden aplicar escalados, codificaciones categóricas, tratamientos de valores perdidos y generación de variables polinómicas.

En primer lugar, el escalado de características ayuda a equilibrar la influencia de cada variable en el resultado final. Para ello, se dispone de clases como StandardScaler, MinMaxScaler o RobustScaler. StandardScaler ajusta cada característica para que tenga media 0 y desviación típica 1, mientras que MinMaxScaler fuerza que cada variable quede acotada en un intervalo (por defecto, [0, 1]). A su vez, RobustScaler es útil cuando existen valores atípicos que podrían distorsionar significativamente la media y la desviación. El escalado se ejecuta mediante los métodos fit y transform, asegurando que se calcule la información estadística únicamente sobre los datos de entrenamiento.

El tratamiento de valores perdidos también ocupa un lugar relevante en la limpieza previa de datos. Scikit Learn ofrece el transformador SimpleImputer, que sustituye los valores ausentes con la media, la mediana o la moda de la columna, y KNNImputer, que estima dichos valores en función de la cercanía con instancias vecinas. Un breve ejemplo para sustituir valores ausentes por la mediana sería:

from sklearn.impute import SimpleImputer
import numpy as np

data = np.array([[1, 2], [np.nan, 3], [7, np.nan], [6, 5]])
imputer = SimpleImputer(strategy='median')
imputer.fit(data)
transformed_data = imputer.transform(data)

Cuando se trabaja con variables categóricas, es conveniente transformarlas a un formato numérico para que los modelos puedan reconocer sus patrones. Con OneHotEncoder se generan columnas binarias, asegurando que no se introduzca un orden artificial en variables nominales. De forma similar, OrdinalEncoder asigna valores enteros a cada categoría, y puede resultar útil en casos donde existe un orden implícito (por ejemplo, tamaños de ropa como S, M, L).

La generación de características adicionales puede hacerse con PolynomialFeatures, que crea interacciones y potencias de las variables originales. Esto puede incrementar la capacidad de ajuste de determinados modelos lineales, al introducir relaciones no lineales. Sin embargo, también incrementa el número de variables, lo que puede derivar en un mayor requerimiento computacional y riesgo de sobreajuste.

Por otro lado, es habitual encadenar distintos pasos de preprocesamiento dentro de un pipeline para asegurar que se realicen en el orden correcto y evitar fugas de información. Esto se logra con Pipeline, que asocia transformaciones como escalado, imputación y codificación, y finaliza en un estimador. Este planteamiento mantiene cada paso bien definido y facilita la replicación de la misma secuencia de transformaciones en el conjunto de prueba.

La corrección de sesgos en las características o la selección de variables relevantes también se integran en esta fase. Existen métodos específicos en sklearn.feature_selection para descartar columnas irrelevantes o altamente correlacionadas, lo que puede mejorar el rendimiento de modelos complejos. Al combinar la imputación de valores perdidos, la normalización y la selección de características, se obtiene un conjunto de datos más limpio y adecuado para tareas de clasificación, regresión o clustering.

El preprocesamiento de datos en Scikit Learn ofrece un ecosistema de transformadores y procedimientos que ayudan a preparar la información para un entrenamiento eficiente y una evaluación fiable. Con estas herramientas, se pueden corregir problemas de heterogeneidad en las escalas, manejar valores ausentes y variables categóricas, y añadir o eliminar características según resulte necesario. A través de las clases y métodos disponibles, cada paso se integra sin inconvenientes en un flujo coherente, manteniendo un enfoque modular y transparente en cada transformación aplicada.

Las técnicas de regresión permiten predecir valores continuos y resultan adecuadas para casos como el pronóstico de ventas, el cálculo de precios de viviendas o la estimación de la demanda energética. En Scikit Learn, estos métodos están reunidos en varios submódulos, principalmente sklearn.linear_model y sklearn.ensemble, aunque existen otros enfoques distribuidos en la librería. La facilidad para intercambiar modelos y probar diferentes algoritmos con la misma interfaz facilita la experimentación y la comparación de resultados.

Un punto de partida habitual es la regresión lineal clásica, implementada en LinearRegressión. Este modelo asume una relación lineal entre las características y la variable objetivo. Se ajusta resolviendo sistemas de ecuaciones que minimizan la suma de los errores cuadráticos. Su implementación en Scikit Learn es directa:

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(X_train, y_train)
predictions = lr.predict(X_test)

La sencillez del método lo hace apto para estudios iniciales o problemas donde la relación entre variables sea clara y estable.

Para regularizar el ajuste y controlar la magnitud de los coeficientes, Scikit Learn dispone de Ridge y Lasso en sklearn.linear_model. Ridge introduce un parámetro de penalización L2 que limita el crecimiento de los pesos, mientras que Lasso aplica una penalización L1 que puede llegar a forzar coeficientes a cero, promoviendo la selección de características relevantes. Esta estrategia mitiga el sobreajuste en situaciones con alto número de variables y reduce la complejidad del modelo.

Otro enfoque basado en conjuntos se encuentra en el submódulo sklearn.ensemble. Modelos como RandomForestRegressor o GradientBoostingRegressor combinan múltiples árboles de decisión para equilibrar la varianza y el sesgo, lo que proporciona resultados robustos ante datos ruidosos. Su flexibilidad permite capturar relaciones no lineales, beneficiando a problemas con interacciones complejas en las variables predictoras.

En escenarios con datos muy extensos, HistGradientBoostingRegressor aprovecha histogramas para acelerar el entrenamiento y manejar mejor la escala de los valores. Este modelo puede procesar grandes volúmenes de datos de forma más eficiente, lo que lo hace conveniente para tareas de análisis a gran escala. Además, Scikit Learn continúa optimizando sus algoritmos para mantener la compatibilidad con nuevas versiones de Python y ofrecer mejoras en rendimiento.

Cuando las relaciones en los datos no son completamente lineales, las características polinómicas se aplican para capturar patrones más complejos. Con PolynomialFeatures, es posible crear combinaciones de potencias e interacciones de las variables originales. Esto incrementa la expresividad del modelo, aunque exige mayor poder computacional y un adecuado control de la dimensionalidad para no incurrir en sobreajuste.

Al examinar algoritmos más recientes, MLPRegressor de sklearn.neural_network adopta la estructura de una red neuronal multicapa para la predicción de valores continuos. Configurar el número de capas y neuronas, junto con la función de activación, permite capturar relaciones no lineales con cierto grado de complejidad. Su rendimiento depende de una sintonía cuidada de los hiperparámetros, incluyendo la tasa de aprendizaje y las funciones de regularización.

La evaluación de modelos de regresión se realiza a través de métricas como el error cuadrático medio (mean_squared_error), la raíz del error cuadrático medio (RMSE), el error absoluto medio (mean_absolute_error) y el coeficiente de determinación (r2_score). Cada métrica ofrece una perspectiva diferente: por ejemplo, el RMSE penaliza con más fuerza las desviaciones grandes, mientras que el R² indica qué tanto varía la variable objetivo explicada por el modelo.

Para optimizar hiperparámetros y verificar la capacidad de generalización, se suele recurrir a la validación cruzada y a la búsqueda en rejilla o aleatoria. Mediante GridSearchCV o RandomizedSearchCV, se exploran combinaciones de parámetros como la tasa de regularización, la profundidad de los árboles o el número de neuronas en una red. De este modo, se identifican configuraciones que brindan un mejor equilibrio entre sesgo y varianza.

En flujos de trabajo complejos, resulta útil combinar transformaciones y modelos en un solo objeto Pipeline, lo que otorga coherencia y simplicidad. Se enlazan etapas como escalado de variables, imputación de valores perdidos o generación de características, y luego se concluye con el regressor elegido. Esto asegura que cada paso se aplique consistentemente y evita aplicar transformaciones con información del conjunto de prueba.

Cada uno de estos métodos de regresión atiende situaciones distintas y se adapta a diversas distribuciones de datos. La disponibilidad de interfaces unificadas para entrenar, predecir y evaluar facilita la incorporación de nuevos algoritmos en proyectos existentes. La integración con pandas y NumPy, junto con la posibilidad de orquestar cada etapa con Pipeline, genera un entorno de experimentación ágil, fiable y escalable para el desarrollo de sistemas de predicción.

El ámbito de la clasificación comprende aquellos métodos en los que se predicen etiquetas discretas, como la detección de correo spam, la identificación de un tipo de tumor o la clasificación de imágenes. En Scikit Learn, la variedad de algoritmos y utilidades para este propósito permite cubrir un amplio abanico de necesidades, desde tareas muy sencillas hasta casos con estructuras de datos complejas.

La interfaz de cada algoritmo de clasificación mantiene un estándar coherente: crear el modelo, entrenarlo con fit usando un conjunto de datos de entrenamiento (X, y) y, finalmente, generar predicciones con predict. Este paradigma unificado facilita realizar comparaciones entre múltiples enfoques en un mismo proyecto.

Se pueden distinguir varias familias de modelos de clasificación:

• Lineales (regresión logística, perceptrones, etc.)
• Árboles de decisión y métodos en ensamblado (RandomForest, GradientBoosting, etc.)
• Máquinas de vectores soporte (SVM)
• Vecinos más cercanos (k-NN)
• Naive Bayes (GaussianNB, MultinomialNB, etc.)
• Redes neuronales básicas (MLPClassifier)

A continuación se describe el modo de uso y las características principales de los algoritmos de clasificación más frecuentes en Scikit Learn.

Regresión logística
Es un modelo lineal básico que asume que la probabilidad de pertenecer a una clase puede expresarse a través de una función logística. Se implementa en sklearn.linear_model.LogisticRegressión. Suele emplearse en problemas binarios, pero también maneja clasificación multiclase con el modo multinomial. Un ejemplo básico:

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression()
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)

Es común combinar la regresión logística con regularizaciones L1 (Lasso) o L2 (Ridge) para controlar la magnitud de los coeficientes. Esto evita el sobreajuste cuando el número de características es elevado.

Máquinas de vectores soporte (SVM)
El clasificador SVC de sklearn.svm se basa en la idea de encontrar un hiperplano que separe las clases con un máximo margen. Dispone de múltiples kernels, como linear, rbf, poly, que ayudan a capturar relaciones no lineales. Un ejemplo con un kernel RBF:

from sklearn.svm import SVC

svc = SVC(kernel='rbf', C=1.0, gamma='scale')
svc.fit(X_train, y_train)
y_pred = svc.predict(X_test)

Elegir el kernel apropiado y ajustar parámetros como C y gamma pueden impactar mucho en la capacidad de generalización del modelo.

Árboles de decisión y bosques aleatorios
Los árboles de decisión (DecisionTreeClassifier) pueden segmentar el espacio de características de forma jerárquica, generando reglas si/entonces. Son intuitivos de interpretar y entrenar, pero a veces presentan sobreajuste. Para mitigarlo, se aplican parámetros de pre-poda como max_depth o min_samples_split.

El RandomForestClassifier, por otro lado, entrena múltiples árboles de decisión en subconjuntos aleatorios de datos y características, integrando sus predicciones para lograr mayor robustez. Un ejemplo:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=100, max_depth=None, random_state=42)
rfc.fit(X_train, y_train)
y_pred = rfc.predict(X_test)

Incluir más estimadores y sintonizar parámetros como max_features puede equilibrar la varianza y el sesgo del modelo.

Gradient boosting
Los métodos de gradient boosting (p. ej. GradientBoostingClassifier o HistGradientBoostingClassifier) combinan árboles de decisión de manera aditiva, corrigiendo iterativamente los errores de modelos débiles previos. Estos algoritmos suelen requerir una búsqueda cuidadosa de hiperparámetros como la tasa de aprendizaje (learning_rate) o la profundidad de los árboles.

HistGradientBoostingClassifier, por ejemplo, realiza un mapeo de los datos en histogramas para acelerar el entrenamiento y manejar datos grandes. Su uso general resulta similar a otros estimadores:

from sklearn.ensemble import HistGradientBoostingClassifier

hist_gb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100)
hist_gb.fit(X_train, y_train)
y_pred = hist_gb.predict(X_test)

k-Vecinos más cercanos (k-NN)
El clasificador KNeighborsClassifier se basa en la vecindad de cada punto. No genera un modelo explícito, sino que, al predecir, observa las clases de los k datos más próximos según una métrica de distancia. Esto puede ser adecuado si el conjunto es relativamente pequeño y si la distancia elegida (euclidiana, manhattan, etc.) guarda relación con la naturaleza de los datos.

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

A menudo conviene normalizar las características antes de aplicar k-NN para que todas tengan influencia equiparable en la distancia.

Naive Bayes
Scikit Learn incorpora distintos clasificadores bayesianos como GaussianNB (para variables continuas con distribución normal aproximada), MultinomialNB (especial para recuentos, como en clasificación de textos) y BernoulliNB. Su fundamento radica en la aplicación de la regla de Bayes y la asunción de independencia condicional entre características.

from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred = gnb.predict(X_test)

Gracias a su simplicidad, estos modelos resultan muy rápidos de entrenar y funcionan bien incluso con conjuntos pequeños.

Redes neuronales con MLPClassifier
Aunque Scikit Learn no se centra en redes neuronales complejas, el MLPClassifier (perceptrón multicapa) permite crear una arquitectura con una o varias capas ocultas y funciones de activación como relu o tanh. Su entrenamiento se basa en descensos de gradiente estocásticos e introduce hiperparámetros como el número de neuronas, la tasa de aprendizaje y la regularización.

from sklearn.neural_network import MLPClassifier

mlp = MLPClassifier(hidden_layer_sizes=(100,50), activation='relu', solver='adam', max_iter=300)
mlp.fit(X_train, y_train)
y_pred = mlp.predict(X_test)

Este modelo puede capturar patrones no lineales de manera más flexible, aunque requiere una buena selección de parámetros y de la configuración de las capas.

Evaluación y métricas
Para comprobar la eficacia de un clasificador, existen métricas en sklearn.metrics como accuracy_score, precision_score, recall_score y la métrica F1, que combina precisión y sensibilidad en un único valor. Se emplea también classification_report para obtener un resumen de las métricas por clase y confusion_matrix para visualizar la distribución de predicciones correctas e incorrectas.

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

acc = accuracy_score(y_test, y_pred)
print("Exactitud:", acc)
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

En contextos con clases desbalanceadas, se recomiendan métricas más robustas, como la AUC-ROC o la sensibilidad y la precisión.

Validación y búsqueda de hiperparámetros
Para evaluar la capacidad de generalización, se utiliza la validación cruzada con KFold o StratifiedKFold. Para explorar distintos valores de hiperparámetros, se aplican GridSearchCV (búsqueda exhaustiva) o RandomizedSearchCV (muestras aleatorias), indicando la métrica que se desea optimizar.

from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.svm import SVC

params = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
svc = SVC()
cv = StratifiedKFold(n_splits=5)
grid = GridSearchCV(svc, param_grid=params, cv=cv, scoring='f1_macro')
grid.fit(X_train, y_train)
print("Mejor combinación:", grid.best_params_)

Este procedimiento sistemático garantiza la evaluación honesta del rendimiento y ayuda a encontrar configuraciones de hiperparámetros más óptimas.

Pipelines de clasificación
Con Pipeline, se enlazan transformaciones de preprocesamiento y el clasificador elegido en un solo objeto. Esto asegura que la secuencia de pasos se aplique correctamente, evitando fugas de información y facilitando la reproducción de resultados.

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

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
])
pipe.fit(X_train, y_train)
y_pred = pipe.predict(X_test)

Esta aproximación es recomendable cuando se combinan múltiples etapas, como imputación de valores, codificación de variables y escalado, integrando así el clasificador final.

En definitiva, la clasificación en Scikit Learn abarca desde métodos lineales hasta enfoques complejos de ensamblado y redes neuronales. El vasto surtido de técnicas y la consistencia de la interfaz dan la posibilidad de probar algoritmos distintos y optimizar la estrategia de manera ágil, siempre garantizando la correcta validación y la interpretación adecuada de los resultados.

El aprendizaje no supervisado se concentra en descubrir patrones, estructuras o relaciones en los datos sin contar con etiquetas o valores objetivo. En scikit learn, esta clase de técnicas se emplean para tareas como clustering, reducción de dimensionalidad y métodos de densidad, brindando herramientas que simplifican la búsqueda de agrupaciones o la extracción de información relevante.

A diferencia de los métodos supervisados, no existe una variable de destino predefinida, por lo que el entrenamiento se basa exclusivamente en la similitud y distribución de las características. Estas técnicas resultan especialmente útiles para la exploración de datos, la segmentación de clientes, la detección de anomalías o la compresión de información.

Los algoritmos de clustering son un pilar del aprendizaje no supervisado. El submódulo sklearn.cluster incluye métodos como KMeans, DBSCAN o AgglomerativeClustering, que difieren en su concepción de proximidad y en cómo forman las agrupaciones.

• KMeans: Divide el conjunto en k conglomerados, asignando cada muestra al centroide más cercano.
• DBSCAN: Basa la agrupación en la densidad local de los puntos, lo que permite detectar estructuras arbitrarias y manejar ruido sin necesidad de especificar k.
• AgglomerativeClustering: Crea una jerarquía de clusters mediante un proceso de fusión progresiva de grupos, resultando en dendrogramas que describen la relación entre conglomerados.

Un ejemplo de KMeans puede lucir así:

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)
labels = kmeans.labels_

Aquí, cada fila del array X se asocia a uno de los tres grupos. El número de clusters se elige de manera heurística o mediante criterios como el método del codo (elbow method).

En cuanto a DBSCAN, ajusta la cantidad de clusters en función de dos parámetros esenciales: eps (radio de vecindad) y min_samples (umbral de puntos dentro de la vecindad). Este procedimiento no requiere conocer el número de grupos a priori.

from sklearn.cluster import DBSCAN

dbscan = DBSCAN(eps=0.5, min_samples=5)
dbscan.fit(X)
labels_db = dbscan.labels_

Un valor de -1 en labels_db indica puntos considerados ruido y no asignados a ningún grupo.

Otro ámbito relevante del aprendizaje no supervisado es la reducción de dimensionalidad, con métodos como PCA (análisis de componentes principales), TruncatedSVD o FactorAnalysis. En el submódulo sklearn.decomposition, se combinan distintas técnicas enfocadas a la extracción de factores latentes y la compresión de grandes volúmenes de datos.

PCA descompone la matriz de características en componentes ortogonales, ordenadas según la varianza que explican. Con ello, se pueden representar muchos atributos originales en un menor número de dimensiones, preservando la mayor parte de la información. Un ejemplo:

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

Esta instrucción reduce las características de X a dos componentes principales, lo que facilita la visualización y la exploración.

En problemas donde la matriz de características es muy grande y dispersa (como en el procesamiento de texto), TruncatedSVD puede resultar conveniente, pues maneja con eficiencia estructuras escasas y evita costos de memoria.

Los métodos basados en densidad y estimación de distribución, presentes en submódulos como sklearn.mixture, permiten modelar la distribución de los datos para inferir a qué componente pertenecen o el grado de pertenencia a distintos grupos. GaussianMixture sirve como alternativa probabilística a KMeans, dado que estima componentes gaussianas en lugar de centroides puntuales.

from sklearn.mixture import GaussianMixture

gmm = GaussianMixture(n_components=3, covariance_type='full', random_state=42)
gmm.fit(X)
labels_gmm = gmm.predict(X)

La interpretación de los resultados se lleva a cabo mediante la visualización de la probabilidad de pertenencia de cada punto a las distintas gausianas, lo que aporta más flexibilidad que los métodos de agrupación estricta.

La evaluación de algoritmos no supervisados puede ser compleja, pues no hay etiquetas para comparar. Aun así, se miden criterios internos como la inercia (en KMeans), la silueta (Silhouette Score) o la cohesión de los grupos, junto con métodos externos cuando se dispone de un etiquetado parcial. El módulo sklearn.metrics ofrece funciones como silhouette_score o calinski_harabasz_score que ayudan a cuantificar la calidad de los clusters.

from sklearn.metrics import silhouette_score

score = silhouette_score(X, labels)
print("Índice de silueta:", score)

Cuanto mayor sea el valor, más diferenciados están los clusters respecto a sus vecinos.

El procesamiento de datos antes de aplicar métodos de agrupación o reducción de dimensionalidad resulta vital. A menudo se recurre a la normalización o al escalado con StandardScaler y a la selección de variables relevantes para evitar ruidos que obstaculicen la detección de patrones. Este flujo se integra fácilmente en un Pipeline, lo que garantiza la consistencia de cada etapa y la reproducibilidad de los resultados.

Por último, la implementación de estas técnicas no supervisadas en scikit learn se caracteriza por la misma interfaz simple: instanciación, ajuste con fit o fit_transform y posterior uso con métodos como predict. A su vez, la compatibilidad con estructuras de NumPy y pandas posibilita encadenar distintos pasos con la misma lógica ordenada. Estas herramientas permiten abordar proyectos de minería de datos, agrupación de imágenes o segmentación de clientes, sin tener que construir el ecosistema desde cero y con la garantía de un enfoque modular y bien documentado.

El procesamiento del lenguaje natural (NLP) se centra en manipular y analizar texto de manera automática para extraer información valiosa, clasificar documentos o generar resúmenes. Aunque scikit learn no es una biblioteca especializada exclusivamente en NLP, ofrece herramientas que, combinadas con otras librerías, permiten cubrir casos comunes de clasificación y extracción de características textuales.

Las técnicas de vectorización transforman texto en representaciones numéricas. El submódulo sklearn.feature_extraction.text proporciona clases como CountVectorizer y TfidfVectorizer. Con CountVectorizer, se construye una matriz de recuentos de palabras (bag of words), mientras que TfidfVectorizer ajusta la relevancia de cada término conforme a su frecuencia en el documento y en el corpus completo. Un ejemplo básico sería:

from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [
    "el perro corre en el parque",
    "la gata duerme en el sofá",
    "el ratón come queso en la casa"
]

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)

Este objeto X resulta ser una matriz dispersa donde cada fila representa un documento y cada columna un término, con valores que reflejan la relevancia TF-IDF. Esta representación es fundamental para aplicar algoritmos de aprendizaje automático.

Para clasificar textos, se combinan estos transformadores con un estimador, por ejemplo una regresión logística, en un único Pipeline. De este modo, el proceso de convertir texto a vectores y entrenar el modelo queda unificado. Esto simplifica la fase de predicción, pues al recibir un texto nuevo, el pipeline aplicará la misma vectorización y luego generará la predicción de clase.

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

text_clf = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', LogisticRegression())
])

text_clf.fit(corpus, [0, 1, 2])  # Etiquetas de ejemplo
prediction = text_clf.predict(["el perro come queso"])

Es habitual realizar preprocesamientos adicionales como eliminación de stop words o la transformación a minúsculas. Estas tareas se controlan mediante parámetros del vectorizador, por ejemplo, TfidfVectorizer(stop_words='spanish', lowercase=True), lo que facilita la limpieza básica del texto.

Para situaciones donde la frecuencia de n-gramas sea relevante, se pueden generar 2-grams o 3-grams en lugar de tokens individuales. Este método permite capturar secuencias de palabras. Configurar el parámetro ngram_range=(1,2) en CountVectorizer o TfidfVectorizer es un modo sencillo de incluir dichos patrones en la matriz de características.

La clasificación y la regresión con texto siguen el mismo patrón de scikit learn:

1. Se separan los datos en entrenamiento y prueba.
2. Se crea un pipeline que contiene la vectorización y el modelo.
3. Se ajusta con fit y se evalúa el rendimiento con predict.

El ajuste de hiperparámetros se beneficia del uso de GridSearchCV o RandomizedSearchCV, ya que se pueden variar aspectos como el número máximo de características (max_features), la estrategia de regularización de la regresión logística o la configuración de los n-gramas, entre otros.

En muchos flujos de trabajo de NLP, puede resultar interesante combinar scikit learn con bibliotecas de preprocesamiento más avanzadas que permitan lematizar o etiquetar gramaticalmente las frases. Sin embargo, la naturaleza extensible de los pipelines en scikit learn hace posible integrar transformaciones personalizadas o de terceros antes de la etapa de vectorización.

Para problemas de clusterización de texto o detección de tópicos, también es viable usar TfidfVectorizer en conjunto con algoritmos de agrupamiento. Por ejemplo, aplicando KMeans a la matriz TF-IDF, se identifican grupos de documentos semejantes entre sí. Del mismo modo, se pueden emplear métodos de reducción de dimensionalidad como TruncatedSVD para explorar las relaciones latentes en el espacio vectorial.

Los resultados de la clasificación de texto se evalúan con métricas como accuracy_score, precision_score, recall_score y f1_score. En problemas con clases muy desbalanceadas, se recomienda usar la métrica AUC-ROC o un reporte completo con classification_report. La elección de la métrica dependerá de si se valora más la capacidad de detección de falsos negativos o la proporción de aciertos global.

En consecuencia, la combinación de transformadores de texto (como TfidfVectorizer) con algoritmos de scikit learn (por ejemplo, LogisticRegressión, SVC o RandomForestClassifier) constituye un método flexible para abordar problemas típicos de NLP. La facilidad con la que se definen pipelines y se ponen a prueba distintos modelos convierte a scikit learn en una herramienta esencial en el procesamiento de texto cuando se requiere una solución rápida y modular.

El tratamiento de series temporales se diferencia de otros enfoques de aprendizaje automático por la dependencia que muestran los datos a lo largo del tiempo. A menudo, las observaciones sucesivas influyen en las subsiguientes, por lo que la estructura de los datos cambia con respecto a los supuestos clásicos de independencia entre muestras. Aunque scikit learn no dispone de un módulo específico para series temporales, ofrece diversas herramientas que pueden emplearse para afrontar problemas de predicción o clasificación con datos que presentan una dimensión temporal.

Un método habitual para aplicar algoritmos de scikit learn a series temporales consiste en transformar el problema en una tarea de supervisión estándar. Se construyen atributos (features) a partir de valores pasados y, opcionalmente, de otras variables exógenas, para luego predecir la variable objetivo (por ejemplo, la demanda en el siguiente periodo). Así, se origina un esquema de entrenamiento similar al de regresión o clasificación, pero con la precaución de no mezclar información presente y futura.

Para generar estas variables históricas, se recurre a técnicas de desplazamiento (lagging) que, por ejemplo, crean columnas que representan los valores de la serie en instantes anteriores. Un ejemplo simple de ingeniería de atributos para predecir ( y_{t} ) utilizando los valores anteriores ( y_{t-1} ) y ( y_{t-2} ) puede plasmarse en pandas o NumPy, y una vez construido este conjunto de datos, se emplea el esquema habitual de scikit learn:

import numpy as np

## Suponiendo series_values como un array 1D con los valores de la serie
X = []
y = []
lag = 2

for i in range(lag, len(series_values)):
    X.append(series_values[i-lag:i])  # valores de la serie en t-2 y t-1
    y.append(series_values[i])        # valor actual en t

X = np.array(X)
y = np.array(y)

## X e y se usan luego con estimadores de scikit learn

Una vez calculadas estas matrices X (características) e y (etiquetas), se puede aplicar cualquier regressor de scikit learn como LinearRegressión, RandomForestRegressor o HistGradientBoostingRegressor. El paso crucial es separar apropiadamente los datos en entrenamiento y validación, respetando la naturaleza temporal.

Para evitar fugas de información al generar subconjuntos de entrenamiento y prueba, conviene ordenar los datos cronológicamente y luego usar el submódulo sklearn.model_selection con TimeSeriesSplit. Este esquema reparte el conjunto de datos de manera que se respeten las líneas temporales y no se solape información futura en el entrenamiento. Un ejemplo de aplicación sencilla:

from sklearn.model_selection import TimeSeriesSplit
from sklearn.linear_model import Ridge

tscv = TimeSeriesSplit(n_splits=3)
model = Ridge()

for train_index, test_index in tscv.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    model.fit(X_train, y_train)
    score = model.score(X_test, y_test)
    print("Score en test:", score)

Con esta validación cruzada, se crea una sucesión de divisiones en las que el conjunto de prueba siempre se sitúa después del conjunto de entrenamiento, reflejando el paso del tiempo de forma coherente. Este enfoque ayuda a estimar la capacidad de generalización y a detectar si el modelo puede adaptarse bien a los datos por venir.

La integración con pipelines también puede ser ventajosa cuando se necesita realizar transformaciones sobre la serie (por ejemplo, escalados, imputaciones de valores faltantes o generación de variables adicionales) sin mezclar datos futuros. El objeto Pipeline permite unificar la ingeniería de características y el estimador en un único flujo. Sin embargo, en series temporales hay que tener especial cuidado al ajustar los transformadores con datos que no incluyan información del futuro.

En muchos casos, la variabilidad de las series temporales se ve afectada por tendencias a largo plazo o estacionalidades periódicas (por ejemplo, patrones diarios, semanales o anuales). Para modelar dichas estructuras, se recurre a la creación de atributos que representen la estacionalidad:

• Índices de la hora del día, día de la semana o mes del año.
• Variables binarias que identifiquen momentos especiales (festivos, fines de semana, etc.).
• Transformaciones trigonométricas para capturar periodicidades, como el uso de sin y cos de la posición en el ciclo.

Otro aspecto clave al trabajar con series temporales en scikit learn es la homogeneización de la escala, pues los datos suelen presentar diferencias de magnitud a lo largo del tiempo. Utilizar transformadores como StandardScaler o MinMaxScaler puede ayudar a estabilizar el entrenamiento de modelos sensibles a la escala de las variables. Un ejemplo de pipeline con escalado y un regresor:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('regressor', LinearRegression())
])

A la hora de predecir valores múltiples a futuro (por ejemplo, horizontes de varios pasos), existen estrategias como la predicción encadenada (recursiva), donde se utiliza la salida del modelo en el instante ( t+1 ) para predecir ( t+2 ), y así sucesivamente. Otra técnica posible es entrenar un modelo directo para cada horizonte específico, de modo que se aprende directamente la relación entre las características y un futuro ( t+k ). Ambas aproximaciones pueden implementarse con scikit learn a partir del diseño adecuado de los conjuntos de datos y la iteración sobre los pasos de predicción.

Cuando la serie presenta anomalías o puntos atípicos, los modelos de scikit learn pueden combinarse con funciones de detección de outliers, como IsolationForest o LocalOutlierFactor, para descubrir comportamientos extraños y limpiarlos o ajustarlos antes de la predicción. Esto puede ser especialmente útil en dominios como detección de fraudes o supervisión industrial.

Si el objetivo de la modelización no es la regresión de valores sino la categorización de estados (por ejemplo, clasificación de un instante como "alerta" o "normal"), se puede convertir el problema en una clasificación supervisada. Cada ventana temporal se etiqueta con la categoría correspondiente, y se utilizan algoritmos como RandomForestClassifier o SVC para establecer la frontera de decisión.

En el caso de análisis avanzado de series temporales, se tiende a integrar scikit learn con librerías especializadas que ofrecen modelos ARIMA, SARIMA o métodos específicos de previsión. Sin embargo, la fortaleza de scikit learn reside en su robustez para el aprendizaje supervisado y la facilidad de crear pipelines para manipular las variables temporales y combinarlas con algoritmos de regresión o clasificación.

La evaluación de los modelos entrenados con series temporales suele basarse en métricas de error como el error absoluto medio (MAE), el error cuadrático medio (MSE) o el error porcentual absoluto medio (MAPE), y varía en función de la naturaleza de la tarea y de la escala de los datos. Por ejemplo, en un escenario de demanda energética, se podría priorizar la MAPE para obtener la desviación porcentual con respecto a la demanda real. En un sistema de detección de fallos, en cambio, podría convenir la precisión (accuracy) o la sensibilidad (recall), típicas de problemas de clasificación.

El proceso de experimentación y validación requiere, en último término, esquemas temporales que eviten la contaminación de información desde el futuro al pasado. Por ello, TimeSeriesSplit se convierte en un aliado fundamental para ajustarse a la lógica cronológica. Al terminar las pruebas, es habitual que se seleccione la configuración de hiperparámetros que haya arrojado los resultados más adecuados a la métrica de interés y que se entrene el modelo definitivo con toda la ventana temporal disponible, reservando únicamente la parte más reciente como validación final.

La manipulación de los datos para convertirlos en un conjunto de entrenamiento y prueba, junto con la estructuración de pipelines, otorga a scikit learn la flexibilidad necesaria para abordar problemas de series temporales en ámbitos muy diversos. Se puede así conjugar la potencia de sus algoritmos de regresión y clasificación con la compatibilidad de pandas y NumPy para la construcción de atributos basados en el tiempo, la detección de outliers y la generación de validaciones coherentes con la dimensión temporal.

Este enfoque es especialmente indicado para escenarios donde se parte de un volumen considerable de datos históricos y se desea aprovechar la familiaridad con scikit learn. Aunque existen bibliotecas más enfocadas en series temporales, la combinación de transformaciones personalizadas, validación adecuada y pipelines con scikit learn ofrece un entorno sólido para prototipos y soluciones basadas en predicciones a corto o mediano plazo.

La validación de modelos es un paso esencial en el proceso de aprendizaje automático, pues permite estimar la capacidad de generalización que alcanzará el sistema al enfrentarse a datos nuevos. En scikit learn, la validación se apoya en diversos métodos y funciones del submódulo sklearn.model_selection, que incluye desde la simple división train/test hasta la validación cruzada. El fin principal de estas técnicas es aportar una visión honesta del rendimiento que ofrecerá el modelo, evitando que se establezcan conclusiones excesivamente optimistas.

El esquema más básico es la separación en dos subconjuntos: entrenamiento (train) y prueba (test). Con train_test_split, se deja un porcentaje de datos para entrenar el modelo y otro para evaluarlo. Por ejemplo, reservar el 80% para entrenamiento y el 20% para prueba:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LogisticRegression()
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
print("Exactitud en test:", score)

Este método resulta sencillo, pero depende de la aleatoriedad de una única partición. Cambiar la semilla (random_state) o el tamaño de la partición puede conducir a variaciones en la estimación de rendimiento.

Para ganar mayor fiabilidad, se recurre a la validación cruzada (cross-validation), donde se dividen los datos en k partes (folds) y se realiza una rotación en la que cada fold funciona de forma alternada como subconjunto de prueba. Una vez completadas las k iteraciones, se calcula la media de las métricas obtenidas. Con sklearn.model_selection.cross_val_score, se agiliza la aplicación de este procedimiento.

from sklearn.model_selection import cross_val_score, KFold
from sklearn.svm import SVC

cv = KFold(n_splits=5, shuffle=True, random_state=42)
svc = SVC(kernel='linear', C=1.0)
scores = cross_val_score(svc, X, y, cv=cv, scoring='accuracy')
print("Exactitud media:", scores.mean())

La validación cruzada reduce la varianza de la estimación, ya que cada muestra es empleada tanto para entrenamiento como para prueba en diferentes iteraciones. Además, es posible equilibrar la distribución de clases con StratifiedKFold, muy útil cuando se trabaja con problemas de clasificación desbalanceados.

En situaciones donde se desea optimizar o buscar hiperparámetros (por ejemplo, C en SVM o la profundidad de un árbol), scikit learn dispone de GridSearchCV y RandomizedSearchCV. Estos métodos combinan la búsqueda de parámetros y la validación cruzada, ajustando distintas configuraciones y evaluándolas de manera sistemática para encontrar la que ofrece un mayor rendimiento.

from sklearn.model_selection import GridSearchCV

param_grid = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid_search = GridSearchCV(svc, param_grid=param_grid, cv=5, scoring='accuracy')
grid_search.fit(X, y)
print("Mejor combinación:", grid_search.best_params_)
print("Mejor puntuación:", grid_search.best_score_)

Cuando se aplican estos enfoques, es importante evitar la fuga de información, sobre todo si antes se hace un preprocesamiento o selección de características. Para ello, se recomienda estructurar el flujo completo en un Pipeline, de modo que las transformaciones se ajusten solo con los datos de entrenamiento en cada fold, sin contaminar los datos de prueba.

Existen también variantes específicas como Leave-One-Out Cross-Validation (LOOCV), donde cada instancia se emplea como conjunto de prueba, y el resto conforman el conjunto de entrenamiento. Esto ofrece un uso muy intensivo de los datos, pero conlleva un coste computacional alto y tiende a presentar mayor varianza en la estimación.

En problemas de series temporales, no basta con barajar aleatoriamente, ya que la información cronológica no puede mezclarse libremente. Con TimeSeriesSplit, cada partición se organiza de manera que el conjunto de entrenamiento siempre preceda temporalmente al de prueba. Este procedimiento evita mirar hacia el futuro durante el entrenamiento y refleja más fielmente el rendimiento que se obtendría en el mundo real.

from sklearn.model_selection import TimeSeriesSplit

tss = TimeSeriesSplit(n_splits=5)
for train_index, test_index in tss.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    model.fit(X_train, y_train)
    score = model.score(X_test, y_test)
    print("Score temporal:", score)

Además de los esquemas de partición, la selección de la métrica adecuada es determinante para evaluar el comportamiento de un modelo. Clásicamente se emplean accuracy_score o mean_squared_error, pero en contextos con clases muy desequilibradas conviene monitorizar la sensibilidad (recall) o la puntuación F1, mientras que en tareas de regresión con escalas desiguales se recurre a métricas relativas como el MAPE (error porcentual absoluto medio).

En experimentos extensos, puede ser útil la validación cruzada anidada (nested cross-validation). La capa externa de validación cruzada calcula el rendimiento, y en cada pliegue se ejecuta internamente un proceso de búsqueda de hiperparámetros con GridSearchCV o RandomizedSearchCV. Este esquema reduce el sesgo en la estimación de la puntuación final, si bien eleva considerablemente el coste computacional.

from sklearn.model_selection import cross_val_score, KFold

outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)
scores_nested = cross_val_score(grid_search, X, y, cv=outer_cv, scoring='accuracy')
print("Puntuación media en validación anidada:", scores_nested.mean())

Para la mayoría de proyectos, combinar un esquema de validación cruzada estratificado (o adaptado a series temporales) con la búsqueda de hiperparámetros y el uso de pipelines es suficiente para obtener resultados fiables. Sin embargo, si el conjunto de datos es muy pequeño, se pueden aplicar métodos exhaustivos como LOOCV y, si es muy grande, se suele optar por prácticas más rápidas como train_test_split repetido con diferentes particiones.

De este modo, scikit learn aporta un marco sólido de validación que, aplicado metódicamente, evita conclusiones engañosas y permite comparar distintos modelos con rigor. La elección final de un procedimiento de validación depende de la estructura de los datos, de la métrica de interés y de los recursos computacionales disponibles. Con la variedad de herramientas que ofrece la biblioteca, cada proyecto puede configurarse para alcanzar el equilibrio justo entre eficiencia y exactitud.

El desarrollo de pipelines en Scikit Learn unifica y automatiza los pasos de preprocesamiento, selección de características y entrenamiento en un mismo objeto, garantizando coherencia y reduciendo el riesgo de fugas de información. Además, su estructura modular facilita la experimentación y la aplicación de transformaciones tanto en entrenamiento como en inferencia.

Para configurar un pipeline, se emplea la clase Pipeline del submódulo sklearn.pipeline. Se definen etapas como tuplas con el nombre del paso y el objeto que lo ejecuta. El último paso suele ser un estimador (por ejemplo, un modelo de clasificación o regresión), mientras que los pasos anteriores corresponden a transformadores (por ejemplo, escalado, imputación o codificación de variables categóricas). Un ejemplo sencillo sería:

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

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
])

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

Este patrón resulta útil porque el escalador se entrena con los datos de entrenamiento y luego se aplica de manera consistente al conjunto de prueba y a cualquier dato futuro. De este modo, se evita calcular estadísticas (como la media y desviación típica) con información del test, lo que podría llevar a sobreestimar el rendimiento real.

El pipeline también se integra con herramientas de búsqueda de hiperparámetros como GridSearchCV. Cada paso del pipeline puede incluir hiperparámetros que se optimizan de forma conjunta, empleando notaciones que especifican el nombre del paso y el parámetro. Por ejemplo:

from sklearn.model_selection import GridSearchCV

param_grid = {
    'scaler__with_mean': [True, False],
    'classifier__C': [0.1, 1, 10]
}

grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print("Mejor configuración:", grid_search.best_params_)
print("Puntuación en validación:", grid_search.best_score_)

Mediante el prefijo scaler__ o classifier__, se hace referencia al paso del pipeline y a la propiedad que se desea ajustar. Esto permite sintonizar con precisión toda la cadena de transformadores y el estimador final.

Además de Pipeline, Scikit Learn incluye herramientas como ColumnTransformer o FeatureUnion para manejar datos con columnas heterogéneas o combinar transformaciones diferenciadas. ColumnTransformer facilita aplicar distintos transformadores en subconjuntos de columnas, mientras que FeatureUnion concatena varias transformaciones en paralelo y entrega un único array de características para el estimador posterior.

Una vez completado el entrenamiento, el pipeline se puede persistir en disco para su uso en producción. Scikit Learn recomienda la serialización con joblib, pues maneja objetos grandes y estructuras de numpy de forma más eficiente que otros métodos. Un ejemplo de guardado:

import joblib

joblib.dump(pipeline, 'modelo_entrenado.pkl')

Para recuperar el pipeline entrenado en un momento posterior, se utiliza:

modelo_cargado = joblib.load('modelo_entrenado.pkl')
predicciones = modelo_cargado.predict(X_nuevos)

Este proceso simplifica el despliegue de modelos, dado que con un solo objeto se encapsula todo el flujo: desde la limpieza y transformación de datos hasta la inferencia final.

En la práctica, el despliegue de un pipeline entrenado puede hacerse en múltiples entornos, por ejemplo:

• Scripts o servicios de backend que cargan el pipeline y reciben peticiones de inferencia.
• Servidores con marcos web (Flask, FastAPI, Django) que proveen endpoints de predicción.
• Contenedores Docker que integran el pipeline y sus dependencias, listos para ejecutarse en la nube o en un clúster.

Para asegurar la consistencia entre el entorno de entrenamiento y el de despliegue, se recomienda anotar la versión de Python, de scikit learn y de librerías relacionadas en un fichero de requisitos, lo que evita problemas de incompatibilidad. Una vez que el pipeline está empaquetado y las dependencias definidas, se traslada a producción con relativa facilidad.

Al poner en marcha un pipeline en un entorno de producción, puede resultar necesario contar con un sistema de monitorización, capaz de detectar cambios en la distribución de los datos (data drift) o degradaciones en la precisión del modelo. Esto facilita el rediseño de la tubería de datos y el reentrenamiento del pipeline cuando se observa un deterioro significativo de su rendimiento.

Otra ventaja de los pipelines en Scikit Learn es su integración con herramientas externas que implementan prácticas de MLOps, manteniendo rastreables las versiones de datos, modelos y resultados de experimentos. Aunque la biblioteca no proporciona una solución nativa para la gestión de proyectos end-to-end, la posibilidad de persistir pipelines y de orquestar transformaciones con facilidad facilita la adopción de soluciones que organicen la operación y el ciclo de vida de los modelos.

En definitiva, los pipelines permiten agrupar cada fase del proceso de aprendizaje automático en un único objeto que se entrena, evalúa, persiste y despliega de forma integral. Gracias a la unificación del preprocesamiento y el modelo, las predicciones posteriores se realizan con seguridad y reproducibilidad, evitando inconsistencias en la aplicación de transformaciones. A su vez, el despliegue de estos pipelines puede llevarse a cabo en múltiples escenarios, siempre que se conserven las librerías y versiones adecuadas para su correcto funcionamiento.

El ecosistema de Scikit-learn no termina en sus estimadores nativos. Los proyectos reales de aprendizaje automático combinan la biblioteca con librerías hermanas que siguen su misma API (fit, predict, compatibilidad con Pipeline) y que cubren tres necesidades críticas del ciclo de vida de un modelo: rendimiento, explicabilidad y trazabilidad.

En este módulo aprenderás a integrar en un flujo de Scikit-learn las bibliotecas de boosting de alto rendimiento (XGBoost, LightGBM, CatBoost), a explicar las predicciones de cualquier modelo con SHAP y a registrar experimentos con MLflow para comparar versiones, hiperparámetros y métricas de forma reproducible.

La clave conceptual es que, pese a tratarse de proyectos independientes, todas estas librerías respetan el patrón de Scikit-learn: puedes usarlas como último paso de un Pipeline, optimizar sus hiperparámetros con GridSearchCV o HalvingRandomSearchCV, y evaluarlas con cross_val_score y las métricas estándar (roc_auc_score, f1_score, mean_absolute_error). Esa interoperabilidad es lo que convierte a Scikit-learn en el eje del stack de ciencia de datos en Python.

Además, el módulo cierra el curso con una visión de MLOps: el conjunto de prácticas y herramientas para llevar modelos a producción de forma sostenible. Verás cómo registrar un experimento con MLflow, cómo usar mlflow.sklearn.autolog() para capturar automáticamente parámetros, métricas y artefactos, y cómo servir un modelo registrado desde un endpoint HTTP con mlflow models serve.