Hallo zusammen, hier ist Nina, zurück auf agntbox.com! Heute ist der 13. März 2026, und wenn ihr wie ich seid, quillt euer Posteingang wahrscheinlich über mit Ankündigungen zu neuen KI-Tools. Das Tempo der Innovation ist einfach unglaublich, oder?
Heute möchte ich über etwas sprechen, was mir seit einer Weile im Kopf herumgeht, besonders nach ein paar nächtlichen Sitzungen, in denen ich an einem bestimmten Projekt gearbeitet habe. Wir werden die Welt der Bewertung von KI-Modellen erkunden, mit einem speziellen Fokus auf ein Framework, das an Popularität gewonnen hat: die MLflow Modellbewertungs-APIs. Jetzt weiß ich, was einige von euch denken – „MLflow? Ist das nicht für MLOps und Tracking?“ Und ja, genau das ist es. Aber sie haben heimlich wirklich interessante Bewertungsfunktionen eingeführt, die meiner Meinung nach eine genauere Betrachtung verdienen, besonders wenn man versucht, über einen einfachen Genauigkeitswert hinauszugehen.
Zur Einordnung: Ich habe kürzlich ein Kundenprojekt abgeschlossen, das ein maßgeschneidertes Sentiment-Analyse-Modell für Kundenrückmeldungen beinhaltete. Der Kunde war nicht nur an einem „guten“ oder „schlechten“ Sentiment interessiert; er benötigte nuancierte Einblicke in warum ein Sentiment positiv oder negativ war und wie das Modell konsistent über verschiedene Produktkategorien hinweg performte. Mein anfänglicher Ansatz, wie so oft, war es, ein paar Python-Skripte zu erstellen, einige Metriken zu berechnen und alles in eine CSV zu kippen. Ihr kennt das – `sklearn.metrics` für Genauigkeit, Präzision, Recall, F1, vielleicht ein Plot der Verwirrungsmatrix mit Matplotlib. Das funktioniert, es ist in Ordnung. Aber dann wollte der Kunde einen Vergleich mit einem Referenzmodell, dann eine weitere Iteration, und plötzlich hatte ich ein Dutzend CSVs und Grafiken, die alle leicht unterschiedlich waren, aber kein klares Mittel, um sie systematisch zu vergleichen.
Da erinnerte ich mich, etwas über die erweiterten Bewertungsfunktionen von MLflow gesehen zu haben. Ich habe MLflow seit Ewigkeiten für das Tracking von Experimenten verwendet, aber ich hatte mich nie wirklich mit der Bewertungsseite beschäftigt. Und lasst mich euch sagen, es war ein bisschen wie ein Erleuchtungmoment. Anstatt das Rad für jeden Vergleich neu zu erfinden, konnte ich meine Bewertung direkt in meine bestehenden MLflow-Ausführungen integrieren, was alles viel organisierter und vergleichbarer machte.
Über eine einzige Metrik hinaus: Warum eine strukturierte Bewertung wichtig ist
Sind wir ehrlich: Wenn ihr KI-Modelle erstellt, besonders für Anwendungen in der realen Welt, erzählt ein einzelner Genauigkeitswert selten die ganze Geschichte. Ihr müsst verstehen:
- Bias: Leistet euer Modell über verschiedene demografische Gruppen, Produktkategorien oder Eingabetypen gleich?
- Robustheit: Wie geht es mit verrauschten Daten oder leichten Variationen in den Eingaben um?
- Erklärbarkeit: Könnt ihr verstehen warum das Modell eine bestimmte Vorhersage getroffen hat?
- Konkrete Fehlermuster: Wo irrt es sich konsistent?
Mein Sentiment-Analyse-Projekt hat das perfekt verdeutlicht. Eine Gesamtgenauigkeit von 85 % sah auf dem Papier großartig aus. Aber als wir sie nach Produktkategorie herunterbrachen, stellten wir fest, dass das Modell erheblich Mühe hatte mit Rückmeldungen zu „technischer Unterstützung“ – es klassifizierte systematisch negative Erfahrungen als neutral. Ohne eine strukturierte Art der Bewertung und des Vergleichs wäre es viel schwieriger gewesen, diese Probleme zu erkennen.
Der traditionelle Ansatz: Gut, aber unordentlich
Bevor wir MLflow erkunden, lassen Sie uns schnell die standardisierte Art und Weise betrachten, wie wir das oft tun. Das umfasst in der Regel eine Schleife, ein paar Metrikberechnungen und dann manuelle Aggregation. Etwas wie das hier:
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
# ... weitere Imports ...
# Angenommen, X, y sind eure 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)
# Metriken berechnen
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"Recall: {recall:.4f}")
print(f"F1-Score: {f1:.4f}")
# Ihr könntet diese Daten dann in eine CSV speichern, eine Verwirrungsmatrix zeichnen, 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 gut für eine einzige Ausführung, aber stellt euch vor, das für 10 verschiedene Modelle zu tun oder 5 verschiedene Versionen desselben Modells mit unterschiedlichen Hyperparametern. Ihr landet schnell mit `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv` und so weiter. Das wird schnell unübersichtlich.
Die MLflow Modellbewertungs-APIs: Ein neuer Überblick
Die Modellbewertungsfunktionen von MLflow sollen Struktur und Standardisierung in diesen Prozess bringen. Die Hauptidee ist, dass, wenn ihr ein Modell mit `mlflow.log_model()` speichert, ihr auch eine Bewertungsdurchführung auslösen könnt, die die Metriken, Grafiken und sogar benutzerdefinierte Bewertungsartefakte zusammen mit eurem Modell speichert. Das bedeutet, dass alle eure Bewertungsergebnisse direkt mit der Modellversion und der Ausführung des Experiments verknüpft sind, die sie hervorgebracht hat.
Die Schlüsselfunktionen hier sind `mlflow.evaluate()` und die Klassen `mlflow.models.EvaluationMetric` und `mlflow.models.EvaluationArtifact`. Lassen Sie uns durchgehen, wie ich das für mein Sentiment-Analyse-Projekt verwendet habe.
Beispiel 1: Integration der Basisbewertung
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, Sie haben Ihre Daten geladen
# Zur Demonstration erstellen wir Dummy-Daten
data = {
'text': [
"Das Produkt ist unglaublich, ich liebe es!",
"Schlechter Service, sehr langsame Antwort.",
"Es ist durchschnittlich, nichts Besonderes.",
"Bester Kauf aller Zeiten, sehr empfehlenswert.",
"Der Kundenservice war unnötig und unhöflich.",
"Funktioniert wie erwartet, ziemlich Standard.",
"Absolut begeistert von diesem Gerät!",
"Defekt bei der Ankunft, sehr enttäuscht.",
"Ordentliche Qualität für den Preis.",
"Eine so tolle Erfahrung!",
"Schlechteste Erfahrung, nie wieder.",
"Neutrales Gefühl dazu, weder schlecht noch gut."
],
'sentiment': [
'positiv', 'negativ', 'neutral', 'positiv', 'negativ',
'neutral', 'positiv', 'negativ', 'neutral', 'positiv',
'negativ', 'neutral'
]
}
df = pd.DataFrame(data)
# Aufteilen der Daten
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']
)
# Einen einfachen Pipeline aufbauen
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Testdaten in einen 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:
# Modell protokollieren (optional, aber gute Praxis)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Durchführung einer Bewertung
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Verwenden Sie die Standardbewertung für text_classification
# Hier können Sie benutzerdefinierte Metriken oder Artefakte hinzufügen
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"MLflow Ausführungs-ID: {run.info.run_id}")
Wenn Sie dies ausführen, berechnet MLflow automatisch die Standardklassifizierungsmetriken (Genauigkeit, Präzision, Rückruf, F1) und protokolliert sie. Es erzeugt auch eine Verwirrungsmatrix-Darstellung, eine PR-Kurve und eine ROC-Kurve, die als Artefakte innerhalb des Laufs gespeichert werden. Das ist bereits ein riesiger Fortschritt im Vergleich zur manuellen Erstellung und Speicherung dieser!
Der Hinweis `model_type=”text_classification”` ist wichtig, da der `default`-Evaluator von MLflow dann weiß, welche Metriken und welche Standardgrafiken am relevantesten sind. Es gibt auch Standard-Evaluator für `regressor`, `classifier` und `question_answering` (bei meinem letzten Stand).
Beispiel 2: Benutzerdefinierte Metriken und Artefakte für tiefere Einblicke
Die wahre Macht kam für mich, als ich über die Standardmetriken hinausgehen musste. Erinnern Sie sich an die Anfrage meines Kunden, die Leistung nach Produktkategorie aufzuschlüsseln? MLflow ermöglicht es Ihnen, `extra_metrics` und `extra_artifacts` festzulegen. Hier können Sie Ihre spezifischen Domain-Bewertungen einfügen.
Für mein Sentiment-Modell wollte ich den F1-Score speziell für Rückmeldungen im Zusammenhang mit „technischer Unterstützung“ sehen. Ich wollte auch einen DataFrame protokollieren, der falsch klassifizierte Beispiele zeigt, um die häufigsten Fehler leicht durchzugehen.
# ... (vorherige Konfiguration für den Pipeline, X_train, X_test, y_train, y_test, df) ...
# Simulieren wir die Produktkategorien für die Testdaten
# Zur Vereinfachung fügen wir einfach eine Spalte 'category' 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 den Bewertungs-DataFrame
# der die 'Ziele' (wahren Labels) und 'Vorhersagen' 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 einer CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Geben Sie den Pfad zurück, um ihn als Artefakt zu speichern
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 aber MLflow, die Funktion 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 Ausführungs-ID mit benutzerdefinierten Metriken: {run.info.run_id}")
In diesem Beispiel:
- `f1_score_tech_support`: Diese Funktion erhält das `eval_df` (das MLflow aus Ihren `data` und den Modellvorhersagen 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 die falsch klassifizierten Zeilen, speichert sie in einer CSV und gibt den Pfad zurück. MLflow protokolliert dann diese CSV als Artefakt.
Wenn Sie diesen Lauf in der MLflow-Oberfläche anzeigen, sehen Sie ‘f1_tech_support’ neben Ihren anderen Metriken aufgelistet, und Sie finden ‘misclassified_samples.csv’ im Abschnitt der Artefakte. Das macht Vergleiche zwischen den Ausführungen unglaublich einfach. Ich konnte leicht sehen, ob mein verfeinertes Modell den F1-Score für Rückmeldungen zur technischen Unterstützung im Vergleich zur Basislinie verbessert hat, und dann schnell die falsch klassifizierten Beispiele herunterladen, um zu sehen, welche Art von Fehlern immer noch auftraten.
Was ich gelernt habe und warum das wichtig ist
Mein Ausflug in die Evaluations-APIs von MLflow war ein signifikanter Wandel für dieses Projekt zur Sentimentanalyse. Hier ist der Grund, warum ich dabei bleibe:
- Zentrale Vergleichbarkeit: Alle meine Bewertungsergebnisse – Standardmetriken, benutzerdefinierte Metriken und Grafiken – sind an einem einzigen Ort gespeichert, direkt verknüpft mit der Modellausführung. Schluss mit dem Suchen in separaten Ordnern oder Tabellen.
- Reproduzierbarkeit: Da die Bewertung Teil des MLflow-Laufs ist, ist sie intrinsisch mit dem genauen Modell, dem verwendeten Code und den Daten verbunden. Das erleichtert die Wiederholung der Ergebnisse und das Verständnis von Änderungen erheblich.
- Personalisierung ist der Schlüssel: Die Fähigkeit, benutzerdefinierte Metriken und Artefakte einzufügen, bedeutet, dass ich nicht auf generische Bewertungen beschränkt bin. Ich kann die Bewertung an die spezifischen Bedürfnisse meines Projekts und meines Kunden anpassen. Das war entscheidend, um die Leistung nach Produktkategorie zu untersuchen.
- Verbesserte Zusammenarbeit: Wenn man im Team arbeitet, können alle die gleichen Bewertungsergebnisse in der MLflow-Oberfläche sehen. Das vereinfacht die Diskussionen über die Modellleistung und mögliche Verbesserungen. Mein Kunde konnte direkt auf die MLflow-Oberfläche zugreifen und die Verteilung nach Kategorien sehen, was viel mehr Vertrauen schuf, als einfach statische Berichte zu senden.
Eine kleine Anmerkung: Wenn Sie benutzerdefinierte Metrik-/Artefaktfunktionen definieren, stellen Sie sicher, dass sie unabhängig sind und nicht von globalen Variablen abhängig sind, die nicht übergeben werden (wie `eval_df`). Das stellt sicher, dass sie sich im MLflow-Kontext vorhersehbar verhalten.
Konkrete Schritte für Ihr nächstes KI-Projekt
Wenn Sie mit KI-Modellen arbeiten und nach einer strukturierteren Möglichkeit suchen, diese zu bewerten, kann ich Ihnen nur empfehlen, die Evaluations-APIs von MLflow auszuprobieren. Hier ist, wie Sie anfangen können:
- Beginnen Sie Einfach : Starten Sie mit der Integration von `mlflow.evaluate()` mit dem `default` Evaluator für Ihren `model_type`. Sehen Sie, welche Metriken und Artefakte es automatisch generiert.
- Identifizieren Sie Schlüssel-Kundenmetriken : Überlegen Sie, was den “Erfolg” für Ihr spezifisches Modell in Ihrem speziellen Anwendungsfall wirklich definiert. Ist es die Leistung auf einem bestimmten Datensatz? Ein spezifischer Fehlertyp? Erstellen Sie dafür benutzerdefinierte Metrikfunktionen.
- Speichern Sie Computerartefakte : Beschränken Sie sich nicht auf Metriken. Welche Grafiken, DataFrames (wie fehlerhafte Beispiele) oder Berichte würden Ihnen helfen, das Verhalten Ihres Modells besser zu verstehen? Speichern Sie diese als benutzerdefinierte Artefakte.
- Erforschen Sie die MLflow-Oberfläche : Verbringen Sie Zeit in der MLflow-Oberfläche, um Ausführungen zu vergleichen. Schauen Sie sich die Grafiken der Metriken und die gespeicherten Artefakte an. Hier zeigt sich der wahre Wert einer organisierten Bewertung.
- Halten Sie Ihre Bewertungsdaten Konsistent : Stellen Sie sicher, dass der Datensatz, den Sie für die Bewertung verwenden, zwischen verschiedenen Modellen oder Experimenten konsistent ist. Dies ist entscheidend für aussagekräftige Vergleiche.
Über die grundlegenden Genauigkeitswerte hinauszugehen und eine tiefgehende Bewertung direkt in Ihren MLOps-Workflow zu integrieren, ist nicht nur eine einfache Ergänzung; es ist entscheidend, um solide, faire und tatsächlich nützliche KI-Systeme aufzubauen. Die Evaluierungs-APIs von MLflow bieten einen effektiven Rahmen dafür.
Das ist alles von mir heute! Ich hoffe, dass Ihnen dieser tiefere Einblick hilft, Ihre KI-Modellbewertungen zu optimieren. Lassen Sie mich in den Kommentaren wissen, ob Sie MLflow für die Bewertung verwendet haben oder ob Sie andere Frameworks bevorzugen!
🕒 Published: