Ciao a tutti, qui è Nina, di nuovo su agntbox.com! Oggi è 13 marzo 2026, e se siete come me, la vostra casella di posta probabilmente è stracolma di annunci riguardanti nuovi strumenti di IA. Il ritmo dell’innovazione è semplicemente incredibile, vero?
Oggi voglio parlare di qualcosa che mi frulla in testa da un po’, soprattutto dopo alcune notti in bianco a lavorare su un progetto particolare. Esploreremo il mondo della valutazione dei modelli di IA, concentrandoci specificamente su un framework che ha guadagnato popolarità: le API di valutazione dei modelli di MLflow. Ora, so cosa pensa qualcuno di voi – “MLflow? Non è solo per MLOps e tracciamento?” E sì, è proprio così. Ma hanno discretamente rilasciato funzionalità di valutazione davvero interessanti che, a mio avviso, meritano un’esamina più approfondita, soprattutto quando si cerca di andare oltre un semplice punteggio di accuratezza.
Per darvi un contesto, ho recentemente concluso un progetto per un cliente che prevedeva un modello di analisi del sentiment personalizzato per i feedback dei clienti. Il cliente non era interessato solo a un sentiment “buono” o “cattivo”; aveva bisogno di approfondimenti sfumati su perché un sentiment fosse positivo o negativo, e su come il modello si comportasse in modo coerente attraverso diverse categorie di prodotto. Il mio approccio iniziale, come spesso accade, era di scrivere alcuni script in Python, calcolare alcune metriche e riversarle in un CSV. Sapete come funziona – `sklearn.metrics` per l’accuratezza, la precisione, il richiamo, l’F1, forse un grafico della matrice di confusione con Matplotlib. Funziona, è corretto. Ma poi, il cliente ha chiesto un confronto con un modello di riferimento, poi un’altra iterazione, e all’improvviso mi sono ritrovato con una dozzina di CSV e grafici, tutti leggermente diversi, e nessun modo chiaro per confrontarli sistematicamente.
È allora che mi sono ricordato di aver visto qualcosa sulle funzionalità di valutazione ampliate di MLflow. Utilizzavo MLflow per il tracciamento delle esperienze da secoli, ma non mi ero davvero immerso nel lato della valutazione. E lasciatemi dire, è stato un po’ come un momento di illuminazione. Invece di reinventare la ruota per ogni confronto, potevo integrare la mia valutazione direttamente nelle mie esecuzioni di MLflow esistenti, rendendo tutto molto più organizzato e comparabile.
Oltre a una sola metrica: perché una valutazione strutturata è importante
Siamo onesti: quando costruite modelli di IA, soprattutto per applicazioni del mondo reale, un solo punteggio di accuratezza racconta raramente l’intera storia. Dovete capire:
- Bias: Il vostro modello si comporta in modo equo attraverso diversi gruppi demografici, categorie di prodotto o tipi di input?
- Robustezza: Come gestisce i dati rumorosi o piccole variazioni nell’input?
- Spiegabilità: Potete capire perché il modello ha fatto una particolare previsione?
- Modalità di errore specifiche: Dove si sbaglia in modo coerente?
Il mio progetto di analisi del sentiment ha evidenziato perfettamente questo punto. Un’accuratezza globale dell’85% sembrava ottima sulla carta. Ma quando l’abbiamo suddivisa per categoria di prodotto, abbiamo scoperto che il modello faticava notevolmente con i feedback legati all'”assistenza tecnica” – classificando sistematicamente esperienze negative come neutre. Senza un modo strutturato per valutare e confrontare, individuare questi problemi sarebbe stato un grattacapo ben più grande.
L’approccio tradizionale: buono, ma disordinato
Prima di esplorare MLflow, riconosciamo rapidamente il modo standard in cui facciamo spesso questo. Di solito, implica un ciclo, alcuni calcoli delle metriche e poi un aggregazione manuale. Qualcosa del genere:
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
# ... altri import ...
# Supponiamo che X, y siano le vostre caratteristiche e etichette
# X_train, X_test, y_train, y_test = train_test_split(...)
# Un modello fittizio
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Calcolare le metriche
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"Accuratezza: {accuracy:.4f}")
print(f"Precisione: {precision:.4f}")
print(f"Richiamo: {recall:.4f}")
print(f"Punteggio F1: {f1:.4f}")
# Poi potreste salvare questi dati in un CSV, tracciare una matrice di confusione, ecc.
# metrics_df = pd.DataFrame({"metric": ["accuracy", "precision", "recall", "f1"],
# "value": [accuracy, precision, recall, f1]})
# metrics_df.to_csv("model_metrics_v1.csv", index=False)
Va bene per una sola esecuzione, ma immaginate di fare questo per 10 modelli diversi, o 5 versioni diverse dello stesso modello, con diversi iperparametri. Vi ritrovate con `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, e così via. Diventa rapidamente ingestibile.
Le API di valutazione dei modelli di MLflow: una nuova prospettiva
Le capacità di valutazione dei modelli di MLflow mirano a portare struttura e standardizzazione a questo processo. L’idea principale è che quando registrate un modello con `mlflow.log_model()`, potete anche innescare un’esecuzione di valutazione che memorizza le metriche, i grafici e persino artefatti di valutazione personalizzati insieme al vostro modello. Questo significa che tutti i vostri risultati di valutazione sono direttamente collegati alla versione del modello e all’esecuzione dell’esperimento che li ha prodotti.
Gli attori chiave qui sono `mlflow.evaluate()` e le classi `mlflow.models.EvaluationMetric` e `mlflow.models.EvaluationArtifact`. Scomponiamo come ho utilizzato questo per il mio progetto di analisi del sentiment.
Esempio 1: Integrazione della valutazione di base
Prima di tutto, avete bisogno del vostro modello e di alcuni dati di test. Per il mio modello di sentiment, avevo un oggetto `pipeline` (un pipeline scikit-learn con un TfidfVectorizer e un classificatore LogisticRegression) e un `test_df` con le colonne `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
# Supponiamo che tu abbia i tuoi dati caricati
# Per la dimostrazione, creiamo dati fittizi
data = {
'text': [
"Il prodotto è incredibile, lo adoro!",
"Servizio terribile, risposta molto lenta.",
"È nella media, niente di speciale.",
"Miglior acquisto di tutti i tempi, altamente raccomandato.",
"Il supporto clienti era inutile e scortese.",
"Funziona come previsto, abbastanza standard.",
"Assolutamente soddisfatto di questo dispositivo!",
"Rotto all'arrivo, molto deluso.",
"Qualità corretta per il prezzo.",
"Un'esperienza così fantastica!",
"Peggior esperienza, mai più.",
"Sentimento neutro a riguardo, né buono né cattivo."
],
'sentiment': [
'positivo', 'negativo', 'neutro', 'positivo', 'negativo',
'neutro', 'positivo', 'negativo', 'neutro', 'positivo',
'negativo', 'neutro'
]
}
df = pd.DataFrame(data)
# Divisione dei dati
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']
)
# Costruire un pipeline semplice
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Preparare i dati di test in un DataFrame per 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:
# Registrare il modello (facoltativo, ma buona pratica)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Eseguire una valutazione
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Usa gli valutatori predefiniti per text_classification
# Puoi aggiungere metriche o artefatti personalizzati qui
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"ID dell'esecuzione MLflow: {run.info.run_id}")
Quando esegui questo, MLflow calcola automaticamente le metriche di classificazione standard (accuratezza, precisione, richiamo, F1) e le registra. Genera anche un tracciato della matrice di confusione, una curva PR, e una curva ROC, memorizzandoli come artefatti all’interno dell’esecuzione. È già un enorme passo avanti rispetto alla generazione e al salvataggio manuali di questi!
Il suggerimento `model_type=”text_classification”` è importante perché l’evaluatore `default` di MLflow saprà quindi quali metriche e grafici standard sono più pertinenti. Ci sono anche evaluatori predefiniti per `regressor`, `classifier` e `question_answering` (alla mia ultima verifica).
Esempio 2: Metriche e artefatti personalizzati per un’analisi più approfondita
Il vero potere, per me, è arrivato quando ho avuto bisogno di andare oltre le metriche predefinite. Ricordi la richiesta del mio cliente di vedere le performance suddivise per categoria di prodotto? MLflow ti consente di definire `extra_metrics` e `extra_artifacts`. È qui che puoi collegare le tue valutazioni specifiche per il dominio.
Per il mio modello di sentiment, volevo vedere il punteggio F1 specificamente per i feedback relativi al “supporto tecnico”. Volevo anche registrare un DataFrame che mostrasse esempi mal classificati per rivedere facilmente gli errori comuni.
# ... (configurazione precedente per il pipeline, X_train, X_test, y_train, y_test, df) ...
# Simuliamo le categorie di prodotto per i dati di test
# Per semplicità, aggiungeremo solo una colonna 'category' a test_df
# In uno scenario reale, questo deriverebbe dai tuoi dati reali
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):
# Questa funzione di metrica personalizzata riceve il DataFrame di valutazione
# che contiene le 'cifre' (etichette vere) e le 'previsioni'
tech_support_df = eval_df[eval_df['category'] == 'technical_support']
if len(tech_support_df) == 0:
return np.nan # O 0, a seconda della tua preferenza
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']]
# Registra gli esempi mal classificati in un CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Restituisci il percorso da registrare come un artefatto
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 colonna in test_df che contiene le etichette vere
model_type="text_classification",
evaluators=["default"],
extra_metrics=[
mlflow.models.EvaluationMetric(
name="f1_tech_support",
func=f1_score_tech_support,
greater_is_better=True,
# L' 'input_example' è facoltativo ma aiuta MLflow a comprendere la firma della funzione
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 simile a sopra
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
]
)
print(f"ID esecuzione MLflow con metriche personalizzate: {run.info.run_id}")
In questo esempio:
- `f1_score_tech_support`: Questa funzione prende il `eval_df` (che MLflow costruisce a partire dai tuoi `data` e dalle previsioni del modello, aggiungendo le colonne ‘targets’ e ‘predictions’) e calcola il punteggio F1 solo per le righe in cui la `category` è ‘technical_support’.
- `log_misclassified_examples`: Questa funzione identifica le righe mal classificate, le registra in un CSV, e restituisce il percorso. MLflow registra quindi questo CSV come un artefatto.
Quando visualizzi questa esecuzione nell’interfaccia MLflow, vedrai ‘f1_tech_support’ elencato accanto alle tue altre metriche, e troverai ‘misclassified_samples.csv’ sotto la sezione degli artefatti. Questo rende le comparazioni tra le esecuzioni incredibilmente semplici. Potrei facilmente vedere se il mio modello raffinato ha migliorato il F1 per i feedback di supporto tecnico rispetto alla linea di base, e poi scaricare rapidamente gli esempi mal classificati per vedere che tipo di errori si verificavano ancora.
Ciò che ho imparato e perché è importante
La mia incursione nelle API di valutazione di MLflow è stata un cambiamento significativo per questo progetto di analisi del sentiment. Ecco perché continuo a usarla:
- Confronto Centralizzato: Tutti i miei risultati di valutazione – metriche standard, metriche personalizzate e grafici – sono memorizzati in un unico posto, direttamente collegati all’esecuzione del modello. Fine della ricerca in cartelle o fogli di calcolo separati.
- Riproducibilità: Poiché la valutazione fa parte dell’esecuzione MLflow, è intrinsecamente collegata al modello esatto, al codice e ai dati utilizzati. Questo rende la riproduzione dei risultati e la comprensione dei cambiamenti molto più facili.
- La Personalizzazione è Chiave: La capacità di iniettare metriche e artefatti personalizzati significa che non sono limitato a valutazioni generiche. Posso adattare la valutazione ai bisogni specifici del mio progetto e del mio cliente. Questo è stato cruciale per esaminare la performance per categoria di prodotto.
- Collaborazione Migliorata: Quando si lavora in team, tutti possono vedere gli stessi risultati di valutazione nell’interfaccia MLflow. Questo semplifica le discussioni sulle performance del modello e sulle potenziali migliorie. Il mio cliente poteva accedere direttamente all’interfaccia MLflow e vedere la ripartizione per categoria, il che ha ispirato molta più fiducia rispetto all’invio di rapporti statici.
Una piccola cosa da notare: Quando definisci funzioni di metriche/artefatti personalizzati, assicurati che siano autonome e non dipendano da variabili globali al di fuori di quelle che vengono passate (come `eval_df`). Questo garantisce che si comportino in modo prevedibile nel contesto di MLflow.
Azioni Concrete per il Tuo Prossimo Progetto AI
Se stai lavorando con modelli AI e cerchi un modo più strutturato per valutarli, ti consiglio vivamente di provare le API di valutazione di MLflow. Ecco come puoi iniziare:
- Inizia Semplice : Inizia integrando `mlflow.evaluate()` con l’evaluatore `default` per il tuo `model_type`. Guarda quali metriche e artefatti genera automaticamente.
- Identifica le Metriche Personalizzate Chiave : Pensa a ciò che definisce realmente il “successo” per il tuo modello specifico nel tuo caso d’uso specifico. È la performance su un particolare campione di dati? Un tipo di errore specifico? Crea funzioni di metriche personalizzate per questo.
- Registra Artefatti Informativi : Non fermarti alle metriche. Quali grafici, DataFrame (come gli esempi mal classificati), o report ti aiuterebbero a comprendere meglio il comportamento del tuo modello? Registrali come artefatti personalizzati.
- Esplora l’Interfaccia MLflow : Dedica tempo all’interfaccia MLflow per confrontare le esecuzioni. Guarda i grafici delle metriche e gli artefatti registrati. È qui che il vero valore di una valutazione organizzata emerge.
- Mantieni Coerenti i Tuoi Dati di Valutazione : Assicurati che il set di dati di test che utilizzi per la valutazione sia coerente tra le diverse versioni o esperimenti di modelli. È fondamentale per confronti significativi.
Andare oltre i punteggi di accuratezza di base e integrare una valutazione approfondita direttamente nel tuo workflow MLOps non è solo un semplice supplemento; è essenziale per costruire sistemi AI solidi, equi e veramente utili. Le API di valutazione di MLflow forniscono un framework valido per questo.
È tutto per oggi! Spero che questo approfondimento ti aiuti a semplificare le tue valutazioni di modelli AI. Fammi sapere nei commenti se hai utilizzato MLflow per la valutazione o se hai altri framework che preferisci!
🕒 Published: