Primer modelo de clasificación

El flujo mínimo de clasificación

Un problema de clasificación consiste en predecir una categoría discreta. En Iris, por ejemplo, el modelo recibe medidas de una flor y predice una de tres especies posibles.

El primer flujo útil no necesita todavía un gran preprocesado. Necesita entender cuatro acciones: separar datos, entrenar, predecir y medir.

from sklearn.datasets import load_iris

iris = load_iris(as_frame=True)
X = iris.frame.drop(columns="target")
y = iris.frame["target"]

La variable X contiene la información disponible antes de decidir. La variable y contiene la respuesta histórica que el modelo usará para aprender.

Para comprobar si el modelo generaliza, no se evalúa con los mismos datos usados para entrenar. Primero se reserva una parte como 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,
)

El parámetro stratify=y mantiene una proporción similar de clases en entrenamiento y prueba. En clasificación suele ser una buena práctica cuando las clases no deben quedar descompensadas por azar.

Entrenar con fit y predecir con predict

En Scikit-learn, un estimador de clasificación suele exponer dos métodos esenciales: fit() para aprender desde datos históricos y predict() para producir clases sobre datos nuevos.

Usaremos un árbol de decisión poco profundo porque permite entrenar un primer modelo sin escalado previo y con pocos parámetros.

from sklearn.tree import DecisionTreeClassifier

modelo = DecisionTreeClassifier(max_depth=3, random_state=42)
modelo.fit(X_train, y_train)

La llamada a fit(X_train, y_train) ajusta el modelo usando las variables predictoras de entrenamiento y las clases reales asociadas. A partir de ese momento, el objeto modelo ya contiene reglas aprendidas.

y_pred = modelo.predict(X_test)

print(y_pred[:10])
print(y_test.head(10).to_numpy())

flowchart LR
    train["Datos de entrenamiento"] --> fit["fit"]
    fit --> model["Modelo entrenado"]
    test["Datos de prueba"] --> predict["predict"]
    model --> predict
    predict --> metric["Métrica"]

fit() aprende usando respuestas conocidas. predict() aplica lo aprendido a filas que el modelo no ha visto durante el entrenamiento.

Medir el primer resultado

La métrica más sencilla en clasificación es accuracy, que mide el porcentaje de predicciones correctas. No siempre es la métrica adecuada en problemas reales, pero sí sirve para cerrar el primer circuito mental.

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.3f}")

Si el valor es 0.895, significa que el modelo acertó aproximadamente el 89,5 % de las muestras del conjunto de prueba. Ese número no debe leerse como una garantía absoluta, sino como una estimación sobre los datos reservados.

También conviene mirar algunas predicciones junto a su etiqueta real:

resultado = X_test.copy()
resultado["real"] = y_test
resultado["prediccion"] = y_pred
resultado["acierto"] = resultado["real"] == resultado["prediccion"]

print(resultado.head())

Este enfoque ayuda a ver el modelo como una pieza del flujo de datos, no como una caja mágica. Primero hay datos, después entrenamiento, después predicciones y finalmente una medición.

Interpretar el resultado sin precipitarse

Un primer modelo con buen accuracy no significa que el problema esté resuelto. Puede que el dataset sea pequeño, que la separación entre clases sea muy clara o que el conjunto de prueba no represente bien casos futuros.

Para una primera lectura, basta con hacerse tres preguntas:

• Qué ha aprendido el modelo: en este caso, reglas sobre medidas de pétalos y sépalos.
• Dónde se ha evaluado: en datos separados con train_test_split.
• Cómo se ha medido: con accuracy_score, una métrica básica de acierto.

Estas tres preguntas acompañan a casi cualquier proyecto de aprendizaje supervisado, aunque más adelante cambien el modelo, la métrica o el tipo de datos.