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á lotada de anúncios sobre novas ferramentas de IA. O ritmo da inovação é simplesmente incrível, não é?
Hoje, quero falar sobre algo que vem me incomodando há um tempo, especialmente após algumas noites em claro trabalhando em um projeto específico. Vamos explorar o mundo da avaliação de modelos de IA, focando especificamente em uma estrutura que ganhou popularidade: as APIs de avaliação de modelos do MLflow. Agora, eu sei o que alguns de vocês estão pensando – “MLflow? Não é sobre MLOps e rastreamento?” E sim, é exatamente isso. Mas eles discretamente lançaram funcionalidades de avaliação realmente interessantes que, na minha opinião, merecem uma análise mais aprofundada, especialmente quando tentamos ir além de uma simples pontuação de precisão.
Para dar um contexto, recentemente terminei um projeto para um cliente envolvendo um modelo de análise de sentimentos personalizado para feedbacks de clientes. O cliente não estava apenas interessado em um sentimento “bom” ou “ruim”; ele precisava de insights detalhados sobre por que um sentimento era positivo ou negativo, e sobre como o modelo se comportava de maneira consistente em diferentes categorias de produtos. Minha abordagem inicial, como é frequentemente o caso, foi criar alguns scripts em Python, calcular algumas métricas e despejar tudo em um CSV. Vocês sabem como funciona – `sklearn.metrics` para precisão, precisão, recall, F1, talvez um gráfico de matriz de confusão com Matplotlib. Funciona, está correto. Mas então, o cliente pediu uma comparação com um modelo de referência, depois outra iteração, e de repente, eu tinha uma dúzia de CSVs e gráficos, todos ligeiramente diferentes, e nenhuma forma clara de compará-los de maneira sistemática.
Foi então que me lembrei de ter visto algo sobre as funcionalidades de avaliação aprimoradas do MLflow. Eu já estava usando o MLflow para rastreamento de experimentos há ages, mas não tinha realmente me aprofundado na parte de avaliação. E deixe-me dizer, foi como um momento de iluminação. Em vez de reinventar a roda para cada comparação, eu podia integrar minha avaliação diretamente nas minhas execuções de MLflow existentes, tornando tudo muito mais organizado e comparável.
Além de uma única métrica: Por que uma avaliação estruturada é importante
Vamos ser honestos: quando você constrói modelos de IA, especialmente para aplicações do mundo real, uma única pontuação de precisão raramente conta toda a história. Você precisa entender:
- Viés: Seu modelo se comporta de maneira igual entre diferentes grupos demográficos, categorias de produtos ou tipos de entrada?
- Robustez: Como ele lida com dados ruidosos ou pequenas variações na entrada?
- Explicabilidade: Você consegue entender por que o modelo fez uma previsão específica?
- Modos de falha específicos: Onde ele costuma errar de maneira consistente?
Meu projeto de análise de sentimentos destacou isso perfeitamente. Uma precisão geral de 85% parecia ótima no papel. Mas quando adesmembramos por categoria de produto, descobrimos que o modelo estava tendo dificuldades significativas com feedbacks relacionados a “suporte técnico” – classificando consistentemente experiências negativas como neutras. Sem uma maneira estruturada de avaliar e comparar, identificar esses problemas teria sido um desafio muito maior.
A abordagem tradicional: Boa, mas desorganizada
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 depois uma agregação manual. Algo como isto:
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
# ... outros imports ...
# Suponha que X, y sejam suas características e rótulos
# X_train, X_test, y_train, y_test = train_test_split(...)
# Um modelo de exemplo
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Calcular as 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"Precisão: {accuracy:.4f}")
print(f"Precisão: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"Pontuação F1: {f1:.4f}")
# Você poderia então salvar esses dados em um CSV, traçar uma matriz de confusão, etc.
# metrics_df = pd.DataFrame({"metric": ["accuracy", "precision", "recall", "f1"],
# "value": [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. Isso rapidamente se torna inadministrável.
As APIs de avaliação de modelos do MLflow: Um novo olhar
As capacidades de avaliação de modelos do MLflow visam trazer estrutura e padronização a esse processo. A ideia principal é que quando você registra um modelo com `mlflow.log_model()`, você também pode acionar uma execução de avaliação que armazena métricas, gráficos e até artefatos de avaliação personalizados ao lado de seu modelo. Isso significa que todos os seus resultados de avaliação estão diretamente ligados à versão do modelo e à execução da experiência que os produziu.
Os principais componentes aqui são `mlflow.evaluate()` e as classes `mlflow.models.EvaluationMetric` e `mlflow.models.EvaluationArtifact`. Vamos analisar como eu usei isso para meu projeto de análise de sentimentos.
Exemplo 1: Integração da avaliação básica
Primeiro, você precisa do seu modelo e de alguns dados de teste. Para o 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 as 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
# Suponhamos que você tenha seus dados carregados
# Para a demonstração, vamos criar dados fictícios
data = {
'text': [
"O produto é incrível, eu adoro!",
"Serviço péssimo, resposta muito lenta.",
"É medíocre, nada demais.",
"Melhor compra de todos os tempos, altamente recomendado.",
"O suporte ao cliente foi inútil e grosso.",
"Funciona como esperado, bastante padrão.",
"Absolutamente encantado com este aparelho!",
"Quebrado na entrega, muito decepcionado.",
"Qualidade certa pelo preço.",
"Uma experiência tão maravilhosa!",
"Pior experiência, nunca mais.",
"Sentimento neutro em relação a isso, nem ruim, nem bom."
],
'sentiment': [
'positivo', 'negativo', 'neutro', 'positivo', 'negativo',
'neutro', 'positivo', 'negativo', 'neutro', 'positivo',
'negativo', 'neutro'
]
}
df = pd.DataFrame(data)
# Divisão dos 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 os 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="Sentiment_Model_Evaluation_v1") as run:
# Registrar o modelo (opcional, mas é uma boa prática)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Realizar uma 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 de classificação padrão (exatidão, precisão, revocação, F1) e as registra. Ele 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 enorme avanço em relação à geração e ao salvamento manual desses itens!
A dica `model_type=”text_classification”` é importante porque o avaliador `default` do MLflow saberá então quais métricas e quais gráficos padrão são mais relevantes. Também existem avaliadores padrão para `regressor`, `classifier` e `question_answering` (na minha última verificação).
Exemplo 2: Métricas e artefatos personalizados para uma visão mais aprofundada
O verdadeiro poder, para mim, veio quando eu precisei ir além das métricas padrão. Você se lembra do pedido do meu cliente para ver o desempenho desagregado 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 sentimento, eu queria ver a pontuação F1 especificamente para os feedbacks relacionados ao “suporte técnico”. Eu também queria registrar um DataFrame mostrando exemplos mal classificados para revisar facilmente os erros comuns.
# ... (configuração anterior para o pipeline, X_train, X_test, y_train, y_test, df) ...
# Vamos simular as categorias de produtos para os dados de teste
# Para simplificar, vamos apenas adicionar uma coluna 'category' ao test_df
# Em um cenário real, isso viria de 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 de métrica personalizada recebe o DataFrame de avaliação
# que contém os 'alvos' (rótulos verdadeiros) e as 'previsões'
tech_support_df = eval_df[eval_df['category'] == 'technical_support']
if len(tech_support_df) == 0:
return np.nan # Ou 0, de acordo com 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 salvo 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 os 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 semelhante 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 as 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 esse CSV como um artefato.
Quando você visualiza essa execução na interface do MLflow, verá ‘f1_tech_support’ listado ao lado de 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 aprimorado melhorou o F1 para os feedbacks de suporte técnico em relação à linha de base, e então baixar rapidamente os exemplos mal classificados para ver que tipo de erros ainda estavam ocorrendo.
O que eu aprendi e por que isso é importante
Minha incursão nas APIs de avaliação do MLflow foi uma mudança significativa para este projeto de análise de sentimento. Aqui está o motivo pelo qual eu continuo usando 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. Adeus à busca em pastas ou planilhas separadas.
- Reprodutibilidade: Já que a avaliação faz parte da execução do MLflow, ela está intrinsecamente ligada ao modelo exato, ao código e aos dados utilizados. Isso torna muito mais fácil reproduzir os resultados e entender as mudanças.
- A Personalizaçã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 do meu cliente. Isso foi crucial para examinar o desempenho por categoria de produto.
- Colaboração Melhorada: Ao trabalhar em equipe, todos podem ver os mesmos resultados de avaliação na interface do MLflow. Isso racionaliza as discussões sobre o desempenho do modelo e melhorias potenciais. Meu cliente pôde acessar diretamente a interface do MLflow e ver a distribuição por categoria, o que gerou muito mais confiança do que simplesmente enviar relatórios estáticos.
Uma pequena coisa a notar: Quando você define funções de métricas/artefatos personalizados, certifique-se de que elas são autônomas e não dependem de variáveis globais fora do que é passado para elas (como `eval_df`). Isso garante que elas se comportem de maneira previsível no contexto do MLflow.
Ações Concretas para Seu Próximo Projeto de AI
Se você está trabalhando com modelos de AI e procura uma maneira mais estruturada de avaliá-los, recomendo fortemente que você experimente 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 as Métricas Personalizadas Chave: Pense no que realmente define o “sucesso” para seu modelo específico no seu caso de uso. É o desempenho em um conjunto de dados particular? Um tipo específico de erro? Crie funções de métricas personalizadas para isso.
- Registre Artefatos Informativos: Não pare nas métricas. Quais gráficos, DataFrames (como os exemplos mal classificados) ou relatórios ajudariam você a entender melhor o comportamento do seu modelo? Registre-os como artefatos personalizados.
- Explore a Interface MLflow: Passe um tempo na interface MLflow comparando as execuções. Veja os gráficos de métricas e os artefatos registrados. É aí que o verdadeiro valor de uma avaliação organizada se destaca.
- Mantenha Seus Dados de Avaliação Coerentes: Certifique-se de que o conjunto de dados de teste que você está usando para a avaliação seja coerente entre diferentes versões ou experimentos de modelos. Isso é fundamental para comparações significativas.
Ir além das pontuações de precisão básicas e integrar uma avaliação aprofundada diretamente em seu fluxo de trabalho MLOps não é apenas um simples acréscimo; é essencial para construir sistemas de IA sólidos, justos e verdadeiramente úteis. As APIs de avaliação do MLflow fornecem uma estrutura eficaz para isso.
Isso é tudo por hoje! Espero que essa análise aprofundada ajude você a agilizar suas avaliações de modelos de IA. Deixe-me saber nos comentários se você usou o MLflow para avaliação ou se você tem outras estruturas que prefere!
🕒 Published: