Warum ML -Modelle überwachen?

Projekte für maschinelles Lernen sind iterative Prozesse. Sie halten nicht nur in einem erfolgreichen Modell in einem Jupyter -Notebook an. Sie h?ren nicht einmal auf, nachdem das Modell online ist, und die Leute k?nnen darauf zugreifen. Auch nach dem Einsatz müssen Sie es st?ndig so gut babysitten, dass es genauso gut funktioniert wie in der Entwicklungsphase.

Zillows Skandal ist ein perfektes Beispiel dafür, was passiert, wenn Sie dies nicht tun. Im Jahr 2021 verlor Zillow aufgrund ihres maschinellen Lernenmodells, das die Immobilienpreise sch?tzten, beeindruckende 304 Millionen Dollar. Zillow überbezahlt für mehr als 7000 H?user und musste sie zu einem viel günstigeren Preis abladen. Das Unternehmen wurde von seinem eigenen Modell ?abgerissen“ und musste seine Belegschaft um 25%reduzieren.

Diese Arten von stillen Modellfehlern sind bei realen Modellen gemeinsam, daher müssen sie st?ndig aktualisiert werden, bevor ihre Produktionsleistung sinkt. Dies schadet den Ruf der Unternehmen, das Vertrauen mit den Stakeholdern und letztendlich ihre Taschen.

.

In diesem Artikel werden Sie vermittelt, wie Sie einen End-to-End-Workflow zur überwachung von maschinellem Lernmodellen nach der Bereitstellung mit Nannyml implementieren.

nannyml ist eine wachsende Open-Source-Bibliothek, die sich auf maschinelles Lernen nach der Einführung konzentriert. Es bietet eine breite Palette von Funktionen, um alle Arten von Problemen zu l?sen, die in Produktions -ML -Umgebungen auftreten. Um nur einige zu nennen:

• Drifterkennung: Erkennt Datenverteilungs?nderungen zwischen Trainings- und Produktionsdaten.
• Leistungssch?tzung: Sch?tzungen der Modellleistung in der Produktion ohne unmittelbare Grundwahrheit.
• Automatisierte Berichterstattung: generiert Berichte über die modellische Gesundheit und Leistung.
• WARTING -SYSTEM: bietet Warnungen für Datendrift- und Leistungsprobleme.
• Modell Fairness Assessment: Monitore Modell Fairness zur Verhinderung von Verzerrungen.
• Kompatibilit?t mit ML -Frameworks: Integriert in alle Rahmenbedingungen für maschinelles Lernen.
• benutzerfreundliche Schnittstelle: bietet eine vertraute scikit-larn-?hnliche Schnittstelle.

Wir werden die technischen Teile dieser Funktionen einzeln lernen.

Voraussetzungskonzepte behandelten

Wir werden die grundlegenden Konzepte der Modellüberwachung durch die Analogie eines Roboter -Mastering -Bogenschie?ens lernen.

in unserer Analogie:

• Der Roboter repr?sentiert unser Modell für maschinelles Lernen.
• Das Ziel repr?sentiert das Ziel oder Ziel unseres Modells.
• Wir k?nnen sagen, dass dies ein Regressionsproblem ist, da die Bewertungen berechnet werden, basierend darauf, wie nahe die Pfeile an das Auge des Stiers geschossen werden - der rote Punkt in der Mitte.
• Die Eigenschaften der Pfeile und des Bogens sowie die physikalischen Attribute und Umgebungsbedingungen des Roboters (wie Wind und Wetter) sind die Merkmale oder Eingangsvariablen unseres Modells.

Also starten wir.

Datendrift

Stellen Sie sich vor, wir haben den Bogen, die Pfeile und das Ziel sorgf?ltig vorbereitet (wie die Datenvorbereitung). Unser Roboter, ausgestattet mit vielen Sensoren und Kameras, schie?t w?hrend des Trainings 10000 Mal. Im Laufe der Zeit beginnt es mit beeindruckender Frequenz auf das Auge des Stiers zu treffen. Wir sind begeistert von der Leistung und beginnen mit dem Verkauf unseres Roboters und seinen Kopien an Bogenschie?enliebhaber (das Modell bereitzustellen).

Aber bald bekommen wir einen Strom von Beschwerden. Einige Benutzer berichten, dass dem Roboter das Ziel v?llig fehlt. überrascht, wir sammeln ein Team, um zu besprechen, was schief gelaufen ist.

Was wir finden, ist ein klassischer Fall von Datendrift . Die Umgebung, in der die Roboter arbeiten

Diese reale Verschiebung der Eingabefunktionen hat die Genauigkeit unseres Roboters abgeworfen, ?hnlich wie ein maschinelles Lernmodell unterdurchschnittlich bei Eingabedaten, insbesondere der Beziehung zwischen Merkmalen, ?ndert sich im Laufe der Zeit.

Konzept Drift

Nachdem wir uns mit diesen Problemen befasst haben, ver?ffentlichen wir eine neue Reihe von Robotern. In ein paar Wochen flie?en ?hnliche Beschwerden ein. Verwirrt sind wir tiefer und stellen fest, dass die Ziele h?ufig von Benutzern ersetzt wurden.

Diese neuen Ziele variieren in der Gr??e und werden in unterschiedlichen Entfernungen platziert. Diese ?nderung erfordert einen anderen Ansatz für die Schie?technik des Roboters - ein Lehrbuchbeispiel für

Konzept Drift .

In maschinellem Lernen tritt die Konzeptdrift auf, wenn sich die Beziehung zwischen den Eingabevariablen und dem Zielergebnis ?ndert. Für unsere Roboter mussten die neuen Arten von Zielen nun an das Aufnehmen anpassen, so wie sich ein maschinelles Lernenmodell anpassen muss, wenn sich die Dynamik der Daten erheblich geschult wurde.

mehr reale Beispiele für Konzept und Datendrift

, um die Punkte nach Hause zu bringen, lassen Sie uns einige Beispiele für die Aufnahme von Daten und Konzepten untersuchen.

Datendriftbeispiele

1. Kreditbewertungsmodelle: Wirtschaftliche Ver?nderungen ver?ndern die Ausgaben und die Kreditgewohnheiten der Menschen. Wenn sich ein Kreditbewertungsmodell nicht anpasst, kann dies zu ungerechtfertigten Ablehnungen oder riskanten Genehmigungen führen.
2. Gesundheit überwachten Systeme: Im Gesundheitswesen k?nnen ?nderungen der Demografie der Benutzer oder der Sensorkalibrierung zu ungenauen Gesundheitsbewertungen aus Modellen zur überwachung von Patienten -Vitalen führen.
.
3. Prognose für den Einzelhandel Nachfrage:
Im Einzelhandel k?nnen Verschiebungen des Verbraucherverhaltens und Trends frühere Vertriebsdatenbasis-Modelle bei der Vorhersage der aktuellen Produktbedarf unwirksam machen.

Beispiele für Konzeptdrift

1. Social -Media -Inhaltsherd:
Inhalts Moderationsmodelle müssen sich st?ndig an sich entwickelnde Sprach- und kulturelle Ph?nomene anpassen oder das Risiko eingehen, was als unangemessen angesehen wird.
2. Autonome Fahrzeuge:
Modelle in selbstfahrenden Autos müssen für regionale Verkehrsregeln und -bedingungen für die beste Leistung aktualisiert werden.
3. Betrugserkennungsmodelle:
Da sich betrügerische Taktiken entwickeln, müssen Betrugserkennungsmodelle aktualisiert werden, um aufkommende Muster zu identifizieren.

Betrachten wir nun einen End-to-End-ML-überwachungs-Workflow.

Wie sieht ein End-to-End-ML-Modellüberwachungs-Workflow aus?

Modellüberwachung umfasst drei Hauptschritte, denen ML -Ingenieure iterativ folgen sollten.

1. überwachungsleistung

Der erste Schritt besteht natürlich darin, die Modellleistung in der Bereitstellung genau im Auge zu behalten. Aber das ist leichter gesagt als getan.

Wenn für ein Modell in der Produktion sofort Grundwahrheit verfügbar ist, ist es einfach, ?nderungen des Modellverhaltens zu erkennen. Zum Beispiel k?nnen die Benutzer sofort sagen, was in unserer Analogie für Roboter/Bogenschie?en falsch ist

Nehmen Sie dagegen das Beispiel eines Modells, das Kreditausf?lle vorhersagt. Solche Modelle sagen voraus, ob ein Benutzer bei der n?chsten Zahlung oder nicht jeden Monat ausf?llt. Um die Vorhersage zu überprüfen, muss das Modell bis zum tats?chlichen Zahlungsdatum warten. Dies ist ein Beispiel für verz?gerte Grundwahrheit , was in realer maschineller Lernsysteme am h?ufigsten vorkommt.

In solchen F?llen ist es zu kostspielig, um zu warten, bis die Grundwahrheit verfügbar ist, um festzustellen, ob Modelle gut abschneiden. ML -Ingenieure ben?tigen also Methoden, um die Modellleistung ohne sie zu sch?tzen. Hier kommen Algorithmen wie CBPE oder DLE ins Spiel (mehr sp?ter).

überwachungsmodelle k?nnen auch durch Messung der direkten gesch?ftlichen Auswirkung durchgeführt werden, d. H. Die überwachung von KPIs (wichtige Leistungsindikatoren). In Zillows Fall h?tte ein ordnungsgem??es überwachungssystem den Gewinnverlust erkennen und die Ingenieure (hypothetisch) alarmiert haben.

2. Ursachenanalyse

Wenn das überwachungssystem einen Leistungsabfall erkennt, unabh?ngig davon, ob das System die realisierte Leistung (mit Bodenwahrheit) oder die gesch?tzte Leistung (ohne Grundwahrheit) analysiert hat, müssen ML -Ingenieure die Ursache hinter dem Abfall identifizieren.

Dies beinhaltet normalerweise die überprüfung von Funktionen einzeln oder in Kombination für Daten (Feature -Drift) und die Untersuchung der Ziele für die Konzeptdrift.

Basierend auf ihren Erkenntnissen verwenden sie verschiedene Problemaufl?sungstechniken.

3. Ausgabeaufl?sung

Hier finden Sie eine nicht exklusive Liste von Techniken, um die Sch?den zu verringern,

1. Datenausgleich: Wenn der Leistungsabfall auf Datendrift zurückzuführen ist, ist die Anpassung des Trainingsdatensatzes eine gute Option.
2. Feature Engineering: Aktualisieren oder Erstellen neuer Funktionen k?nnen die Modellleistung verbessern. Dies ist ein guter Ansatz in F?llen von Konzeptdrift, bei denen sich die Beziehung zwischen Eing?ngen und Ausgaben ge?ndert hat.
3. Modellumschulung: Eine teurere Methode ist das Umschulungen des Modells mit frischen Daten, um sicherzustellen, dass es genau bleibt. Dies funktioniert sowohl für Daten- als auch für Konzeptdrift.
4. Modell Feinabstimmung: Anstatt von Grund auf neu zu kehren, k?nnen einige Modelle auf einem kürzlich durchgeführten Datensatz fein abgestimmt werden. Dies funktioniert gut mit tiefem Lernen und generativen Modellen.
5. Anomalieerkennung: Verwenden von Anomalie -Erkennungsmethoden kann ungew?hnliche Muster in Produktionsdaten frühzeitig identifizieren.
6. Domain -Fachkenntnisse Beteiligung: Dom?nenexperten anziehen k?nnen tiefe Einblicke in die Gründe geben, warum die Modelle m?glicherweise unterdurchschnittlich sind.

Jede Methode hat ihren Anwendungskontext, und h?ufig k?nnen Sie eine Kombination von ihnen implementieren.

Nannyml befasst sich mit den ersten beiden Schritten dieses iterativen Prozesses. Also lasst uns darauf ankommen.

Schritt 1: Vorbereitung der Daten für Nannyml

Abgesehen von Trainings- und Validierungss?tzen ben?tigt Nannyml zwei zus?tzliche S?tze, die als Referenz und Analyse in bestimmten Formaten bezeichnet werden, um mit der überwachung zu beginnen. In diesem Abschnitt wird Ihnen ermittelt, wie Sie sie aus allen Daten erstellen.

Erstens ben?tigen wir ein Modell, das bereits geschult und bereit ist, um in die Produktion eingesetzt zu werden, damit wir es überwachen k?nnen. Zu diesem Zweck verwenden wir den Diamonds -Datensatz und trainieren einen Xgboost -Regressor.

Daten laden, Features definieren und zielen

import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore")

Der erste Schritt nach dem Importieren von Modulen besteht darin, den Diamonds -Datensatz von Seeborn zu laden. Wir werden jedoch eine spezielle Version des Datensatzes verwenden, die ich speziell für diesen Artikel vorbereitet habe, um zu veranschaulichen, wie die überwachung aussieht. Sie k?nnen den Datensatz mit dem folgenden Snippet in Ihre Umgebung laden:

dataset_link = "https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2024/1_january/4_intro_to_nannyml/diamonds_special.csv"

diamonds_special = pd.read_csv(dataset_link)
diamonds_special.head()

Diese spezielle Version des Datensatzes hat eine Spalte mit dem Namen "Set", die wir in einer Sekunde erhalten.

Im Moment extrahieren wir alle Feature -Namen, die kategorialen Feature -Namen und den Zielnamen:

import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore")

Die Aufgabe ist eine Regression - wir werden die Diamantpreise angesichts ihrer physischen Attribute vorhersagen.

Der Diamonds -Datensatz ist ziemlich sauber. Die einzige Vorverarbeitung, die wir durchführen, besteht darin, die Textfunktionen in den Datentyp der Kategorie von Pandas zu übertragen. Dies ist eine Voraussetzung, um die automatische kategoriale Datenvorverarbeitung durch Xgboost zu aktivieren.

dataset_link = "https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2024/1_january/4_intro_to_nannyml/diamonds_special.csv"

diamonds_special = pd.read_csv(dataset_link)
diamonds_special.head()

Lassen Sie uns die Daten aufteilen.

Aufteilen der Daten in vier S?tze

Ja, Sie haben das richtig gelesen. Wir werden die Daten in vier S?tze aufteilen. Traditionell haben Sie es m?glicherweise nur in drei aufgeteilt:

• Trainingssatz damit das Modell Muster
lernt
• Validierungssatz
Für Hyperparameter -Tuning
• Testssatz
Für die endgültige Bewertung vor der Bereitstellung

Workflows für Modellüberwachung erfordern einen weiteren Satz, um die Produktionsdaten nachzuahmen. Dies soll sicherstellen, dass unser System die Leistungsabf?lle korrekt erkennt, indem die richtigen Algorithmen verwendet werden und berichtet, was schief gelaufen ist.

Zu diesem Zweck habe ich die Zeilen von Diamonds Special mit vier Kategorien in der Spalte festgelegt:

# Extract all feature names
all_feature_names = diamonds_special.drop(["price", "set"], axis=1).columns.tolist()

# Extract the columns and cast into category
cats = diamonds_special.select_dtypes(exclude=np.number).columns

# Define the target column
target = "price"

Der Trainingssatz entspricht 70%, w?hrend der Rest jeweils 10% der Gesamtdaten ist. Lassen Sie es uns teilen:

for col in cats:
   diamonds_special[col] = diamonds_special[col].astype("category")

, aber reale Datens?tze werden nicht mit integrierten Set-Labels geliefert, sodass Sie die Daten selbst manuell in vier S?tze aufteilen müssen. Hier ist eine Funktion, die die Aufgabe mit train_test_split von sklearn ausleitet:

diamonds_special.set.unique()
['train', 'val', 'test', 'prod']
Categories (4, object): ['prod', 'test', 'train', 'val']

Hinweis:

Verwenden Sie die Schaltfl?che ?Code erkl?ren“, um eine zeilenweise Erl?uterung der Funktion zu erhalten.

Lassen Sie uns nun zum Modelltraining übergehen.

trainieren ein Modell

Vor dem Training eines XGBOOST -Modells müssen wir die Datens?tze in DMatrices umwandeln. Hier ist der Code:

tr = diamonds_special[diamonds_special.set == "train"].drop("set", axis=1)
val = diamonds_special[diamonds_special.set == "validation"].drop("set", axis=1)
test = diamonds_special[diamonds_special.set == "test"].drop("set", axis=1)
prod = diamonds_special[diamonds_special.set == "prod"].drop("set", axis=1)

tr.shape
(37758, 10)

Hier ist der Code, um einen Regressor mit bereits abgestimmten Hyperparametern zu trainieren:

def split_into_four(df, train_size=0.7):
   """
   A function to split a dataset into four sets:
   - Training
   - Validation
   - Testing
   - Production
   train_size is set by the user.
   The remaining data will be equally divided between the three sets.
   """
   # Do the splits
   training, the_rest = train_test_split(df, train_size=train_size)
   validation, the_rest = train_test_split(the_rest, train_size=1 / 3)
   testing, production = train_test_split(the_rest, train_size=0.5)

   # Reset the indices
   sets = (training, validation, testing, production)
   for set in sets:
       set.reset_index(inplace=True, drop=True)

   return sets


tr, val, test, prod = split_into_four(your_dataset)

Gro?artig - Wir haben ein Modell, das 503 $ in Bezug auf RMSE im Validierungssatz erreicht. Bewerten wir das Modell ein letztes Mal im Testsatz:

dtrain = xgb.DMatrix(tr[all_feature_names], label=tr[target], enable_categorical=True)
dval = xgb.DMatrix(val[all_feature_names], label=val[target], enable_categorical=True)

dtest = xgb.DMatrix(
   test[all_feature_names], label=test[target], enable_categorical=True
)
dprod = xgb.DMatrix(
   prod[all_feature_names], label=prod[target], enable_categorical=True
)

Die Testleistung betr?gt 551 $. Das ist gut genug.

Erstellen eines Referenzsatzes

Bis zu diesem Zeitpunkt war alles ziemlich einfach. Jetzt kommen wir zum Hauptteil - erstellen Sie Referenz- und Analyse -Sets.

Ein Referenzsatz ist ein anderer Name für den im Modellüberwachungskontext verwendeten Testsatz. Nannyml verwendet die Leistung des Modells im Testsatz als Grundlinie für die Produktionsleistung. Der Referenzsatz muss zwei Spalten von den Merkmalen haben:

• Das Ziel selbst - die Grundwahrheit - Diamantpreise
• Die Testvorhersagen - Wir haben sie in y_test_pred
generiert

Im Moment enth?lt unser Testsatz die Funktionen und das Ziel, fehlt jedoch y_test_pred:

import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore")

Fügen wir es hinzu:

dataset_link = "https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2024/1_january/4_intro_to_nannyml/diamonds_special.csv"

diamonds_special = pd.read_csv(dataset_link)
diamonds_special.head()

Jetzt werden wir den Test in Referenz umbenennen:

# Extract all feature names
all_feature_names = diamonds_special.drop(["price", "set"], axis=1).columns.tolist()

# Extract the columns and cast into category
cats = diamonds_special.select_dtypes(exclude=np.number).columns

# Define the target column
target = "price"

Erstellen eines Analysesatzes

Stellen wir uns zu diesem Zeitpunkt vor, dass unser Regressor in der Cloud eingesetzt wird. Die Vorstellung ist einfacher als die Bereitstellung des Modells, das für diesen Artikel übertrieben ist.

Nachdem wir unser Diamonds -Preismodell eingesetzt haben, erhalten wir die Nachricht, dass eine gro?e Versand von Diamanten kommt. Bevor die Fracht eintrifft, wurden uns die physischen Messungen von Diamanten als Prod (wir stellen uns immer noch vor) gesendet, damit wir Preise für sie generieren und auf unserer Website vermarkten k?nnen. Lassen Sie uns also generieren.

for col in cats:
   diamonds_special[col] = diamonds_special[col].astype("category")

Bevor die tats?chlichen Diamanten ankommen und ein menschlicher Spezialist die von unserem Modell generierten Preise überprüft, müssen wir überprüfen, ob unser Modell gut abschneidet. Wir m?chten die Diamanten nicht mit ungenauen Preisen auf unserer Website anzeigen.

Um dies zu tun, müssten wir die Leistung des Modells messen, indem wir y_prod_prise mit den tats?chlichen Preisen neuer Diamanten, der Grundwahrheit, vergleichen. Aber wir werden keine Grundwahrheit haben, bevor die Preise überprüft werden. Wir müssten also die Leistung des Modells ohne Grundwahrheit sch?tzen.

Um diese Aufgabe zu erledigen, ben?tigt Nannyml einen Analysesatz - die Daten, die die Produktionsdaten mit Vorhersagen des Modells enthalten.

Erstellen eines Analysesatzes ?hnelt dem Erstellen einer Referenz:

diamonds_special.set.unique()
['train', 'val', 'test', 'prod']
Categories (4, object): ['prod', 'test', 'train', 'val']

Jetzt sind wir bereit, die Leistung des Regressors abzusch?tzen.

Schritt 2: Sch?tzung der Leistung in Nannyml

nannyml liefert zwei Hauptalgorithmen zur Sch?tzung der Leistung von Regressions- und Klassifizierungsmodellen:

• Direktverlustsch?tzung (DLE) für die Regression
• Konfidenzbasierte Leistungssch?tzung (CBPE) für die Klassifizierung

Wir werden den DLE -Algorithmus für unsere Aufgabe verwenden. DLE kann die Leistung eines Produktionsmodells ohne Grundwahrheit messen und verschiedene Regressions-Pseudo-Metrics wie RMSE, RMSLE, MAE usw. melden.

Um DLE zu verwenden, müssen wir zun?chst in die Verweise eingehen, um eine Basisleistung zu ermitteln.

Sch?tzung der Leistung unter Verwendung von DLE in Nannyml

tr = diamonds_special[diamonds_special.set == "train"].drop("set", axis=1)
val = diamonds_special[diamonds_special.set == "validation"].drop("set", axis=1)
test = diamonds_special[diamonds_special.set == "test"].drop("set", axis=1)
prod = diamonds_special[diamonds_special.set == "prod"].drop("set", axis=1)

tr.shape
(37758, 10)

Initialisieren von DLE ben?tigt drei Parameter - die Eingabefunktionsnamen, der Name der Spalte, die die Grundwahrheit für das Testen enth?lt, und den Namen der Spalte, die Testvorhersagen enth?lt.

Zus?tzlich verabschieden wir RMSE als Metrik und Stücke von 250.

def split_into_four(df, train_size=0.7):
   """
   A function to split a dataset into four sets:
   - Training
   - Validation
   - Testing
   - Production
   train_size is set by the user.
   The remaining data will be equally divided between the three sets.
   """
   # Do the splits
   training, the_rest = train_test_split(df, train_size=train_size)
   validation, the_rest = train_test_split(the_rest, train_size=1 / 3)
   testing, production = train_test_split(the_rest, train_size=0.5)

   # Reset the indices
   sets = (training, validation, testing, production)
   for set in sets:
       set.reset_index(inplace=True, drop=True)

   return sets


tr, val, test, prod = split_into_four(your_dataset)

Wir haben ein Nannyml -Ergebnisobjekt, das aufgetragen werden kann. Mal sehen, was es produziert:

import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore")

interpretieren wir das Diagramm - es verfügt über zwei Abschnitte, in denen die Leistung in den Referenz- und Analyse -S?tzen angezeigt wird. Wenn die gesch?tzte Produktion RMSE über die Schwellenwerte hinausgeht, markiert Nannyml sie als Warnungen.

Wie wir sehen k?nnen, haben wir einige Warnungen für Produktionsdaten, was darauf hindeutet, dass in den letzten Chargen etwas Fischiges vor sich geht.

Schritt 3: Gesch?tzt vs. realisierte Leistung bei der überwachung

Unser überwachungssystem zeigt uns, dass die Modellleistung in der Produktion um etwa die H?lfte gesunken ist. Aber es ist nur eine Sch?tzung - wir k?nnen es nicht sicher sagen.

W?hrend wir die gesch?tzte Leistung planen, ist die Sendung eingetroffen und unser Diamantenspezialist berechnete ihren tats?chlichen Preis. Wir haben sie als Preis in Produkt gespeichert.

Jetzt k?nnen wir die realisierte Leistung (tats?chliche Leistung) des Modells mit der gesch?tzten Leistung vergleichen, um festzustellen, ob unser überwachungssystem gut funktioniert.

Nannyml bietet dazu eine PerformanceCalculator -Klasse:

dataset_link = "https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2024/1_january/4_intro_to_nannyml/diamonds_special.csv"

diamonds_special = pd.read_csv(dataset_link)
diamonds_special.head()

Die Klasse erfordert vier Parameter:

• problem_type: Was ist die Aufgabe?
• y_true: Was sind die Etiketten?
• y_pred: Wo finde ich die Vorhersagen?
• Metriken: Mit welchen Metriken berechne ich die Leistung?

Nachdem wir diese übergeben und den Taschenrechner an die Referenz angemessen haben, berechnen wir den Analysesatz.

Um realized_results mit gesch?tzten_Resulten zu vergleichen, verwenden wir erneut ein visuelles:

