Ciao a tutti, Nina qui, di nuovo su agntbox.com! È il 13 marzo 2026 e, se siete simili a me, la vostra casella di posta probabilmente è stracolma di annunci su nuovi strumenti di intelligenza artificiale. Il ritmo dell’innovazione è davvero sorprendente, vero?
Oggi voglio parlare di qualcosa che ho in mente da un po’, specialmente dopo un paio di notti passate a destreggiarmi con un progetto particolare. Esploreremo il mondo della valutazione dei modelli di intelligenza artificiale, concentrandoci su un framework che sta guadagnando attenzione: le API di Valutazione dei Modelli di MLflow. So cosa stanno pensando alcuni di voi – “MLflow? Non è per MLOps e monitoraggio?” E sì, è proprio così. Ma hanno introdotto in silenzio alcune funzioni di valutazione davvero curate che penso meritino di essere analizzate più da vicino, specialmente quando si cerca di andare oltre la semplice analisi di un singolo punteggio di accuratezza.
Per dare un contesto, ho recentemente concluso un progetto per un cliente che coinvolgeva un modello di analisi del sentiment personalizzato per il feedback dei clienti. Il cliente non era solo interessato a un sentiment “buono” o “cattivo”; necessitava di approfondimenti sfumati su perché un sentiment fosse positivo o negativo, e come il modello si comportasse in modo coerente attraverso diverse categorie di prodotti. Il mio approccio iniziale, come spesso accade, è stato quello di creare alcuni script Python, calcolare alcune metriche e scaricarle in un CSV. Sapete come funziona – `sklearn.metrics` per accuratezza, precisione, richiamo, F1, magari anche un grafico della matrice di confusione con Matplotlib. Funziona, va bene. Ma poi il cliente ha chiesto un confronto con un modello di base, e poi un’altra iterazione, e all’improvviso avevo una dozzina di CSV e grafici, tutti leggermente diversi, e nessun modo chiaro per confrontarli in modo sistematico.
È stato allora che ho ricordato di aver visto qualcosa riguardo le funzionalità di valutazione espanse di MLflow. Avevo usato MLflow per il monitoraggio degli esperimenti da anni, ma non mi ero mai veramente addentrato nella parte della valutazione. E lasciatemi dire, è stato un momento rivelatore. Invece di reinventare la ruota per ogni confronto, potevo integrare la mia valutazione direttamente nelle mie esecuzioni di MLflow esistenti, rendendo tutto molto più ordinato e confrontabile.
Oltre una Singola Metrica: Perché la Valutazione Strutturata è Importante
Siamo onesti: quando costruisci modelli di intelligenza artificiale, specialmente per applicazioni nel mondo reale, un singolo punteggio di accuratezza raramente racconta l’intera storia. Devi comprendere:
- Bias: Il tuo modello si comporta in modo equo tra diversi gruppi demografici, categorie di prodotto o tipi di input?
- Solidità: Come gestisce dati rumorosi o lievi variazioni negli input?
- Spiegabilità: Puoi capire perché il modello ha effettuato una particolare previsione?
- Modi di Fallimento Specifici: Dove sbaglia in modo consistente?
Il mio progetto di analisi del sentiment ha messo in evidenza tutto ciò in modo perfetto. Un’accuratezza generale dell’85% sembrava buona sulla carta. Ma quando l’abbiamo analizzata per categoria di prodotto, abbiamo scoperto che il modello stava avendo difficoltà significative con il feedback relativo a “assistenza tecnica” – classificando erroneamente esperienze negative come neutre. Senza un modo strutturato per valutare e confrontare, individuare questi problemi sarebbe stato un mal di testa molto più grande.
Approccio Tradizionale: Buono, Ma Ingombrante
Prima di esplorare MLflow, riconosciamo rapidamente il modo standard in cui spesso facciamo questo. Di solito comporta un ciclo, alcuni calcoli di 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 ...
# Supponendo che X, y siano le tue 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"F1 Score: {f1:.4f}")
# Potresti poi 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)
Questo va bene per un’esecuzione singola, ma immaginate di fare questo per 10 modelli diversi, o 5 versioni diverse dello stesso modello, con iperparametri differenti. Finisci con `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, e così via. Diventa rapidamente ingombrante.
Le API di Valutazione dei Modelli di MLflow: Un Nuovo Sguardo
Le capacità di valutazione dei modelli di MLflow mirano a portare struttura e standardizzazione in questo processo. L’idea fondamentale è che, quando registri un modello con `mlflow.log_model()`, puoi anche attivare un’esecuzione di valutazione che memorizza metriche, grafici e anche artefatti di valutazione personalizzati insieme al tuo modello. Ciò significa che tutti i tuoi risultati di valutazione sono direttamente legati alla versione del modello e all’esecuzione dell’esperimento che li ha generati.
I protagonisti qui sono `mlflow.evaluate()` e le classi `mlflow.models.EvaluationMetric` e `mlflow.models.EvaluationArtifact`. Analizziamo come ho utilizzato questo per il mio progetto di analisi del sentiment.
Esempio 1: Integrazione di Valutazione di Base
Innanzitutto, hai bisogno del tuo modello e di alcuni dati di test. Per il mio modello di sentiment, avevo un oggetto `pipeline` (una pipeline scikit-learn con un TfidfVectorizer e un classificatore LogisticRegression) e un `test_df` con 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
# Supponendo di avere i tuoi dati caricati
# Per dimostrazione, creiamo alcuni dati fittizi
data = {
'text': [
"Il prodotto è fantastico, lo adoro!",
"Servizio terribile, risposta molto lenta.",
"Va bene, niente di speciale.",
"Il miglior acquisto di sempre, lo consiglio vivamente.",
"L'assistenza clienti è stata poco utile e scortese.",
"Funziona come previsto, abbastanza standard.",
"Assolutamente entusiasta di questo dispositivo!",
"Rotto all'arrivo, molto deluso.",
"Qualità decente per il prezzo.",
"Un'ottima esperienza!",
"Peggiore esperienza, mai più.",
"Sensazione neutra su questo, non male, non buono."
],
'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']
)
# Costruisci una pipeline semplice
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Prepara i dati di test come 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:
# Registra il modello (opzionale, ma buona pratica)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Esegui la valutazione
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Usa i valutatori predefiniti per text_classification
# Puoi aggiungere metriche o artefatti personalizzati qui
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"MLflow Run ID: {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 grafico della matrice di confusione, una curva PR e una curva ROC, memorizzandole come artefatti all’interno dell’esecuzione. Questo è già un enorme passo avanti rispetto alla generazione e al salvataggio manuale di questi!
Il suggerimento `model_type=”text_classification”` è importante perché il valutatore `default` di MLflow saprà quindi quali metriche e grafici standard sono più rilevanti. Ci sono anche valutatori predefiniti per `regressor`, `classifier` e `question_answering` (alla mia ultima verifica).
Esempio 2: Metriche e Artefatti Personalizzati per Approfondimenti Maggiori
Il vero potere, per me, è venuto quando ho avuto bisogno di andare oltre le metriche predefinite. Ricordate la richiesta del mio cliente di vedere le prestazioni suddivise per categoria di prodotto? MLflow consente di definire `extra_metrics` e `extra_artifacts`. Qui puoi inserire le tue valutazioni specifiche del dominio.
Per il mio modello di sentiment, volevo vedere il punteggio F1 specificamente per il feedback relativo a “assistenza tecnica”. Volevo anche registrare un dataframe che mostrasse esempi classificati erroneamente per rivedere facilmente gli errori comuni.
# ... (impostazione precedente per pipeline, X_train, X_test, y_train, y_test, df) ...
# Simuliamo le categorie di prodotto per i dati di test
# Per semplicità, aggiungiamo solo una colonna 'category' a test_df
# In uno scenario reale, questo provverrebbe dai tuoi dati effettivi
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 metrica personalizzata riceve il DataFrame di valutazione
# che contiene 'targets' (etichette vere) e 'predictions'
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']]
# Salva gli esempi classificati in modo errato 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 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 è opzionale 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 della Run di MLflow con metriche personalizzate: {run.info.run_id}")
In questo esempio:
- `f1_score_tech_support`: Questa funzione prende `eval_df` (che MLflow costruisce 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 classificate in modo errato, le salva in un CSV e restituisce il percorso. MLflow poi registra questo CSV come un artefatto.
Quando visualizzi questa esecuzione nell’interfaccia utente di MLflow, vedrai ‘f1_tech_support’ elencata insieme alle altre metriche, e troverai ‘misclassified_samples.csv’ nella sezione artefatti. Questo rende le comparazioni tra le esecuzioni incredibilmente semplici. Potrei facilmente vedere se il mio modello perfezionato ha migliorato l’F1 per il feedback del supporto tecnico rispetto alla baseline, e poi scaricare rapidamente gli esempi classificati in modo errato per vedere che tipo di errori si stessero ancora verificando.
Cosa ho imparato e perché è importante
Il mio approccio alle API di valutazione di MLflow è stato un cambiamento significativo per quel progetto di analisi del sentiment. Ecco perché intendo continuare a usarlo:
- Confronto centralizzato: Tutti i miei risultati di valutazione – metriche standard, metriche personalizzate e grafici – sono archiviati in un unico luogo, collegati direttamente all’esecuzione del modello. Niente più cacce in cartelle o fogli di calcolo separati.
- Riproducibilità: Poiché la valutazione è parte dell’esecuzione di MLflow, è intrinsecamente legata al modello esatto, al codice e ai dati utilizzati. Ciò rende molto più facile riprodurre risultati e comprendere cambiamenti.
- La personalizzazione è fondamentale: La possibilità di iniettare metriche e artefatti personalizzati significa che non sono limitato a valutazioni generiche. Posso adattare la valutazione alle esigenze specifiche del mio progetto e del cliente. Questo è stato cruciale per approfondire le prestazioni specifiche per categoria di prodotto.
- Migliorata collaborazione: Lavorando con un team, tutti possono vedere gli stessi risultati di valutazione nell’interfaccia utente di MLflow. Questo semplifica le discussioni sulle prestazioni del modello e i potenziali miglioramenti. Il mio cliente potrebbe accedere direttamente all’interfaccia utente di MLflow e vedere la suddivisione per categoria, il che ha generato molta più fiducia rispetto all’invio di rapporti statici.
Una piccola nota: Quando definisci funzioni di metriche/artefatti personalizzate, assicurati che siano autonome e non facciano affidamento su variabili globali al di fuori di quelle che vengono passate a loro (come `eval_df`). Questo assicura che si comportino in modo prevedibile all’interno del contesto di MLflow.
Lezioni pratiche per il tuo prossimo progetto AI
Se stai lavorando con modelli AI e cerchi un modo più strutturato per valutarli, ti consiglio vivamente di dare un’occhiata alle API di valutazione di MLflow. Ecco come puoi iniziare:
- Inizia semplice: Inizia integrando `mlflow.evaluate()` con l’evaluator `default` per il tuo `model_type`. Vedi quali metriche e artefatti genera automaticamente.
- Identifica metriche personalizzate chiave: Pensa a cosa definisce veramente il “successo” per il tuo modello specifico nel tuo caso d’uso specifico. È la performance su un particolare sottoinsieme di dati? Un tipo di errore specifico? Crea funzioni metriche personalizzate per questi.
- Registra artefatti informativi: Non fermarti alle metriche. Quali grafici, dataframe (come esempi classificati in modo errato) o rapporti ti aiuterebbero a comprendere meglio il comportamento del tuo modello? Registrali come artefatti personalizzati.
- Esplora l’interfaccia utente di MLflow: Dedica del tempo all’interfaccia utente di MLflow confrontando le esecuzioni. Guarda i grafici delle metriche e gli artefatti registrati. Qui è dove il vero valore di una valutazione organizzata risplende.
- Mantieni i tuoi dati di valutazione coerenti: Assicurati che il dataset di test che utilizzi per la valutazione sia coerente tra le diverse versioni del modello o esperimenti. Questo è fondamentale per confronti significativi.
Andare oltre i punteggi di accuratezza di base e integrare una valutazione approfondita direttamente nel tuo flusso di lavoro MLOps non è solo un bel di avere; è essenziale per costruire sistemi AI solidi, equi e davvero utili. Le API di valutazione di MLflow forniscono una solida struttura per farlo.
È tutto per oggi! Spero che questo approfondimento ti aiuti a semplificare le valutazioni del tuo modello AI. Fammi sapere nei commenti se hai utilizzato MLflow per la valutazione o se hai altri framework su cui giuri!
🕒 Published: