Hallo zusammen, hier ist Nina, zurück auf agntbox.com! Es ist der 13. März 2026, und wenn du wie ich bist, überquillt dein Posteingang wahrscheinlich mit Ankündigungen zu neuen KI-Tools. Das Innovationstempo ist einfach verrückt, oder?
Heute möchte ich über etwas sprechen, das mich schon eine Weile beschäftigt, insbesondere nach ein paar Nächten, in denen ich mit einem bestimmten Projekt gekämpft habe. Wir werden die Welt der KI-Modellbewertung erkunden, insbesondere einen Rahmen, der an Bedeutung gewinnt: MLflow’s Model Evaluation APIs. Jetzt weiß ich, was einige von euch denken – „MLflow? Ist das nicht für MLOps und Tracking?“ Und ja, das ist es absolut. Aber sie haben heimlich einige wirklich durchdachte Bewertungsfunktionen eingeführt, die ich für einen genaueren Blick wert halte, besonders wenn man über die bloße Betrachtung eines einzelnen Genauigkeitswerts hinausgehen möchte.
Zur Klarstellung: Ich habe kürzlich ein Kundenprojekt abgeschlossen, bei dem ein maßgeschneidertes Sentiment-Analyse-Modell für Kundenfeedback entwickelt wurde. Der Kunde war nicht nur an „gut“ oder „schlecht“ interessiert; er benötigte nuancierte Einblicke in warum ein Sentiment positiv oder negativ war und wie konsistent das Modell über verschiedene Produktkategorien hinweg arbeitete. Mein ursprünglicher Ansatz, wie so oft, war es, ein paar Python-Skripte zu schreiben, einige Kennzahlen zu berechnen und sie in eine CSV-Datei zu dumpen. Ihr kennt das schon – `sklearn.metrics` für Genauigkeit, Präzision, Rückruf, F1, vielleicht ein Konfusionsmatrix-Plot mit Matplotlib. Es funktioniert, es ist in Ordnung. Aber dann fragte der Kunde nach einem Vergleich mit einem Basislinienmodell, dann nach einer weiteren Iteration, und plötzlich hatte ich ein Dutzend CSVs und Plots, die alle leicht unterschiedlich waren, und keinen klaren Weg, um sie systematisch zu vergleichen.
Da erinnerte ich mich daran, etwas über die erweiterten Bewertungsfunktionen von MLflow gesehen zu haben. Ich hatte MLflow seit Ewigkeiten für das Experiment-Tracking verwendet, aber mich nicht wirklich mit den Bewertungsfunktionen beschäftigt. Und lasst mich euch sagen, es war ein bisschen wie ein Lichtblick. Anstatt das Rad für jeden Vergleich neu zu erfinden, konnte ich meine Bewertung direkt in meine bestehenden MLflow-Läufe integrieren, was alles viel organisierter und vergleichbarer machte.
Über eine einzelne Kennzahl hinaus: Warum strukturierte Bewertung wichtig ist
Seien wir ehrlich: Wenn man KI-Modelle entwickelt, insbesondere für reale Anwendungen, sagt eine einzelne Genauigkeitsbewertung selten die ganze Geschichte. Man muss verstehen:
- Bias: Leistet dein Modell gleich gut über verschiedene demografische Gruppen, Produktkategorien oder Eingabetypen?
- Stabilität: Wie geht es mit geräuschbehafteten Daten oder leichten Variationen in den Eingaben um?
- Erklärbarkeit: Kannst du verstehen, warum das Modell eine bestimmte Vorhersage gemacht hat?
- Spezifische Fehlermuster: Wo liegt es konstant falsch?
Mein Projekt zur Sentiment-Analyse hat dies perfekt verdeutlicht. Eine Gesamtgenauigkeit von 85 % sah gut aus. Aber als wir es nach Produktkategorie aufschlüsselten, stellten wir fest, dass das Modell erheblich mit Feedback zur „technischen Unterstützung“ kämpfte – negative Erfahrungen wurde durchweg als neutral klassifiziert. Ohne eine strukturierte Möglichkeit zur Evaluation und zum Vergleich wären diese Probleme viel schwerer zu erkennen gewesen.
Der traditionelle Ansatz: Gut, aber unordentlich
Bevor wir MLflow erkunden, lasst uns schnell den Standardweg anerkennen, wie wir das oft machen. Es umfasst normalerweise eine Schleife, einige Kennzahlenberechnungen und dann eine manuelle Aggregation. Etwas in dieser Art:
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
# ... andere Imports ...
# Angenommen, X, y sind deine Merkmale und Labels
# X_train, X_test, y_train, y_test = train_test_split(...)
# Ein Dummy-Modell
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Berechne Kennzahlen
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"Genauigkeit: {accuracy:.4f}")
print(f"Präzision: {precision:.4f}")
print(f"Erinnerung: {recall:.4f}")
print(f"F1-Score: {f1:.4f}")
# Du würdest dies dann vielleicht in eine CSV speichern, eine Konfusionsmatrix plotten usw.
# metrics_df = pd.DataFrame({"metric": ["accuracy", "precision", "recall", "f1"],
# "value": [accuracy, precision, recall, f1]})
# metrics_df.to_csv("model_metrics_v1.csv", index=False)
Das ist in Ordnung für einen einzelnen Lauf, aber stell dir vor, du machst das für 10 verschiedene Modelle oder 5 verschiedene Versionen desselben Modells mit unterschiedlichen Hyperparametern. Du endest mit `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv` usw. Es wird schnell unhandlich.
MLflow’s Model Evaluation APIs: Ein frischer Blick
Die Modellbewertungsfähigkeiten von MLflow zielen darauf ab, Struktur und Standardisierung in diesen Prozess zu bringen. Die Grundidee ist, dass, wenn du ein Modell mit `mlflow.log_model()` protokollierst, du auch einen Bewertungsdurchlauf auslösen kannst, der Kennzahlen, Plots und sogar benutzerdefinierte Bewertungsartefakte zusammen mit deinem Modell speichert. Das bedeutet, dass alle deine Bewertungsergebnisse direkt mit der Modellversion und dem Experimentdurchlauf verknüpft sind, die sie hervorgebracht haben.
Die Schlüsselkomponenten hier sind `mlflow.evaluate()` und die Klassen `mlflow.models.EvaluationMetric` und `mlflow.models.EvaluationArtifact`. Lassen Sie uns aufschlüsseln, wie ich dies für mein Sentiment-Analyse-Projekt genutzt habe.
Beispiel 1: Grundlegende Evaluationsintegration
Zuerst benötigst du dein Modell und einige Testdaten. Für mein Sentiment-Modell hatte ich ein `pipeline`-Objekt (eine scikit-learn-Pipeline mit einem TfidfVectorizer und einem LogisticRegression-Klassifizierer) und ein `test_df` mit den Spalten `text` und `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
# Angenommen, du hast deine Daten geladen
# Zur Demonstration lassen Sie uns einige Dummy-Daten erstellen
data = {
'text': [
"Das Produkt ist erstaunlich, ich liebe es!",
"Schrecklicher Service, sehr langsame Antwort.",
"Es ist in Ordnung, nichts Besonderes.",
"Der beste Einkauf aller Zeiten, sehr zu empfehlen.",
"Der Kundenservice war unhilfsbereit und unhöflich.",
"Funktioniert wie erwartet, ziemlich Standard.",
"Ich bin absolut begeistert von diesem Gerät!",
"Defekt bei Lieferung, sehr enttäuschend.",
"Anständige Qualität für den Preis.",
"So ein tolles Erlebnis!",
"Schlechteste Erfahrung, nie wieder.",
"Neutrales Gefühl dabei, weder schlecht noch gut."
],
'sentiment': [
'positive', 'negative', 'neutral', 'positive', 'negative',
'neutral', 'positive', 'negative', 'neutral', 'positive',
'negative', 'neutral'
]
}
df = pd.DataFrame(data)
# Daten aufteilen
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']
)
# Eine einfache Pipeline erstellen
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Testdaten als DataFrame für mlflow.evaluate vorbereiten
test_df = pd.DataFrame({'text': X_test, 'true_sentiment': y_test})
with mlflow.start_run(run_name="Sentiment_Model_Evaluation_v1") as run:
# Protokolliere das Modell (optional, aber gute Praxis)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Durchführung der Evaluation
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Verwende die Standardbewertungsfunktionen für text_classification
# Du kannst hier benutzerdefinierte Kennzahlen oder Artefakte hinzufügen
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"MLflow Run ID: {run.info.run_id}")
Wenn du dies ausführst, berechnet MLflow automatisch die Standard-Klassifikationskennzahlen (Genauigkeit, Präzision, Rückruf, F1) und protokolliert sie. Es generiert auch einen Plot der Konfusionsmatrix, eine PR-Kurve und eine ROC-Kurve und speichert sie als Artefakte innerhalb des Laufs. Das ist bereits ein großer Fortschritt gegenüber dem manuellen Erzeugen und Speichern dieser!
Der Hinweis `model_type=”text_classification”` ist wichtig, da der `default`-Evaluator von MLflow dann weiß, welche Standardkennzahlen und Plots am relevantesten sind. Es gibt auch Standard-Evaluatoren für `regressor`, `classifier` und `question_answering` (nach meiner letzten Prüfung).
Beispiel 2: Benutzerdefinierte Kennzahlen und Artefakte für tiefere Einblicke
Die wahre Power, für mich, kam, als ich über die Standardkennzahlen hinausgehen musste. Erinnerst du dich an die Anfrage meines Kunden, die Leistung nach Produktkategorie aufzuschlüsseln? MLflow erlaubt es dir, `extra_metrics` und `extra_artifacts` zu definieren. Hier kannst du deine domänenspezifischen Bewertungen einfügen.
Für mein Sentiment-Modell wollte ich insbesondere den F1-Score für das Feedback zur „technischen Unterstützung“ sehen. Ich wollte auch ein DataFrame protokollieren, das falsch klassifizierte Beispiele zeigt, um häufige Fehler leicht zu überprüfen.
# ... (vorherige Einrichtung für Pipeline, X_train, X_test, y_train, y_test, df) ...
# Lassen Sie uns Produktkategorien für die Testdaten simulieren
# Zur Vereinfachung fügen wir einfach eine 'category'-Spalte zu test_df hinzu
# In einem realen Szenario würde dies aus Ihren tatsächlichen Daten stammen
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):
# Diese benutzerdefinierte Metrikfunktion erhält das Evaluations-DataFrame
# das 'targets' (wahre Labels) und 'predictions' enthält
tech_support_df = eval_df[eval_df['category'] == 'technical_support']
if len(tech_support_df) == 0:
return np.nan # Oder 0, je nach Vorliebe
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']]
# Speichern Sie die falsch klassifizierten Beispiele in einem CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Pfad zurückgeben, der als Artefakt protokolliert werden soll
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", # Die Spalte in test_df, die die wahren Labels enthält
model_type="text_classification",
evaluators=["default"],
extra_metrics=[
mlflow.models.EvaluationMetric(
name="f1_tech_support",
func=f1_score_tech_support,
greater_is_better=True,
# Das 'input_example' ist optional, hilft jedoch MLflow, die Funktionssignatur zu verstehen
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 ähnlich wie oben
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
]
)
print(f"MLflow Run ID mit benutzerdefinierten Metriken: {run.info.run_id}")
In diesem Beispiel:
- `f1_score_tech_support`: Diese Funktion nimmt das `eval_df` (das MLflow aus Ihren `data` und Modellergebnissen erstellt, wobei die Spalten ‘targets’ und ‘predictions’ hinzugefügt werden) und berechnet den F1-Score nur für die Zeilen, in denen die `category` ‘technical_support’ ist.
- `log_misclassified_examples`: Diese Funktion identifiziert falsch klassifizierte Zeilen, speichert sie in einem CSV und gibt den Pfad zurück. MLflow protokolliert dann dieses CSV als Artefakt.
Wenn Sie diesen Lauf in der MLflow-Benutzeroberfläche ansehen, sehen Sie ‘f1_tech_support’ zusammen mit Ihren anderen Metriken aufgeführt, und Sie finden ‘misclassified_samples.csv’ im Abschnitt Artefakte. Dies macht den Vergleich über mehrere Läufe hinweg unglaublich einfach. Ich konnte leicht sehen, ob mein feinabgestimmtes Modell den F1-Score für Feedback im technischen Support im Vergleich zur Basislinie verbessert hat, und dann schnell die falsch klassifizierten Beispiele herunterladen, um zu sehen, welche Art von Fehlern noch auftraten.
Was ich gelernt habe und warum es wichtig ist
Mein Einstieg in die Bewertungs-APIs von MLflow war ein bedeutender Wandel für dieses Sentiment-Analyse-Projekt. Hier sind die Gründe, warum ich dabei bleibe:
- Zentralisierte Vergleiche: Alle meine Bewertungsergebnisse – Standardmetriken, benutzerdefinierte Metriken und Grafiken – werden an einem Ort gespeichert, der direkt mit dem Modell-Lauf verknüpft ist. Kein mühsames Suchen in separaten Ordnern oder Tabellenkalkulationen mehr.
- Reproduzierbarkeit: Da die Bewertung Teil des MLflow-Laufs ist, ist sie unmittelbar an das genaue Modell, den Code und die verwendeten Daten gebunden. Das macht es einfacher, Ergebnisse zu reproduzieren und Änderungen zu verstehen.
- Anpassung ist der Schlüssel: Die Möglichkeit, benutzerdefinierte Metriken und Artefakte einzufügen, bedeutet, dass ich nicht auf allgemeine Bewertungen beschränkt bin. Ich kann die Bewertung an die spezifischen Bedürfnisse meines Projekts und meiner Kunden anpassen. Dies war entscheidend, um die Leistung in Bezug auf produktspezifische Kategorien zu vertiefen.
- Verbesserte Zusammenarbeit: Wenn man im Team arbeitet, können alle dieselben Bewertungsergebnisse in der MLflow-Benutzeroberfläche sehen. Dies erleichtert Diskussionen über die Modellleistung und mögliche Verbesserungen. Mein Kunde konnte direkt auf die MLflow-Benutzeroberfläche zugreifen und die Aufschlüsselung nach Kategorie sehen, was viel mehr Vertrauen förderte als das bloße Zusenden statischer Berichte.
Eine kleine Anmerkung: Wenn Sie benutzerdefinierte Metrik-/Artefaktfunktionen definieren, stellen Sie sicher, dass sie selbstständig sind und nicht von globalen Variablen außerhalb der übergebenen Parameter (wie `eval_df`) abhängen. Dies stellt sicher, dass sie im MLflow-Kontext vorhersagbar funktionieren.
Umsetzbare Erkenntnisse für Ihr nächstes KI-Projekt
Wenn Sie mit KI-Modellen arbeiten und eine strukturiertere Möglichkeit suchen, diese zu bewerten, kann ich Ihnen nur empfehlen, die Bewertungs-APIs von MLflow auszuprobieren. So können Sie beginnen:
- Einfach anfangen: Beginnen Sie damit, `mlflow.evaluate()` mit dem `default`-Evaluator für Ihren `model_type` zu integrieren. Sehen Sie, welche Metriken und Artefakte es automatisch generiert.
- Wesentliche benutzerdefinierte Metriken identifizieren: Überlegen Sie, was “Erfolg” für Ihr bestimmtes Modell in Ihrem spezifischen Anwendungsfall wirklich definiert. Ist es die Leistung auf einem bestimmten Datensatz? Ein bestimmter Fehlertyp? Erstellen Sie benutzerdefinierte Metrikfunktionen dafür.
- Informative Artefakte protokollieren: Hören Sie nicht bei Metriken auf. Welche Grafiken, Datenrahmen (wie falsch klassifizierte Beispiele) oder Berichte würden Ihnen helfen, das Verhalten Ihres Modells besser zu verstehen? Protokollieren Sie diese als benutzerdefinierte Artefakte.
- Die MLflow-Benutzeroberfläche erkunden: Verbringen Sie Zeit in der MLflow-Benutzeroberfläche, um Läufe zu vergleichen. Sehen Sie sich die Metrikdiagramme und die protokollierten Artefakte an. Hier zeigt sich der wahre Wert einer organisierten Bewertung.
- Halten Sie Ihre Bewertungsdaten konsistent: Stellen Sie sicher, dass der Testdatensatz, den Sie für die Bewertung verwenden, über verschiedene Modellversionen oder Experimente hinweg konsistent ist. Das ist grundlegend für bedeutungsvolle Vergleiche.
Über grundlegende Genauigkeitswerte hinauszugehen und eine gründliche Bewertung direkt in Ihren MLOps-Workflow zu integrieren, ist nicht nur eine nette Zusatzfunktion; es ist entscheidend, um solide, faire und wirklich nützliche KI-Systeme zu bauen. Die Bewertungs-APIs von MLflow bieten einen soliden Rahmen dafür.
Das war’s für heute! Ich hoffe, dieser tiefgreifende Einblick hilft Ihnen, Ihre KI-Modellbewertungen zu optimieren. Lassen Sie mich in den Kommentaren wissen, ob Sie MLflow für Bewertungen verwendet haben oder ob Sie andere Frameworks haben, auf die Sie schwören!
🕒 Published: