Abweichungen zwischen Training und Bereitstellung mit TensorFlow-Datenvalidierung analysieren

Dieses Dokument ist das dritte einer Reihe, in der erläutert wird, wie Sie Modelle für maschinelles Lernen (ML) überwachen, die in AI Platform Prediction zur Datenverzerrung bereitgestellt werden. Der Schwerpunkt dieses Leitfadens liegt auf den Konzepten und Implementierungsmethoden für die Erkennung von Abweichungen zwischen Training und Bereitstellung mithilfe von TensorFlow Data Validation (TFDV).

Dieser Leitfaden richtet sich an Data Scientists und ML-Entwickler, die überwachen möchten, wie sich Datenänderungen im Laufe der Zeit ändern und ob es Abweichungen bei der Datenverzerrung oder Anomalien gibt. Dabei wird davon ausgegangen, dass Sie mit Google Cloud, BigQuery und Jupyter-Notebooks vertraut sind.

Die Reihe besteht aus folgenden Führungslinien:

Der Code für den in diesem Dokument beschriebenen Prozess ist in Jupyter-Notebooks integriert. Die Notebooks befinden sich in einem GitHub-Repository.

Daten- und Konzeptabweichungen verstehen

Die Überwachung der Vorhersageleistung eines ML-Modells in der Produktion hat sich bei MLOps als wichtiger Bereich erwiesen. Im Folgenden sind zwei häufige Ursachen für Abbrüche bei der Vorhersageleistung eines Modells im Zeitverlauf dargestellt:

  • Eine Abweichung zwischen Trainingsdaten und Bereitstellungsdaten steigt. Dieses Problem wird als Datenabweichung bezeichnet.
  • Die Interpretation der Beziehung zwischen den Eingabe-Predictors und der Zielfunktion entwickelt sich. Dieses Problem wird als Konzeptabweichung bezeichnet.

Bei der Übertragung von Daten fließen die Produktionsdaten, die ein Modell für die Bewertung erhalten, von dem Dataset ab, mit dem das Modell trainiert, optimiert und bewertet wurde. Die Diskrepanzen zwischen Trainingsdaten und Bereitstellungsdaten können in der Regel als Schemaverzerrungen oder Verteilungsabweichungen klassifiziert werden:

  • Eine Schemaverzerrung tritt auf, wenn Trainingsdaten und Bereitstellungsdaten nicht dasselbe Schema haben. Die Schemaverzerrung wird häufig durch Fehler oder Änderungen im vorgelagerten Prozess verursacht, durch die die Bereitstellungsdaten generiert werden. Schemaabweichungen zwischen Trainings- und Bereitstellungsdaten können Folgendes umfassen:

    • Uneinheitliche Merkmale – zum Beispiel wird ein neues Feature zu den Bereitstellungsdaten hinzugefügt.
    • Inkonsistente Featuretypen: Beispielsweise ist ein numerisches Feature, das in den Trainingsdaten eine Ganzzahl war, eine echte Zahl in den Bereitstellungsdaten.
    • Inkonsistente Funktionsdomains: Beispielsweise ändert sich ein Wert in einem kategorialen Merkmal oder es gibt eine Änderung des Bereichs von numerischen Features.
  • Verteilungsabweichung tritt auf, wenn die Verteilung von Merkmalswerten für Trainingsdaten erheblich von den Bereitstellungsdaten abweicht. Diese Verzerrung kann auftreten, wenn Sie das falsche Trainings-Dataset für reale Daten auswählen. Diese Verzerrung tritt manchmal auch auf, wenn sich neue Trends und Muster aufgrund der Änderungen in der Dynamik der Umgebung ergeben. Das können beispielsweise Preise für Immobilien oder Änderungen bei der Beliebtheit von Modeartikeln sein.

Konzeptabweichung bedeutet, dass sich Ihre Interpretation der Daten geändert hat. Oftmals impliziert die Annahme, dass die Zuordnung von Eingabemerkmalen zu Labels, die während des Trainings verwendet werden, nicht mehr gültig ist oder dass eine neuartige Klasse oder eine Reihe von Labelwerten angezeigt wurde. Konzeptabweichung ist häufig das Ergebnis einer Änderung des Prozesses, den Sie modellieren möchten. Es ist auch eine Weiterentwicklung dieses Prozesses möglich.

Dieses Dokument konzentriert sich auf das Data-Drift-Szenario. Dabei geht es insbesondere darum, Schemaabweichungen und Funktionsverteilungen zwischen den Trainingsdaten und den Bereitstellungsdaten zu erkennen.

Architektur

Das folgende Diagramm zeigt die in diesem Dokument beschriebene Umgebung:

Architektur für den Ablauf, der in dieser Anleitungsreihe erstellt wird.

In dieser Architektur protokolliert das Anfrage-/Antwort-Logging von AI Platform Prediction eine Stichprobe von Onlineanfragen in einer BigQuery-Tabelle. Anschließend können Sie diese Daten parsen, beschreibende Statistiken berechnen und Datenabweichungen und -abweichungen mithilfe von Notebooks und TFDV visualisieren.

Auslieferungsdaten erfassen

Ein früheres Dokument in dieser Reihe, Logging-Anfragen mithilfe von AI Platform Prediction, zeigt, wie Sie mit AI Platform Prediction ein Keras-Modell für Onlinevorhersagen bereitstellen. Außerdem erfahren Sie, wie Sie die Anfrage-Antwort-Protokollierung aktivieren, die eine Stichprobe von Online-Vorhersageanforderungen und -antworten in einer BigQuery-Tabelle protokolliert.

Die protokollierten Anfrageinstanzen und Antwortvorhersagen werden in einem Rohformat gespeichert. Das vorhergehende Dokument dieser Reihe zeigt, wie Sie diese Rohdatenlogs parsen und eine strukturierte Ansicht zum Analysieren von Eingabemerkmalen und Ausgabevorhersagen erstellen. In diesem Dokument wird außerdem beschrieben, wie Sie mit Google Data Studio visualisieren können, wie sich einige Merkmalswerte im Laufe der Zeit ändern. Mithilfe der Visualisierung lassen sich auch Ausreißer in den Daten erkennen, die zu Vorhersageabweichungen führen können.

Abweichungen bei der Auslieferung von Daten erkennen

Es ist schwierig, mögliche Verzerrungen und Anomalien in Ihren Daten einfach anhand der Visualisierung zu identifizieren. Das ist besonders schwierig, wenn Sie viele große Eingabefeatures haben. Daher benötigen Sie einen skalierbaren und automatisierten Ansatz in der Produktion, um potenzielle Probleme proaktiv in den Bereitstellungsdaten aufzuzeigen.

In diesem Dokument wird beschrieben, wie Sie mit TFVD Datensenken erkennen, analysieren und visualisieren. TFDV analysiert die Bereitstellungsdatenlogs anhand des erwarteten Schemas und anhand der Statistiken, die aus den Trainingsdaten generiert wurden, um Anomalien zu ermitteln und Abweichungen zwischen Training und Bereitstellung zu erkennen. Wie im vorherigen Architekturdiagramm gezeigt, verwenden Sie Notebooks zur interaktiven Verwendung von TFDG-Tools.

TFDV zur Erkennung von Abweichungen zwischen Training und Bereitstellung verwenden

Das folgende Diagramm veranschaulicht den Workflow für die Verwendung von TFDV zur Erkennung und Analyse von Abweichungen in Anfrage-/Antwort-Logs von BigQuery.

Workflow zur Erkennung von Abweichungen zwischen Trainingsservern.

Der Workflow besteht aus folgenden Phasen:

  1. Baseline-Statistiken und ein Referenzschema aus den Trainingsdaten generieren Sie können dann die Baseline und das Referenzschema verwenden, um die Bereitstellungsdaten zu validieren.
  2. Serving-Datenverzerrung erkennen Dieser Prozess erzeugt die Statistik für die Bereitstellung von Daten und ermittelt etwaige Anomalien, die bei der Validierung der Bereitstellungsdaten anhand des Referenzschemas festgestellt werden.
  3. Validierungsausgabe analysieren und visualisieren Die erstellten Anomalien werden dann visualisiert und analysiert und die Statistiken werden grafisch dargestellt, um Verteilungsveränderungen darzustellen.

Ziele

  • Baseline-Statistiken und ein Referenzschema generieren
  • Erkennung von Serverabweichungen
  • Validierungsausgaben analysieren und visualisieren

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

Bevor Sie beginnen, müssen Sie Teil 1 und Teil 2 dieser Reihe absolvieren.

Nach Abschluss dieser Schritte haben Sie Folgendes:

  • Eine Notebooks-Instanz, die TensorFlow 2.3 verwendet.
  • Ein Klon des GitHub-Repositorys mit dem Jupyter-Notebook, das Sie für diese Anleitung benötigen.
  • Eine BigQuery-Tabelle mit Anfrage-Antwort-Logs und einer Ansicht, die die Rohdaten- und Antwortdaten parst.

Das Jupyter-Notebook für dieses Szenario

Für diesen Workflow wird ein End-to-End-Prozess in einem Jupyter Notebook im GitHub-Repository codiert, das mit diesem Dokument verknüpft ist. Die Schritte im Notebook basieren auf dem Dataset Covertype aus dem UCI Machine Learning Repository. Dies ist dasselbe Dataset, das in der Vergangenheit für Beispieldaten in Dokumenten dieser Reihe verwendet wurden.

Notebook-Einstellungen konfigurieren

In diesem Abschnitt bereiten Sie die Python-Umgebung vor und legen Variablen fest, die Sie zum Ausführen des Codes für das Szenario benötigen.

  1. Wenn Sie die Notebooks-Instanz noch nicht aus Teil 1 in der Cloud Console geöffnet haben, gehen Sie so vor:

    1. Rufen Sie die Seite „Notebooks“ auf.

      Zur Seite „Notebooks“

    2. Wählen Sie in der Notebook-Instanzliste das Notebook aus und klicken Sie auf Jupyterlab öffnen. Die JupyterLab-Umgebung wird im Browser geöffnet.

    3. Öffnen Sie im Dateibrowser die Datei mlops-on-gcp und rufen Sie das Verzeichnis skew-detection auf.

  2. 03-covertype-drift-detection_tfdv.ipynb Notebook öffnen.

  3. Führen Sie im Notebook unter Einrichtung die Zelle Pakete und Abhängigkeiten installieren aus, um die erforderlichen Python-Pakete zu installieren und die Umgebungsvariablen zu konfigurieren.

  4. Legen Sie unter Einstellungen der Google Cloud-Umgebung konfigurieren die folgenden Variablen fest:

    • PROJECT_ID: Die ID des Google Cloud-Projekts, in dem das BigQuery-Dataset für die Anfrage-Antwort-Daten protokolliert wird.
    • BUCKET: Der Name des Cloud Storage-Buckets, in dem generierte Artefakte gespeichert werden.
    • BQ_DATASET_NAME: Der Name des BigQuery-Datasets, in dem die Anfrage-Antwort-Logs gespeichert sind.
    • BQ_VIEW_NAME: Der Name der BigQuery-Ansicht, die Sie in Teil 2 der Reihe erstellt haben.
    • MODEL_NAME: Der Name des Modells, das für AI Platform Prediction bereitgestellt wird.
    • VERSION_NAME: Der Versionsname des Modells, das in AI Platform Prediction bereitgestellt wird. Die Version hat das Format vN; zum Beispiel v1.
  5. Führen Sie die verbleibenden Zellen unter Einrichtung aus, um die Konfiguration der Umgebung abzuschließen:

    1. GCP-Konto authentifizieren
    2. Bibliotheken importieren
    3. Lokalen Arbeitsbereich erstellen

Baseline-Statistiken und ein Referenzschema generieren

Führen Sie die Aufgaben im ersten Abschnitt des Notebooks aus, damit die Trainingsdaten Baseline-Statistiken und das Schema generieren. Laden Sie die Daten als CSV-Dateien herunter und verwenden Sie die Methode tfdv.generate_statistics_from_csv, um die Referenzstatistik zu berechnen und diese in die Variable baseline_stats einzufügen. Der Code verwendet die Methode tfdv.infer_schema, um das Referenzschema der Trainingsdaten abzuleiten und in die Variable reference_schema einzufügen.

Sie können das abgeleitete Schema, wie im folgenden Code-Snippet gezeigt, ändern:

baseline_stats = tfdv.generate_statistics_from_csv(
   data_location=TRAIN_DATA,
   stats_options=tfdv.StatsOptions(schema=reference_schema,
       sample_count=10000))

reference_schema = tfdv.infer_schema(baseline_stats)

# Set Soil_Type to be categorical
tfdv.set_domain(reference_schema, 'Soil_Type', schema_pb2.IntDomain(
   name='Soil_Type', is_categorical=True))

# Set Cover_Type to be categorical
tfdv.set_domain(reference_schema, 'Cover_Type', schema_pb2.IntDomain(
   name='Cover_Type', is_categorical=True))

# Set max and min values for Elevation
tfdv.set_domain(reference_schema,
   'Elevation',
   tfdv.utils.schema_util.schema_pb2.IntDomain(min=1000, max=5000))

# Allow no missing values
tfdv.get_feature(reference_schema,
   'Slope').presence.min_fraction = 1.0

# Set distribution skew detector for Wilderness_Area
tfdv.get_feature(reference_schema,
   'Wilderness_Area').skew_comparator.infinity_norm.threshold = 0.05

Das generierte Referenzschema wird mithilfe der Methode tfdv.display_schema angezeigt. Die Liste sieht in etwa so aus:

Liste des generierten Schemas.

Abweichungen bei der Auslieferung von Daten erkennen

Im nächsten Abschnitt des Notebooks führen Sie Aufgaben aus, um Bereitstellungsdaten zu erkennen. Der Prozess besteht aus den folgenden Schritten:

  1. Die Daten zur Anfrage-Antwort werden aus der Ansicht vw_covertype_classifier_logs_v1 in BigQuery gelesen. Die Ansicht enthält geparste Merkmalswerte und Vorhersagen, die in der Tabelle covertype_classifier_logs protokolliert sind. Die Tabelle enthält Rohinstanzanfragen und Vorhersageantworten aus dem covertype_classifier-Modell, das zuvor in AI Platform Prediction bereitgestellt wurde.
  2. Die protokollierten Daten zur Auslieferung werden in einer CSV-Datei gespeichert, damit sie von TFDV verwendet werden können.
  3. TFDV berechnet Bereitstellungsstatistiken aus der CSV-Datendatei für verschiedene Segmente der Bereitstellungsdaten mit der Methode tfdv.experimental_get_feature_value_slicer, wie im folgenden Code-Snippet dargestellt:

    slice_fn = tfdv.experimental_get_feature_value_slicer(features={'time': None})
    
    serving_stats_list = tfdv.generate_statistics_from_csv(
    data_location=serving_data_file,
    stats_options=tfdv.StatsOptions(
        slice_functions=[slice_fn],
        schema=reference_schema))
    
  4. TFDV überprüft mithilfe der Methode tfdv.validate_statistics jedes serving_stats-Segment anhand des Referenzschemas in der Variable reference_schema. Dieser Prozess generiert Anomalien, wie im folgenden Code-Snippet dargestellt:

    anomalies_list = []
    
    for slice_key in slice_keys[1:]:
      serving_stats = tfdv.get_slice_stats(serving_stats_list, slice_key)
      anomalies = tfdv.validate_statistics(
           serving_stats, schema=reference_schema,
           previous_statistics=baseline_stats)
      anomalies_list.append(anomalies)
    

TFVD prüft Anomalien und vergleicht den Protokollpuffer. Informationen zu den von TFD erkannten Anomalietypen finden Sie in der Referenz zu Anomalien der TensorFlow-Datenvalidierung. Die Schema- und Statistikfelder werden verwendet, um alle Anomalietypen und die Bedingungen zu erkennen, unter denen jeder Anomalietyp erkannt wird.

Validierungsausgaben analysieren und visualisieren

Visualisieren Sie im letzten Abschnitt des Notebooks Anomalien. Der Code verwendet die Methode tfdv.visualize_statistics, um ein serving_stats-Segment anhand der Statistikwerte der Trainingsdaten zu visualisieren, um die Verteilungsverzerrungen hervorzuheben.

Der folgende Screenshot zeigt ein Beispiel für eine Visualisierung für Verteilungen für die numerischen Features Elevation und Aspect.

Grafiken mit Anomalien in Bezug auf Höhe und Seitenverhältnis

Die folgenden Screenshots zeigen Beispiele von Visualisierungen für die kategorialen Features Wildness_Area und Cover_Type. In der kategorialen Merkmalsvisualisierung ist Cover_Type das Zielmerkmal und die Verteilung zeigt eine Vorhersageverzerrung an.

Visualisierung des Darstellungsbereichs

Darstellung des Covertyps

Zum Prüfen der generierten Anomalien in jedem serving_stats-Segment rufen Sie die Methode tfdv.display_anomalies auf. Die folgende Auflistung zeigt ein Beispiel für die erkannten Anomalien.

Liste der Anomalien, die von der Methode "display_anomalies" gefunden wurden.

Zusätzlich zum Erstellen von Visualisierungen mithilfe der TFDV-Visualisierungs-API können Sie eine Python-Plot-Bibliothek verwenden, um die Statistiken in Ihrem Notebook zu visualisieren.

In den folgenden Abbildungen wird gezeigt, wie die Mittelwerte des numerischen Features in der Bereitstellungsstatistik über Zeitabschnitte hinweg differenzieren und wie sich die Werte mit den Mittelwerten in der Referenzstatistik vergleichen:

Grafik der Mittelwertwerte für die Höhe

Grafik der Mittelwertwerte für Seitenverhältnis.

Grafik der Mittelwertwerte für Steigung.

Das folgende Diagramm zeigt, wie sich die Wertverteilung der kategorialen Funktion in der Bereitstellungsstatistik über Zeitabschnitte erstreckt:

Balkendiagramme, die die Wertverteilung von Funktionen im Zeitverlauf zeigen

Bereinigen

Wenn Sie den Rest dieser Reihe fortsetzen möchten, behalten Sie die bereits vorhandenen Ressourcen bei. Löschen Sie andernfalls das Projekt, das die Ressourcen enthält, oder behalten Sie das Projekt und löschen Sie die einzelnen Ressourcen.

Projekt löschen

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte