Olá a todos, aqui é a Nina, de volta no agntbox.com! Hoje é 13 de março de 2026, e se você é como eu, sua caixa de entrada provavelmente está transbordando com anúncios sobre novas ferramentas de IA. O ritmo da inovação é simplesmente insano, né?
Hoje, quero falar sobre algo que está me ocupando há um tempo, especialmente depois de algumas noites em claro lidando com um projeto específico. Vamos explorar o mundo da avaliação de modelos de IA, com foco em uma estrutura que tem ganhado destaque: APIs de Avaliação de Modelos do MLflow. Agora, eu sei o que alguns de vocês estão pensando – “MLflow? Não é isso para MLOps e rastreamento?” E sim, absolutamente é. Mas eles lançaram silenciosamente algumas capacidades de avaliação realmente bem pensadas que eu acho que merecem uma olhada mais atenta, especialmente quando você está tentando ir além de apenas olhar uma única pontuação de acurácia.
Para contextualizar, eu recentemente finalizei um projeto para um cliente envolvendo um modelo de análise de sentimentos personalizado para feedback de clientes. O cliente não estava apenas interessado em sentimentos “bons” ou “maus”; eles precisavam de insights mais sutis sobre por que um sentimento era positivo ou negativo, e como o modelo se comportava de forma consistente em diferentes categorias de produtos. Minha abordagem inicial, como costuma ser, foi criar alguns scripts em Python, calcular algumas métricas e jogar tudo em um CSV. Você sabe como é – `sklearn.metrics` para acurácia, precisão, recall, F1, talvez um gráfico de matriz de confusão com Matplotlib. Funciona, está tudo bem. Mas então o cliente pediu uma comparação com um modelo base, e depois outra iteração, e de repente eu tinha uma dúzia de CSVs e gráficos, todos ligeiramente diferentes, e nenhuma maneira clara de compará-los de forma sistemática.
Foi então que me lembrei de ter visto algo sobre os recursos de avaliação expandidos do MLflow. Eu já vinha usando o MLflow para rastreamento de experimentos há muito tempo, mas não tinha realmente me aprofundado na parte de avaliação. E deixe-me dizer, foi uma espécie de momento “aha”. Em vez de reinventar a roda para cada comparação, eu poderia integrar minha avaliação diretamente nas minhas execuções existentes do MLflow, tornando tudo muito mais organizado e comparável.
Além de Uma Única Métrica: Por Que a Avaliação Estruturada Importa
Vamos ser realistas: quando você está construindo modelos de IA, especialmente para aplicações do mundo real, uma única pontuação de acurácia raramente conta toda a história. Você precisa entender:
- Viés: Seu modelo tem um desempenho igualmente bom em diferentes grupos demográficos, categorias de produtos ou tipos de entrada?
- Consistência: Como ele lida com dados ruidosos ou pequenas variações na entrada?
- Explicabilidade: Você consegue entender por que o modelo fez uma determinada previsão?
- Modos de Falha Específicos: Onde ele consistentemente falha?
Meu projeto de análise de sentimentos destacou isso perfeitamente. Uma acurácia geral de 85% parecia boa no papel. Mas quando analisamos por categoria de produto, descobrimos que o modelo estava tendo dificuldades significativas com feedback relacionado a “suporte técnico” – classificando consistentemente experiências negativas como neutras. Sem uma maneira estruturada de avaliar e comparar, identificar esses problemas teria sido uma dor de cabeça muito maior.
A Abordagem Tradicional: Boa, Mas Bagunçada
Antes de explorar o MLflow, vamos rapidamente reconhecer a maneira padrão como costumamos fazer isso. Geralmente, envolve um loop, alguns cálculos de métricas e, em seguida, agregação manual. Algo assim:
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
# ... outras importações ...
# Suponha que X, y sejam suas características e rótulos
# X_train, X_test, y_train, y_test = train_test_split(...)
# Um modelo simples
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"Acurácia: {accuracy:.4f}")
print(f"Precisão: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1 Score: {f1:.4f}")
# Você pode então salvar isso em um CSV, plotar uma matriz de confusão, etc.
# metrics_df = pd.DataFrame({"métrica": ["acurácia", "precisão", "recall", "f1"],
# "valor": [accuracy, precision, recall, f1]})
# metrics_df.to_csv("model_metrics_v1.csv", index=False)
Isso é bom para uma única execução, mas imagine fazer isso para 10 modelos diferentes, ou 5 versões diferentes do mesmo modelo, com diferentes hiperparâmetros. Você acaba com `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, e assim por diante. Fica inadministrável rapidamente.
APIs de Avaliação de Modelos do MLflow: Uma Nova Perspectiva
As capacidades de avaliação de modelos do MLflow visam trazer estrutura e padronização a esse processo. A ideia central é que quando você registra um modelo com `mlflow.log_model()`, você pode também acionar uma execução de avaliação que armazena métricas, gráficos e até mesmo artefatos personalizados de avaliação junto com seu modelo. Isso significa que todos os seus resultados de avaliação estão diretamente vinculados à versão do modelo e à execução do experimento que os produziu.
Os principais componentes aqui são `mlflow.evaluate()` e as classes `mlflow.models.EvaluationMetric` e `mlflow.models.EvaluationArtifact`. Vamos detalhar como eu usei isso para o meu projeto de análise de sentimentos.
Exemplo 1: Integração Básica de Avaliação
Primeiro, você precisa do seu modelo e alguns dados de teste. Para meu modelo de sentimentos, eu tinha um objeto `pipeline` (um pipeline scikit-learn com um TfidfVectorizer e um classificador LogisticRegression) e um `test_df` com colunas `text` e `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
# Suponha que você tenha seus dados carregados
# Para demonstração, vamos criar alguns dados fictícios
data = {
'text': [
"O produto é incrível, eu adoro!",
"Serviço terrível, resposta muito lenta.",
"Está ok, nada especial.",
"Melhor compra de todas, altamente recomendável.",
"O suporte ao cliente foi inútil e rude.",
"Funciona como esperado, bem padrão.",
"Estou absolutamente encantado com este dispositivo!",
"Quebrado na entrega, muito decepcionado.",
"Qualidade decente pelo preço.",
"Uma experiência tão ótima!",
"Pior experiência, nunca mais.",
"Sentimento neutro sobre isso, nem ruim, nem bom."
],
'sentiment': [
'positivo', 'negativo', 'neutro', 'positivo', 'negativo',
'neutro', 'positivo', 'negativo', 'neutro', 'positivo',
'negativo', 'neutro'
]
}
df = pd.DataFrame(data)
# Dividir os dados
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']
)
# Construir um pipeline simples
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Preparar dados de teste como um DataFrame para mlflow.evaluate
test_df = pd.DataFrame({'text': X_test, 'true_sentiment': y_test})
with mlflow.start_run(run_name="Avaliação_Modelo_Sentimento_v1") as run:
# Registrar o modelo (opcional, mas boa prática)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Executar avaliação
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Use os avaliadores padrão para text_classification
# Você pode adicionar métricas ou artefatos personalizados aqui
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"ID da Execução do MLflow: {run.info.run_id}")
Quando você executa isso, o MLflow calcula automaticamente as métricas padrão de classificação (acurácia, precisão, recall, F1) e as registra. Também gera um gráfico de matriz de confusão, uma curva PR e uma curva ROC, armazenando-os como artefatos dentro da execução. Isso já é um grande avanço em relação a gerar e salvar isso manualmente!
A dica `model_type=”text_classification”` é importante porque o avaliador `default` do MLflow saberá quais métricas e gráficos padrão são mais relevantes. Também há avaliadores padrão para `regressor`, `classifier` e `question_answering` (até minha última verificação).
Exemplo 2: Métricas e Artefatos Personalizados para Insights Mais Profundos
O verdadeiro poder, para mim, veio quando eu precisava ir além das métricas padrão. Lembre-se do pedido do meu cliente para ver o desempenho discriminado por categoria de produto? O MLflow permite que você defina `extra_metrics` e `extra_artifacts`. É aqui que você pode conectar suas avaliações específicas de domínio.
Para meu modelo de sentimentos, eu queria ver a pontuação F1 especificamente para feedback relacionado a “suporte técnico”. Eu também queria registrar um dataframe mostrando exemplos mal classificados para revisar facilmente erros comuns.
# ... (configuração anterior para pipeline, X_train, X_test, y_train, y_test, df) ...
# Vamos simular categorias de produtos para os dados de teste
# Para simplicidade, apenas adicionaremos uma coluna 'category' ao test_df
# Em uma situação real, isso viria dos seus dados reais
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 função métrica personalizada recebe o DataFrame de avaliação
# que contém 'targets' (rótulos verdadeiros) e 'predictions'
tech_support_df = eval_df[eval_df['category'] == 'technical_support']
if len(tech_support_df) == 0:
return np.nan # Ou 0, dependendo da sua preferência
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']]
# Salve os exemplos mal classificados em um CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Retorne o caminho para ser registrado como um artefato
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", # A coluna em test_df que contém rótulos verdadeiros
model_type="text_classification",
evaluators=["default"],
extra_metrics=[
mlflow.models.EvaluationMetric(
name="f1_tech_support",
func=f1_score_tech_support,
greater_is_better=True,
# O 'input_example' é opcional, mas ajuda o MLflow a entender a assinatura da função
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 ao acima
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
]
)
print(f"ID da execução do MLflow com métricas personalizadas: {run.info.run_id}")
Neste exemplo:
- `f1_score_tech_support`: Esta função recebe o `eval_df` (que o MLflow constrói a partir dos seus `data` e das previsões do modelo, adicionando as colunas ‘targets’ e ‘predictions’) e calcula a pontuação F1 apenas para linhas onde a `category` é ‘technical_support’.
- `log_misclassified_examples`: Esta função identifica as linhas mal classificadas, as salva em um CSV e retorna o caminho. O MLflow então registra este CSV como um artefato.
Quando você visualizar esta execução na interface do MLflow, verá ‘f1_tech_support’ listado ao lado das suas outras métricas, e encontrará ‘misclassified_samples.csv’ na seção de artefatos. Isso torna as comparações entre execuções incrivelmente simples. Eu poderia facilmente ver se meu modelo ajustado melhorou o F1 para o feedback de suporte técnico em comparação com a linha de base, e então rapidamente baixar os exemplos mal classificados para ver que tipo de erros ainda estavam ocorrendo.
O Que Aprendi e Por Que Isso Importa
Minha incursão nas APIs de avaliação do MLflow foi uma mudança significativa para aquele projeto de análise de sentimentos. Aqui está o porquê de eu continuar com isso:
- Comparação Centralizada: Todos os meus resultados de avaliação – métricas padrão, métricas personalizadas e gráficos – estão armazenados em um só lugar, vinculados diretamente à execução do modelo. Sem mais procurar em pastas ou planilhas separadas.
- Reproduzibilidade: Como a avaliação é parte da execução do MLflow, está intrinsecamente ligada ao modelo, código e dados exatos usados. Isso facilita a reprodução de resultados e a compreensão de alterações.
- Customização é Fundamental: A capacidade de injetar métricas e artefatos personalizados significa que não estou limitado a avaliações genéricas. Posso adaptar a avaliação às necessidades específicas do meu projeto e cliente. Isso foi crucial para aprofundar o desempenho específico por categoria de produto.
- Colaboração Aprimorada: Ao trabalhar com uma equipe, todos podem ver os mesmos resultados de avaliação na interface do MLflow. Isso agiliza discussões sobre o desempenho do modelo e possíveis melhorias. Meu cliente poderia acessar diretamente a interface do MLflow e ver a divisão por categoria, o que gerou muito mais confiança do que apenas enviar relatórios estáticos.
Uma pequena observação: Quando você define funções de métrica/artefato personalizadas, certifique-se de que sejam autônomas e não dependam de variáveis globais fora do que é passado para elas (como `eval_df`). Isso garante que se comportem de forma previsível dentro do contexto do MLflow.
Considerações Práticas para Seu Próximo Projeto de IA
Se você está trabalhando com modelos de IA e buscando uma maneira mais estruturada de avaliá-los, recomendo muito experimentar as APIs de avaliação do MLflow. Aqui está como você pode começar:
- Comece Simples: Comece integrando `mlflow.evaluate()` com o avaliador `default` para seu `model_type`. Veja quais métricas e artefatos ele gera automaticamente.
- Identifique Métricas Personalizadas Chave: Pense sobre o que realmente define “sucesso” para seu modelo específico em seu caso de uso específico. É o desempenho em um determinado subconjunto de dados? Um tipo específico de erro? Crie funções de métrica personalizadas para esses.
- Registre Artefatos Informativos: Não pare nas métricas. Que gráficos, dataframes (como exemplos mal classificados) ou relatórios ajudariam você a entender melhor o comportamento do seu modelo? Registre-os como artefatos personalizados.
- Explore a Interface do MLflow: Passe algum tempo na interface do MLflow comparando execuções. Olhe para os gráficos de métricas e os artefatos registrados. É aqui que o verdadeiro valor da avaliação organizada brilha.
- Mantenha Seus Dados de Avaliação Consistentes: Certifique-se de que o conjunto de dados de teste que você usa para avaliação seja consistente entre diferentes versões do modelo ou experimentos. Isso é fundamental para comparações significativas.
Ir além das pontuações básicas de precisão e integrar uma avaliação completa diretamente em seu fluxo de trabalho MLOps não é apenas um diferencial; é essencial para construir sistemas de IA sólidos, justos e realmente úteis. As APIs de avaliação do MLflow fornecem uma estrutura sólida para fazer exatamente isso.
É isso por hoje! Espero que esta análise ajude você a otimizar suas avaliações de modelos de IA. Deixe um comentário se você já usou o MLflow para avaliação ou se tem outras ferramentas que você recomenda!
🕒 Published: