Estoy explorando los marcos de evaluación de modelos de IA

Hola a todos, Nina aquí, de regreso en agntbox.com! Es 13 de marzo de 2026, y si eres como yo, tu bandeja de entrada probablemente esté desbordante de anuncios sobre nuevas herramientas de IA. El ritmo de la innovación es simplemente increíble, ¿verdad?

Hoy quiero hablar sobre algo que ha estado en mi mente durante un tiempo, especialmente después de un par de noches tarde luchando con un proyecto en particular. Vamos a explorar el mundo de la evaluación de modelos de IA, enfocándonos específicamente en un marco que ha estado ganando tracción: APIs de Evaluación de Modelos de MLflow. Ahora, sé lo que algunos de ustedes están pensando: “¿MLflow? ¿No es eso para MLOps y seguimiento?” Y sí, absolutamente lo es. Pero han implementado silenciosamente algunas capacidades de evaluación muy bien pensadas que creo que merecen un vistazo más de cerca, especialmente cuando intentas ir más allá de simplemente observar una única puntuación de precisión.

Para contextualizar, recientemente terminé un proyecto para un cliente que involucraba un modelo de análisis de sentimientos personalizado para comentarios de clientes. El cliente no solo estaba interesado en un sentimiento “bueno” o “malo”; necesitaban información matizada sobre por qué un sentimiento era positivo o negativo, y cuán consistentemente se desempeñaba el modelo en diferentes categorías de productos. Mi enfoque inicial, como a menudo ocurre, fue hacer algunos scripts en Python, calcular algunas métricas y volcarlas en un CSV. Ya sabes cómo es: `sklearn.metrics` para precisión, precisión, recuperación, F1, tal vez un gráfico de matriz de confusión con Matplotlib. Funciona, está bien. Pero luego el cliente pidió una comparación contra un modelo base, y luego otra iteración, y de repente tenía una docena de CSVs y gráficos, todos ligeramente diferentes, y ninguna manera clara de compararlos sistemáticamente.

Ahí fue cuando recordé haber visto algo sobre las características de evaluación ampliadas de MLflow. Había estado usando MLflow para el seguimiento de experimentos durante ages, pero no había realmente profundizado en el lado de la evaluación. Y déjame decirte, fue un momento de revelación. En lugar de reinventar la rueda para cada comparación, podía integrar mi evaluación directamente en mis ejecuciones de MLflow existentes, haciendo que todo estuviera mucho más organizado y comparable.

Más Allá de una Única Métrica: Por Qué la Evaluación Estructurada Importa

Seamos realistas: cuando estás construyendo modelos de IA, especialmente para aplicaciones en el mundo real, una única puntuación de precisión rara vez cuenta toda la historia. Necesitas entender:

• Sesgo: ¿Tu modelo se desempeña igual de bien entre diferentes grupos demográficos, categorías de productos o tipos de entrada?
• solidez: ¿Cómo maneja datos ruidosos o ligeras variaciones en la entrada?
• Explicabilidad: ¿Puedes entender por qué el modelo hizo una predicción en particular?
• Modos de Falla Específicos: ¿Dónde se equivoca consistentemente?

Mi proyecto de análisis de sentimientos destacó esto perfectamente. Una precisión general del 85% se veía bien sobre el papel. Pero cuando lo desglosamos por categoría de producto, encontramos que el modelo tenía problemas significativos con los comentarios relacionados con “soporte técnico”, clasificando erróneamente experiencias negativas como neutras. Sin una forma estructurada de evaluar y comparar, detectar estos problemas habría sido un gran dolor de cabeza.

El Enfoque Tradicional: Bueno, Pero Desorganizado

Antes de profundizar en MLflow, reconozcamos rápidamente la forma estándar en que a menudo hacemos esto. Generalmente implica un bucle, algunos cálculos de métricas, y luego agregación manual. Algo como esto:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
# ... otros imports ...

# Supongamos que X, y son tus características y etiquetas
# X_train, X_test, y_train, y_test = train_test_split(...)

# Un modelo de ejemplo
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)

# Calcular métricas
accuracy = accuracy_score(y_test, predictions)
precision = precision_score(y_test, predictions, average='weighted')
recall = recall_score(y_test, predictions, average='weighted')
f1 = f1_score(y_test, predictions, average='weighted')

print(f"Precisión: {accuracy:.4f}")
print(f"Precisión: {precision:.4f}")
print(f"Recuperación: {recall:.4f}")
print(f"Puntuación F1: {f1:.4f}")

# Luego podrías guardar esto en un CSV, graficar una matriz de confusión, etc.
# metrics_df = pd.DataFrame({"métricas": ["precisión", "precisión", "recuperación", "f1"],
# "valor": [accuracy, precision, recall, f1]})
# metrics_df.to_csv("model_metrics_v1.csv", index=False)

Esto está bien para una única ejecución, pero imagina hacer esto para 10 modelos diferentes, o 5 versiones diferentes del mismo modelo, con diferentes hiperparámetros. Terminas con `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, y así sucesivamente. Se vuelve complicado rápidamente.

APIs de Evaluación de Modelos de MLflow: Una Nueva Perspectiva

Las capacidades de evaluación de modelos de MLflow tienen como objetivo brindar estructura y estandarización a este proceso. La idea central es que cuando registras un modelo con `mlflow.log_model()`, también puedes activar una ejecución de evaluación que almacena métricas, gráficos e incluso artefactos de evaluación personalizados junto a tu modelo. Esto significa que todos tus resultados de evaluación están directamente vinculados a la versión del modelo y ejecución del experimento que los produjo.

Los actores clave aquí son `mlflow.evaluate()` y las clases `mlflow.models.EvaluationMetric` y `mlflow.models.EvaluationArtifact`. Vamos a desglosar cómo utilicé esto para mi proyecto de análisis de sentimientos.

Ejemplo 1: Integración Básica de Evaluación

Primero, necesitas tu modelo y algunos datos de prueba. Para mi modelo de sentimientos, tenía un objeto `pipeline` (un pipeline de scikit-learn con un TfidfVectorizer y un clasificador de LogisticRegression) y un `test_df` con columnas `text` y `true_sentiment`.

import mlflow
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt
import numpy as np

# Supongamos que tienes tus datos cargados
# Para mostrar, vamos a crear algunos datos de ejemplo
data = {
 'text': [
 "¡El producto es increíble, me encanta!",
 "Servicio terrible, muy lenta respuesta.",
 "Está bien, nada especial.",
 "La mejor compra de todas, lo recomiendo mucho.",
 "El soporte al cliente fue inútil y grosero.",
 "Funciona como se esperaba, bastante estándar.",
 "¡Estoy absolutamente encantado con este dispositivo!",
 "Roto al llegar, muy decepcionado.",
 "Calidad decente por el precio.",
 "¡Una experiencia tan genial!",
 "Peor experiencia, nunca más.",
 "Sentimiento neutral sobre esto, ni mal ni bueno."
 ],
 'sentiment': [
 'positivo', 'negativo', 'neutral', 'positivo', 'negativo',
 'neutral', 'positivo', 'negativo', 'neutral', 'positivo',
 'negativo', 'neutral'
 ]
}
df = pd.DataFrame(data)

# Dividir los datos
X_train, X_test, y_train, y_test = train_test_split(
 df['text'], df['sentiment'], test_size=0.3, random_state=42, stratify=df['sentiment']
)

# Crear un pipeline simple
pipeline = Pipeline([
 ('tfidf', TfidfVectorizer()),
 ('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)

# Preparar datos de prueba como un DataFrame para mlflow.evaluate
test_df = pd.DataFrame({'text': X_test, 'true_sentiment': y_test})

with mlflow.start_run(run_name="Evaluación_Modelo_Sentimientos_v1") as run:
 # Registrar el modelo (opcional, pero buena práctica)
 mlflow.sklearn.log_model(pipeline, "sentiment_model")

 # Realizar evaluación
 mlflow.evaluate(
 model=pipeline,
 data=test_df,
 targets="true_sentiment",
 model_type="text_classification",
 evaluators=["default"], # Usar los evaluadores predeterminados para text_classification
 # Puedes agregar métricas o artefactos personalizados aquí
 # extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
 # extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
 )

print(f"ID de Ejecución de MLflow: {run.info.run_id}")

Cuando ejecutas esto, MLflow calcula automáticamente métricas estándar de clasificación (precisión, precisión, recuperación, F1) y las registra. También genera un gráfico de matriz de confusión, una curva PR y una curva ROC, almacenándolos como artefactos dentro de la ejecución. ¡Esto ya es un gran avance respecto a generar y guardar estos manualmente!

El indicativo `model_type=”text_classification”` es importante porque el evaluador `default` de MLflow sabrá entonces cuáles métricas y gráficos estándar son más relevantes. También hay evaluadores predeterminados para `regressor`, `classifier`, y `question_answering` (hasta mi última revisión).

Ejemplo 2: Métricas y Artefactos Personalizados para Mayor Perspectiva

El verdadero poder, para mí, llegó cuando necesitaba ir más allá de las métricas predeterminadas. ¿Recuerdas la solicitud de mi cliente de ver el rendimiento desglosado por categoría de producto? MLflow te permite definir `extra_metrics` y `extra_artifacts`. Aquí es donde puedes insertar tus evaluaciones específicas del dominio.

Para mi modelo de sentimientos, quería ver específicamente la puntuación F1 para comentarios relacionados con “soporte técnico”. También quería registrar un dataframe mostrando ejemplos mal clasificados para revisar fácilmente los errores comunes.

# ... (configuración anterior para pipeline, X_train, X_test, y_train, y_test, df) ...

# Simulamos categorías de productos para los datos de prueba
# Por simplicidad, solo agregaremos una columna 'category' al test_df
# En un escenario real, esto vendría de tus datos reales
test_df['category'] = np.random.choice(['product_A', 'product_B', 'technical_support', 'billing'], size=len(test_df))

def f1_score_tech_support(eval_df, _builtin_metrics):
 # Esta función métrica personalizada recibe el DataFrame de evaluación
 # que contiene 'targets' (etiquetas verdaderas) y 'predictions'
 tech_support_df = eval_df[eval_df['category'] == 'technical_support']
 if len(tech_support_df) == 0:
 return np.nan # O 0, dependiendo de tu preferencia
 return f1_score(tech_support_df['targets'], tech_support_df['predictions'], average='weighted')

def log_misclassified_examples(eval_df, _builtin_metrics):
 misclassified_df = eval_df[eval_df['targets'] != eval_df['predictions']]
 # Guarda los ejemplos mal clasificados en un CSV
 misclassified_path = "misclassified_examples.csv"
 misclassified_df.to_csv(misclassified_path, index=False)
 return misclassified_path # Devuelve la ruta para ser registrada como un artefacto

with mlflow.start_run(run_name="Sentiment_Model_Evaluation_v2_Custom") as run:
 mlflow.sklearn.log_model(pipeline, "sentiment_model")

 mlflow.evaluate(
 model=pipeline,
 data=test_df,
 targets="true_sentiment", # La columna en test_df que contiene las etiquetas verdaderas
 model_type="text_classification",
 evaluators=["default"],
 extra_metrics=[
 mlflow.models.EvaluationMetric(
 name="f1_tech_support",
 func=f1_score_tech_support,
 greater_is_better=True,
 # El 'input_example' es opcional, pero ayuda a MLflow a entender la firma de la función
 input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
 )
 ],
 extra_artifacts=[
 mlflow.models.EvaluationArtifact(
 name="misclassified_samples",
 func=log_misclassified_examples,
 # input_example similar al anterior
 input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
 )
 ]
 )

print(f"ID de ejecución de MLflow con métricas personalizadas: {run.info.run_id}")

En este ejemplo:

• `f1_score_tech_support`: Esta función toma el `eval_df` (que MLflow construye a partir de tus `data` y las predicciones del modelo, añadiendo columnas de ‘targets’ y ‘predictions’) y calcula la puntuación F1 solo para las filas donde la `category` es ‘technical_support’.
• `log_misclassified_examples`: Esta función identifica filas mal clasificadas, las guarda en un CSV y devuelve la ruta. MLflow luego registra este CSV como un artefacto.

Cuando veas esta ejecución en la interfaz de usuario de MLflow, encontrarás ‘f1_tech_support’ listado junto con tus otras métricas, y encontrarás ‘misclassified_samples.csv’ en la sección de artefactos. Esto hace que las comparaciones entre ejecuciones sean increíblemente sencillas. Podía ver fácilmente si mi modelo ajustado mejoró el F1 para los comentarios de soporte técnico en comparación con la línea base, y luego descargar rápidamente los ejemplos mal clasificados para ver qué tipo de errores seguían ocurriendo.

Lo que aprendí y por qué es importante

Mi incursión en las APIs de evaluación de MLflow fue un cambio significativo para ese proyecto de análisis de sentimientos. Aquí te explico por qué voy a seguir utilizándolo:

• Comparación Centralizada: Todos mis resultados de evaluación – métricas estándar, métricas personalizadas y gráficos – se almacenan en un solo lugar, vinculados directamente a la ejecución del modelo. No más tener que buscar en carpetas o hojas de cálculo separadas.
• Reproducibilidad: Dado que la evaluación es parte de la ejecución de MLflow, está inherentemente ligada al modelo exacto, código y datos utilizados. Esto hace que reproducir resultados y entender cambios sea mucho más fácil.
• La Personalización es Clave: La capacidad de inyectar métricas y artefactos personalizados significa que no estoy limitado a evaluaciones genéricas. Puedo adaptar la evaluación a las necesidades específicas de mi proyecto y cliente. Esto fue crucial para profundizar en el rendimiento específico de la categoría del producto.
• Mejor Colaboración: Cuando trabajas con un equipo, todos pueden ver los mismos resultados de evaluación en la interfaz de usuario de MLflow. Esto agiliza las discusiones sobre el rendimiento del modelo y las posibles mejoras. Mi cliente podría acceder directamente a la interfaz de usuario de MLflow y ver el desglose por categoría, lo que fomentó mucha más confianza que enviar informes estáticos.

Una pequeña cosa a tener en cuenta: Cuando defines funciones de métrica/artefacto personalizadas, asegúrate de que sean autónomas y no dependan de variables globales fuera de lo que se les pase (como `eval_df`). Esto asegura que se comporten de manera predecible dentro del contexto de MLflow.

Recomendaciones para tu próximo proyecto de IA

Si estás trabajando con modelos de IA y buscas una forma más estructurada de evaluarlos, te recomiendo encarecidamente que pruebes las APIs de evaluación de MLflow. Aquí tienes cómo puedes comenzar:

1. Comienza Simple: Empieza integrando `mlflow.evaluate()` con el evaluador `default` para tu `model_type`. Observa qué métricas y artefactos genera automáticamente.
2. Identifica las Métricas Clave Personalizadas: Piensa en lo que realmente define el “éxito” para tu modelo específico en tu caso de uso particular. ¿Es el rendimiento en un segmento de datos en particular? ¿Un tipo de error específico? Crea funciones de métrica personalizadas para estos.
3. Registra Artefactos Informativos: No te detengas en las métricas. ¿Qué gráficos, dataframes (como ejemplos mal clasificados), o informes te ayudarían a comprender mejor el comportamiento de tu modelo? Regístralos como artefactos personalizados.
4. Explora la Interfaz de Usuario de MLflow: Pasa tiempo en la interfaz de usuario de MLflow comparando ejecuciones. Observa los gráficos de métricas y los artefactos registrados. Aquí es donde brilla el verdadero valor de la evaluación organizada.
5. Mantén tus Datos de Evaluación Consistentes: Asegúrate de que el conjunto de datos de prueba que usas para la evaluación sea consistente entre diferentes versiones de modelos o experimentos. Esto es fundamental para comparaciones significativas.

Pasar más allá de las puntuaciones de precisión básicas e integrar evaluaciones directamente en tu flujo de trabajo de MLOps no es solo un capricho; es esencial para construir sistemas de IA justos, útiles y realmente efectivos. Las APIs de evaluación de MLflow proporcionan un marco sólido para hacer precisamente eso.

¡Eso es todo por hoy! Espero que este análisis profundo te ayude a agilizar tus evaluaciones de modelos de IA. ¡Déjame saber en los comentarios si has utilizado MLflow para la evaluación o si tienes otros marcos en los que confías!

🕒 Published: March 26, 2026