El "Efecto Palanca" en Machine Learning: ¿Por Qué Tus Datos Deberían Empezar con un K-Means?

Una guía técnica sobre cómo mejorar la precisión de tus modelos (y tu perfil profesional) usando Clustering como paso previo.

Hay una frase que repito en las clases de Python Baires: "Un modelo no es más que la calidad de los datos que le alimentas". Y la calidad no es solo limpiar nulos. Es enriquecer.

La mayoría de los programadores que inician en Machine Learning se obsesionan con el algoritmo final: "¿Uso Regresión Lineal o XGBoost?". Se olvidan de una etapa crítica que puede hacer que un modelo mediocre dé saltos de calidad increíble: la ingeniería de características (Feature Engineering) mediante Machine Learning No Supervisado.

Hoy te voy a mostrar cómo usar un algoritmo de clustering (K-Means) no para "agrupar cosas", sino para generar una columna nueva que le dé un superpoder a tu modelo predictivo.

El Problema Real: La Linealidad Engañosa

Imaginemos que trabajamos en una EdTech (como la nuestra). Tenemos datos de estudiantes: horas_estudiadas, puntaje_ejercicios, y queremos predecir si aprobarán un examen final (exito).

Si usamos un modelo lineal simple, asume que a más horas de estudio, más probabilidad de éxito. Pero en la realidad, los estudiantes tienen perfiles distintos:

1. Diligentes: Estudian mucho, van bien.
2. Brillantes: Estudian poco, pero captan rápido.
3. Brillantes pero perezosos: (Zona gris).
4. En riesgo: Estudian mucho pero no entienden.

Si no le decimos al modelo explícitamente que existen estos grupos, se confundirá. Vamos a arreglarlo.

Paso 1: Simulando Datos Reales (con Patrones Ocultos)

Generaremos datos donde existen 3 perfiles ocultos. Queremos que el modelo los descubra por sí solo.

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

np.random.seed(42)

# Generamos 3 grupos de estudiantes
# Grupo A (Diligentes): Muchas horas, buen puntaje
n_a = 100
horas_a = np.random.normal(20, 3, n_a)
puntaje_a = np.random.normal(85, 5, n_a)
exito_a = np.random.choice([0, 1], size=n_a, p=[0.1, 0.9]) # Casi todos aprueban

# Grupo B (Brillantes/Perezosos): Pocas horas, buen puntaje
n_b = 100
horas_b = np.random.normal(5, 2, n_b)
puntaje_b = np.random.normal(80, 5, n_b)
exito_b = np.random.choice([0, 1], size=n_b, p=[0.3, 0.7]) 

# Grupo C (En Riesgo): Horas medias, puntaje bajo
n_c = 100
horas_c = np.random.normal(15, 4, n_c)
puntaje_c = np.random.normal(60, 8, n_c)
exito_c = np.random.choice([0, 1], size=n_c, p=[0.7, 0.3]) # Muchos fallan

# Concatenamos todo
df = pd.DataFrame({
    'horas_estudio': np.concatenate([horas_a, horas_b, horas_c]),
    'puntaje_ejercicios': np.concatenate([puntaje_a, puntaje_b, puntaje_c]),
    'exito': np.concatenate([exito_a, exito_b, exito_c])
})

# Barajamos los datos (simular que no sabemos los grupos)
df = df.sample(frac=1).reset_index(drop=True)

X = df[['horas_estudio', 'puntaje_ejercicios']]
y = df['exito']

print("Datos generados. Sin etiquetas de 'tipo de estudiante':")
print(df.head())

Paso 2: El Truco - Usando K-Means para Crear "Palanca"

Aquí está la magia. No vamos a predecir nada todavía. Vamos a entrenar un K-Means para que encuentre los 3 grupos en los datos. Luego, usaremos la etiqueta de ese grupo como una nueva característica (feature).

# 1. Escalamos los datos (K-Means es sensible a la escala)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. Aplicamos K-Means para detectar los perfiles (3 clusters)
# Esto es Unsupervised Learning
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
kmeans.fit(X_scaled)

# 3. Añadimos la etiqueta del cluster como una nueva columna "palanca"
# Esto le da al modelo futuro información sobre el "comportamiento" del estudiante
df['perfil_estudiante'] = kmeans.labels_

print("\nDatos enriquecidos con el 'Perfil' detectado:")
print(df.groupby('perfil_estudiante').mean())
print("\nObserva cómo el perfil 0 tiene alta salida (éxito), mientras que el 2 tiene baja salida.")

Paso 3: Comparando Modelos (Antes vs. Después)

Ahora entrenaremos dos modelos simples (Regresión Logística) para ver la diferencia de rendimiento.

1. Modelo Base: Solo usa horas y puntaje.
2. Modelo Palanca: Usa horas, puntaje + perfil_estudiante.

# --- MODELO BASE (Sin la nueva feature) ---
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model_base = LogisticRegression()
model_base.fit(X_train, y_train)
pred_base = model_base.predict(X_test)

# --- MODELO CON PALANCA (Con la nueva feature) ---
# Definimos X con la nueva columna
X_enhanced = df[['horas_estudio', 'puntaje_ejercicios', 'perfil_estudiante']]

Xe_train, Xe_test, ye_train, ye_test = train_test_split(X_enhanced, y, test_size=0.2, random_state=42)

model_enhanced = LogisticRegression()
model_enhanced.fit(Xe_train, ye_train)
pred_enhanced = model_enhanced.predict(Xe_test)

# --- RESULTADOS ---
print("\n--- COMPARACIÓN DE RENDIMIENTO ---")
print(f"Exactitud Modelo Base:      {accuracy_score(y_test, pred_base):.4f}")
print(f"Exactitud Modelo Palanca:   {accuracy_score(ye_test, pred_enhanced):.4f}")

print("\n--- DETALLE MODELO PALANCA ---")
print(classification_report(ye_test, pred_enhanced))

Resultado esperado: El Modelo Palanca tendrá una exactitud (accuracy) significativamente mayor. El modelo base se confunde con los estudiantes que estudian mucho pero tienen bajo rendimiento (Grupo C). El modelo enriquecido identifica ese grupo como "Perfil 2" y ajusta la predicción correctamente.

La Brecha de Conocimiento

Lo que acabamos de hacer se conoce como Feature Engineering basado en Algoritmos. En proyectos reales, esto escala a:

• Usar embeddings de texto (NLP) para enriquecer modelos tabulares.
• Detectar anomalías financieras antes de predecir la probabilidad de fraude.
• Reducir la dimensionalidad (PCA) antes de meter datos a un modelo pesado.

No es solo "aprender librerías". Es pensar como un científico de datos.

El Siguiente Paso

En la industria, los algoritmos son baratos. Lo caro (y escaso) es saber qué features generar para que tu modelo aprenda mejor. En Python Baires no solo te enseñamos a programar KMeans. Te enseñamos a pensar en arquitecturas de datos.

Si querés dejar de intentar ajustar parámetros a ciegas y empezar a diseñar soluciones inteligentes que los modelos simples no pueden ver, tenés que dominar estos conceptos.

En nuestro curso de Machine Learning, vemos técnicas avanzadas de Feature Engineering, selección de modelos y despliegue desde el día uno.

Mirá el programa completo y reservá tu lugar:
👉 https://www.python-baires.ar/Curso-ml.html