# Extract all feature names
all_feature_names = diamonds_special.drop(["price", "set"], axis=1).columns.tolist()

# Extract the columns and cast into category
cats = diamonds_special.select_dtypes(exclude=np.number).columns

# Define the target column
target = "price"

Nun, es sieht so aus, als ob der gesch?tzte RMSE (lila) der tats?chlichen Leistung ziemlich nahe war (realisiert RMSE, Blau).

Dies sagt uns eines - unser überwachungssystem funktioniert gut, aber unser Modell ist nicht, wie der steigende Verlust angezeigt. Also, was ist der Grund (s)?

wir werden jetzt in das eintauchen.

Schritt 4: Drift -Erkennungsmethoden

Wie im Intro erw?hnt, ist einer der h?ufigsten Gründe, warum Modelle in der Produktion versagen, die Drift. In diesem Abschnitt konzentrieren wir uns auf die Datenerfassung von Daten (Feature).

Drifterkennung ist Teil des Schritts der Ursachenanalyse des Modellüberwachungs -Workflows. Es beginnt normalerweise mit einer multivariaten Drifterkennung.

Multivariate Drifterkennung

Eine der besten multivariaten Drift -Erkennungsmethoden ist die Berechnung des Datenrekonstruktionsfehlers unter Verwendung von PCA. Es funktioniert bemerkenswert gut und kann sogar die geringsten Drifts in Feature -Verteilungen fangen. Hier ist ein hochrangiger überblick über diese Methode:

1. PCA passt zur Referenz und komprimiert es auf eine niedrigere Dimension - Reference_lower.

• In diesem Schritt gehen einige Informationen über den ursprünglichen Datensatz aufgrund der Art von PCA verloren.

2. Reference_lower wird dann in seine ursprüngliche Dimensionalit?t dekomprimiert - Referenz_Reconstruation.

• Da die Informationen in Schritt 1 verloren gingen, sind die rekonstruierten Daten nicht vollst?ndig mit Referenz.

3. Die Differenz zwischen Referenz und Referenz_Reconstruation wird gefunden und als Datenrekonstruktionsfehler - reconstruct_error genannt.

• reconstruct_error arbeitet als Grundlinie zum Vergleich des Rekonstruktionsfehlers von Produktionsdaten

4. Die gleiche Reduktions-/Rekonstruktionsmethode wird auf Produktionsdaten angewendet.

• Wenn Rekonstruktionsfehler der Produktionsdaten h?her als die Basislinie sind, sind die Funktionen gesteuert.
• Das System sendet uns eine Warnung, die uns dazu veranlasst, Produktionsdaten weiter zu untersuchen

Diese vier Schritte werden in Nannyml als DataArConstructionDiftCalcuLculator -Klasse implementiert. Hier erfahren Sie, wie Sie es verwenden:

import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore")

Sobald wir den Fehler für jeden Datenblock haben (jeweils 250 Zeilen), k?nnen wir ihn zeichnen:

dataset_link = "https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2024/1_january/4_intro_to_nannyml/diamonds_special.csv"

diamonds_special = pd.read_csv(dataset_link)
diamonds_special.head()

Wie wir sehen k?nnen, ist der Rekonstruktionsfehler sehr hoch, was auf eine Drift der Merkmale hinweist. Wir k?nnen den Fehler auch mit der realisierten Leistung vergleichen:

# Extract all feature names
all_feature_names = diamonds_special.drop(["price", "set"], axis=1).columns.tolist()

# Extract the columns and cast into category
cats = diamonds_special.select_dtypes(exclude=np.number).columns

# Define the target column
target = "price"

Wie wir sehen k?nnen, entsprechen alle Spikes im Verlust mit Warnungen im Rekonstruktionsfehler.

univariate Drifterkennung

Datenrekonstruktionsfehler ist eine einzige Zahl, um die Drift für alle Funktionen zu messen. Aber wie w?re es mit der Drift einzelner Merkmale? Wenn unser Datensatz Hunderte von Funktionen enth?lt, wie würden wir dann die am meisten treibenden Funktionen finden und geeignete Ma?nahmen ergreifen?

Hier verwenden wir univariate Drift -Erkennungsmethoden. Nannyml bietet mehrere je nach Funktionstyp:

• Kategorische Merkmale: l-infinity, chi2
• kontinuierliche Merkmale: Wasserstein, Kolgomor-Smirnov-Test
• Beide: Jensen-Shannen-Distanz, Hellinger-Entfernung

All dies vergleichen die Verteilung einzelner Merkmale in Bezug auf die des Analysesatzes. Wir k?nnen einige (oder sogar alle) innerhalb der univariierten Riftcalculator -Klasse verwenden:

for col in cats:
   diamonds_special[col] = diamonds_special[col].astype("category")

Der einzige erforderliche Parameter ist column_names, der Rest kann von Nannyml eingestellt werden. Um die Dinge einfach zu halten, verwenden wir Wasserstein und Jensen_Shannon für kontinuierliche und kategorische Merkmale.

Im Moment haben wir 11 Funktionen, sodass Plot (). Show () m?glicherweise nicht die optimalen Ergebnisse liefern. Stattdessen k?nnen wir einen Warncone Ranker verwenden, um die Funktionen zurückzugeben, die die meisten Warnungen ergaben (wenn alle Teile berücksichtigt werden). Hier ist der Code:

diamonds_special.set.unique()
['train', 'val', 'test', 'prod']
Categories (4, object): ['prod', 'test', 'train', 'val']

Sobald wir die Ranker -Ergebnisse erzielt haben, k?nnen wir seinen Kopf drucken, da es sich um einen Pandas -Datenrahmen handelt:

tr = diamonds_special[diamonds_special.set == "train"].drop("set", axis=1)
val = diamonds_special[diamonds_special.set == "validation"].drop("set", axis=1)
test = diamonds_special[diamonds_special.set == "test"].drop("set", axis=1)
prod = diamonds_special[diamonds_special.set == "prod"].drop("set", axis=1)

tr.shape
(37758, 10)

Wir k?nnen sehen, dass die problematischsten Merkmale Farbe und Tiefe sind. Dies sollte mich nicht überraschen, da ich es war, der sie künstlich dazu veranlasste, vor dem Schreiben des Artikels zu driften.

Aber wenn dies ein reales Szenario w?re, m?chten Sie einige Zeit mit der Arbeit an der Probleml?sung für diese Funktionen verbringen.

Schlussfolgerung

Ich finde die Modellüberwachung faszinierend, weil es die Illusion zerst?rt, dass maschinelles Lernen fertig ist, sobald Sie ein gutes Modell haben. Wenn sich die Erde umgeht und die Benutzermuster sich ?ndern, bleibt kein Modell für lange Zeit relevant. Dies macht die überwachung der Modellüberwachung zu einem entscheidenden Bestandteil der F?higkeiten eines ML -Ingenieurs.

Heute haben wir einen Workflow für die grundlegende Modellüberwachung behandelt. Wir haben zun?chst über grundlegende überwachungskonzepte gesprochen. Dann tauchten wir voran in den Code ein: Wir haben die Daten in ein mit Nannyml kompatibeler Format gef?lscht. Erstellte unser erstes Diagramm für die gesch?tzte Modellleistung und erstellte ein weiteres, um es mit realisierter Leistung zu vergleichen. Erhielt ein paar Benachrichtigungen, dass die Leistung sinkt; überprüfte es mit multivariater Drifterkennung; schwere Merkmalsdrift gefunden; doppelt überprüft es mit individueller Merkmalsdrifterkennung; identifizierte die Driftfunktionen.

Leider haben wir gleich zur Aufl?sung von Problemen stehen. Dieser letzte Schritt zur überwachung des Workflows liegt au?erhalb des Rahmens dieses Artikels. Ich habe jedoch einige hervorragende Empfehlungen, die es abdecken und viel mehr über die Modellüberwachung:

• überwachung des maschinellen Lernens Konzepte Kurs
• überwachung des maschinellen Lernens im Python -Kurs

Beide Kurse werden von der besten Person erstellt, auf die Sie sich hoffen k?nnen - dem CEO und Gründer von Nannyml. In den Kursen gibt es viele Informationen von Informationen, die Sie nicht verpassen k?nnen.

Ich empfehle auch, die Nanny ML-Dokumente für einige praktische Tutorials zu lesen.

Das obige ist der detaillierte Inhalt vonEin End-to-End-ML-Modellüberwachungsworkflow mit Nannyml in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!