AI Platform Prediction-Logs in BigQuery analysieren

Dieses Dokument ist der zweite Teil einer Reihe, die Ihnen zeigt, wie Sie Modelle für maschinelles Lernen (ML) überwachen, die in AI Platform Prediction bereitgestellt werden, um Ihnen bei der Erkennung von Datenabweichungen zu helfen. In diesem Leitfaden erfahren Sie, wie Sie Rohdaten im Anfrage-Antwort-Log von AI Platform Prediction in ein analytisches Datenmodell parsen. Anschließend wird gezeigt, wie Sie mit Data Studio die erfassten Anfragen auf Datenverzerrung und -abweichungen analysieren können.

Die Reihe richtet sich an Data Scientists und MLOps-Entwickler, die die Leistung ihrer ML-Modelle in der Produktion beibehalten möchten, indem sie beobachten, wie sich die Bereitstellungsdaten im Laufe der Zeit ändern. Dabei wird davon ausgegangen, dass Sie mit Google Cloud, BigQuery und Jupyter-Notebooks vertraut sind.

Die Reihe besteht aus folgenden Führungslinien:

Die in diesem Dokument beschriebenen Aufgaben sind in Jupyter-Notebooks integriert. Die Notebooks befinden sich in einem GitHub-Repository.

Übersicht

Wie in Teil 1 dieser Reihe erläutert, trainiert der Code im Jupyter-Notebook ein Keras-Klassifizierungsmodell für das Covertype-Dataset zur Vorhersage des Waldabdeckungstyps aus kartografischen Variablen. Das exportierte SavedModel wird dann für die Onlinebereitstellung in AI Platform Prediction bereitgestellt. Das Notebook ermöglicht auch Folgendes:Anfrage-/Antwort-Logging protokolliert ein Beispiel für Online-Vorhersageanfragen (Instanzen) und Antworten (Vorhersagen für vorhergesagte Label) an eineBigQuery-Tabelle.

Die Gesamtarchitektur wird im folgenden Diagramm dargestellt:

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. Nachdem die Rohinstanzen und Vorhersagedaten in BigQuery gespeichert wurden, können Sie diese Daten parsen, beschreibende Statistiken erstellen und Datenverzerrung und -abweichung visualisieren.

In der folgenden Tabelle wird das Schema der BigQuery-Tabelle zusammengefasst.

Feldname Typ Mode Beschreibung
model STRING REQUIRED Der Name eines Modells
model_version STRING REQUIRED Der Name einer Modellversion
time TIMESTAMP REQUIRED Datum und Uhrzeit der Erfassung einer Anfrage
raw_data STRING REQUIRED Der Anfragetext in der JSON-Darstellung in AI Platform Prediction
raw_prediction STRING NULLABLE Der Antworttext (Vorhersagen) in der JSON-Darstellung in AI Platform Prediction
groundtruth STRING NULLABLE Ground Truth (falls verfügbar)

Die folgende Tabelle enthält ein Beispiel für die Daten, die in den Spalten raw_data und raw_prediction der BigQuery-Tabelle gespeichert sind.

Spalte Beispieldaten
raw_data

{
  "signature_name":"serving_default",
  "instances":[
    {
      "Elevation":[3158],
      "Aspect":[78],
      "Slope":[25],
      "Horizontal_Distance_To_Hydrology":[150],
      "Vertical_Distance_To_Hydrology":[53],
      "Horizontal_Distance_To_Roadways":[1080],
      "Hillshade_9am":[243],
      "Hillshade_Noon":[185],
      "Hillshade_3pm":[57],
      "Horizontal_Distance_To_Fire_Points":[2234],
      "Wilderness_Area":["Rawah"],
      "Soil_Type":["7745"],
    }
  ]
}
raw_prediction

{
 "predictions": [
   {
     "probabilities": [
       0.03593460097908974,
       0.9640452861785889,
       1.2815438710234162e-9,
       1.5712469103590365e-9,
       0.000018715836631599814,
       4.030006106603423e-9,
       0.0000013792159734293818
     ],
     "confidence":  0.9640452861785889,
     "predicted_label": "1"

   }
 ]
}

In diesem Dokument parst das Feld raw_data ein analytisches Modell, sodass Sie den Inhalt jedes Features separat analysieren und eventuelle Datenblöcke identifizieren können.

Ziele

  • Erstellen Sie Metadaten für das Dataset.
  • Generieren Sie eine SQL-CREATE VIEW-Anweisung, die für das Dataset spezifisch ist.
  • Mit der Ansicht Logdaten in BigQuery abfragen.
  • Visualisierungen der Logdaten erstellen

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 dieser Reihe abschließen.

Nach Abschluss von Teil 1 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.

Das Jupyter-Notebook für dieses Szenario

Die Aufgaben zum Parsen und Analysieren der Daten sind in einem Jupyter-Notebook enthalten, das sich in einem GitHub-Repository befindet. Zum Ausführen der Aufgaben rufen Sie das Notebook ab und führen dann die Codezellen im Notebook in der angegebenen Reihenfolge aus.

In diesem Dokument verwenden Sie das Jupyter-Notebook, um die folgenden Aufgaben auszuführen:

  • Erstellen Sie eine BigQuery-SQL-Ansicht, um die Rohdaten der Anfrage- und Antwortdaten zu parsen. Zum Generieren der Ansicht führen Sie Code aus, der Informationen wie Metadaten für das Dataset und die von Ihnen bereitgestellten Namen zusammenfasst.
  • Simulieren Sie das Verfahren zur Bereitstellung von Daten über mehrere Tage mit künstlichen Skizzen.
  • Verwenden Sie Data Studio, um die geparsten Bereitstellungsdaten so darzustellen, wie in BigQuery protokolliert.

Notebook-Einstellungen konfigurieren

In diesem Abschnitt des Notebooks bereiten Sie die Python-Umgebung für die Ausführung des Codes für das Szenario vor. Der Code im Notebook erstellt die Ansicht auf Basis der Featurespezifikation des Datasets. Zum Generieren des SQL-Skripts CREATE OR REPLACE VIEW müssen Sie eine Reihe von Variablen festlegen.

  1. Wenn Sie die AI Platforms Notebooks-Instanz noch nicht von Teil 1 in der Cloud Console geöffnet haben, führen Sie folgende Schritte aus:

    1. Zur Seite „Notebooks“.

      Zur Seite „Notebooks“

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

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

  2. 02-covertype-logs-parsing-analysis.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.
    • BQ_DATASET_NAME: Der Name des BigQuery-Datasets, in dem die Anfrage-Antwort-Logs gespeichert werden.
    • BQ_TABLE_NAME: Der Name der BigQuery-Tabelle zum Speichern der Anfrage-Antwort-Logs.
    • MODEL_NAME: Der Name des Modells, das in 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

Metadaten für das Dataset definieren

In Abschnitt 1 des Notebook Dataset-Metadaten definieren werden Variablen festgelegt, die später in Code verwendet werden, mit dem ein SQL-Skript generiert wird. Mit dem Code in diesem Abschnitt werden beispielsweise zwei Variablen mit den Namen NUMERIC_FEATURE_NAMES und CATEGORICAL_FEATURES_WITH_VOCABULARY erstellt, wie im folgenden Snippet des Codes gezeigt:

NUMERIC_FEATURE_NAMES = ['Aspect', 'Elevation', 'Hillshade_3pm',
                         'Hillshade_9am', 'Hillshade_Noon',
                         'Horizontal_Distance_To_Fire_Points',
                         'Horizontal_Distance_To_Hydrology',
                         'Horizontal_Distance_To_Roadways','Slope',
                         'Vertical_Distance_To_Hydrology']

CATEGORICAL_FEATURES_WITH_VOCABULARY = {
    'Soil_Type': ['2702', '2703', '2704', '2705', '2706', '2717', '3501', '3502',
                  '4201', '4703', '4704', '4744', '4758', '5101', '6101', '6102',
                  '6731', '7101', '7102', '7103', '7201', '7202', '7700', '7701',
                  '7702', '7709', '7710', '7745', '7746', '7755', '7756', '7757',
                  '7790', '8703', '8707', '8708', '8771', '8772', '8776'],
    'Wilderness_Area': ['Cache', 'Commanche', 'Neota', 'Rawah']
}

Anschließend erstellt der Code eine Variable mit dem Namen FEATURE_NAMES, um diese Werte wie in der folgenden Zeile zu kombinieren:

FEATURE_NAMES = list(CATEGORICAL_FEATURES_WITH_VOCABULARY.keys()) + NUMERIC_FEATURE_NAMES

CREATE VIEW-SQL-Skript generieren

Führen Sie die Aufgaben in Abschnitt 2 des Notebooks aus, um die CREATE VIEW-Anweisung zu generieren, die Sie später zum Parsen der Logs ausführen.

Die erste Aufgabe führt Code aus, um aus den Datenmetadaten für die Variablen json_features_extraction und json_prediction_extraction Werte zu erstellen. Diese Variablen enthalten die Features und Vorhersagewerte in einem Format, das in eine SQL-Anweisung eingefügt werden kann.

Dieser Code basiert auf den Variablen, die Sie zuvor bei der Konfiguration der Notebook-Einstellungen und beim Definieren der Metadaten für das Dataset festgelegt haben. Das folgende Snippet zeigt diesen Code.

LABEL_KEY = 'predicted_label'
SCORE_KEY = 'confidence'
SIGNATURE_NAME = 'serving_default'

def _extract_json(column, feature_name):
  return "JSON_EXTRACT({}, '$.{}')".format(column, feature_name)

def _replace_brackets(field):
  return "REPLACE(REPLACE({}, ']', ''), '[','')".format(field)

def _replace_quotes(field):
  return 'REPLACE({}, "\\"","")'.format(field)

def _cast_to_numeric(field):
  return "CAST({} AS NUMERIC)".format(field)

def _add_alias(field, feature_name):
  return "{} AS {}".format(field, feature_name)

view_name = "vw_"+BQ_TABLE_NAME+"_"+VERSION_NAME

colum_names = FEATURE_NAMES
input_features = ', \r\n  '.join(colum_names)

json_features_extraction = []
for feature_name in colum_names:
  field = _extract_json('instance', feature_name)
  field = _replace_brackets(field)
  if feature_name in NUMERIC_FEATURE_NAMES:
    field = _cast_to_numeric(field)
  else:
    field = _replace_quotes(field)
  field = _add_alias(field, feature_name)
  json_features_extraction.append(field)

json_features_extraction = ', \r\n    '.join(json_features_extraction)

json_prediction_extraction = []
for feature_name in [LABEL_KEY, SCORE_KEY]:
  field = _extract_json('prediction', feature_name)
  field = _replace_brackets(field)
  if feature_name == SCORE_KEY:
    field = _cast_to_numeric(field)
  else:
    field = _replace_quotes(field)
  field = _add_alias(field, feature_name)
  json_prediction_extraction.append(field)

json_prediction_extraction = ', \r\n    '.join(json_prediction_extraction)

In der zweiten Aufgabe wird eine Variable namens sql_script auf einen langen String festgelegt, der eine CREATE OR REPLACE VIEW-Anweisung enthält. Die Anweisung enthält mehrere Platzhalter, die im String mit @ als Präfix gekennzeichnet sind. Es gibt z. B. Platzhalter für die Namen des Datasets und der Ansicht:

CREATE OR REPLACE VIEW @dataset_name.@view_name

Es gibt auch Platzhalter für die Namen des Projekts, der Tabelle, des Modells und der Version:

FROM
  `@project.@dataset_name.@table_name`
  WHERE
    model = '@model_name' AND
    model_version = '@version'
)

Am Ende der Anweisung finden Sie Platzhalter, die die Variablen json_features_extraction und json_prediction_extraction verwenden, die Sie durch Ausführen des Codes in der vorherigen Aufgabe erstellt haben:

step3 AS
(SELECT
    model,
    model_version,
    time,
    @json_features_extraction,
    @json_prediction_extraction
FROM step2
)

Abschließend führen Sie die nächste Zelle aus, um die Platzhalter in der SQL-Anweisung durch Werte zu ersetzen, die Sie zuvor festgelegt haben, wie im folgenden Snippet gezeigt:

sql_script = sql_script.replace("@project", PROJECT_ID)
sql_script = sql_script.replace("@dataset_name", BQ_DATASET_NAME)
sql_script = sql_script.replace("@table_name", BQ_TABLE_NAME)
sql_script = sql_script.replace("@view_name", view_name)
sql_script = sql_script.replace("@model_name", MODEL_NAME)
sql_script = sql_script.replace("@version", VERSION_NAME)
sql_script = sql_script.replace("@input_features", input_features)
sql_script = sql_script.replace("@json_features_extraction", json_features_extraction)
sql_script = sql_script.replace("@json_prediction_extraction", json_prediction_extraction)

In diesem Schritt wird die Generierung der SQL-Anweisung abgeschlossen, die die Ansicht erstellt, um die Rohdaten der Anfrage und der Antwort zu parsen.

Wenn Sie das generierte Skript sehen möchten, führen Sie die Zelle aus, die die Ansicht ausgibt. Die Zelle enthält folgenden Code:

print(sql_script)

CREATE VIEW-SQL-Skript ausführen

Zum Ausführen der CREATE VIEW-Anweisung führen Sie den Code in Abschnitt 3 des Notebooks aus. Wenn Sie fertig sind, zeigt der Code die Nachricht View created or replaced an. Wenn Sie diese Meldung sehen, ist die Ansicht zum Parsen der Daten bereit.

Das folgende Snippet zeigt die resultierende Anweisung.

CREATE OR REPLACE VIEW prediction_logs.vw_covertype_classifier_logs_v1
AS

WITH step1 AS
(
  SELECT
    model,
    model_version,
    time,
    SPLIT(JSON_EXTRACT(raw_data, '$.instances'), '}],[{') instance_list,
    SPLIT(JSON_EXTRACT(raw_prediction, '$.predictions'), '}],[{') as prediction_list
  FROM
  `sa-data-validation.prediction_logs.covertype_classifier_logs`
  WHERE
    model = 'covertype_classifier' AND
    model_version = 'v1'
),

step2 AS
(
  SELECT
    model,
    model_version,
    time,
    REPLACE(REPLACE(instance, '[{', '{'),'}]', '}') AS instance,
    REPLACE(REPLACE(prediction, '[{', '{'),'}]', '}') AS prediction,
  FROM step1
  JOIN UNNEST(step1.instance_list) AS instance
  WITH OFFSET AS f1
  JOIN UNNEST(step1.prediction_list) AS prediction
  WITH OFFSET AS f2
  ON f1=f2
),

step3 AS
(
  SELECT
    model,
    model_version,
    time,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Soil_Type'), ']', ''), '[',''), "\"","") AS Soil_Type,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Wilderness_Area'), ']', ''), '[',''), "\"","") AS Wilderness_Area,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Aspect'), ']', ''), '[','') AS NUMERIC) AS Aspect,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Elevation'), ']', ''), '[','') AS NUMERIC) AS Elevation,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_3pm'), ']', ''), '[','') AS NUMERIC) AS Hillshade_3pm,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_9am'), ']', ''), '[','') AS NUMERIC) AS Hillshade_9am,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_Noon'), ']', ''), '[','') AS NUMERIC) AS Hillshade_Noon,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Fire_Points'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Fire_Points,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Hydrology'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Hydrology,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Roadways'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Roadways,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Slope'), ']', ''), '[','') AS NUMERIC) AS Slope,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Vertical_Distance_To_Hydrology'), ']', ''), '[','') AS NUMERIC) AS Vertical_Distance_To_Hydrology,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(prediction, '$.predicted_label'), ']', ''), '[',''), "\"","") AS predicted_label,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(prediction, '$.confidence'), ']', ''), '[','') AS NUMERIC) AS confidence
  FROM step2
)

SELECT*
FROM step3

Ansicht abfragen

Nachdem die Ansicht erstellt wurde, können Sie sie abfragen. Führen Sie zum Abfragen der Ansicht den Code in Abschnitt 4, Abfrage der Ansicht aus. Der Code verwendet die Methode pandas.io.gbq.read_gbq im Notebook, wie im folgenden Code-Snippet gezeigt:

query = '''
 SELECT * FROM
 `{}.{}`
 LIMIT {}
'''.format(BQ_DATASET_NAME, view_name, 3)

pd.io.gbq.read_gbq(
   query, project_id=PROJECT_ID).T

Der Code erzeugt eine Ausgabe, die in etwa so aussieht:

Ausgabe durch Abfragen der Ansicht.

Das Abfrageergebnis wird angezeigt:

  • Jedes Element hat einen eigenen Eintrag.
  • Die Anführungszeichen werden aus den kategorialen Features entfernt.
  • Das vorhergesagte Klassenlabel wird im Eintrag predicted_label angezeigt.
  • Die Wahrscheinlichkeit für das vorhergesagte Klassenlabel wird im Eintrag confidence angezeigt.

BigQuery-Konsole verwenden

Statt die Ansicht mit der pandas API abzufragen, können Sie die Ansicht in der BigQuery-Konsole abfragen.

  1. Öffnen Sie die BigQuery Console:

    Zur BigQuery-Konsole

  2. Geben Sie im Abfrageeditor eine Abfrage wie die folgende ein:

    Select*
    FROM PROJECT_ID.prediction_logs.vw_covertype_classifier_logs_v1
    Limit 10
    

    Ersetzen Sie PROJECT_ID durch die ID des zuvor festgelegten Cloud-Projekts.

    Die Ausgabe sieht etwa so aus:

    Abfrageeditor mit SQL-Anweisung und -Ausgabe

(Optional) Auslieferungsdaten simulieren

Wenn Sie mit Ihrem eigenen Modell und Ihren Daten arbeiten, überspringen Sie diesen Abschnitt und gehen Sie zum nächsten Abschnitt. Dort wird beschrieben, wie die Anfrage-Antwort-Log-Tabelle mit Beispieldaten gefüllt wird.

Sie können Beispieldaten verwenden, um verzerrte Datenpunkte zu generieren und anschließend Vorhersageanfragen an die Modellversion zu simulieren, die in AI Platform Prediction bereitgestellt wird. Das Modell erstellt Vorhersagen für die Anfrageinstanzen. Sowohl Instanzen als auch Vorhersagen werden in BigQuery gespeichert.

Sie können Beispiel-Normaldaten (normal und verzerrt) für Vorhersageanfragen generieren und dann das Klassifizierungsmodell covertype für die AI Platform Prediction mithilfe der generierten Datenpunkte aufrufen. Das geklonte Repository enthält ein Notebook, das Code für diese Aufgabe enthält. Alternativ können Sie eine CSV-Datei laden, die Protokolldaten mit Abweichungen enthält.

So generieren Sie die Beispieldaten aus dem Notebook:

  1. Öffnen Sie im Notebook den Dateibrowser, öffnen Sie mlops-on-gcp und rufen Sie das Verzeichnis skew-detection/workload_simulator auf.
  2. covertype-data-generation.ipynb Notebook öffnen.
  3. Legen Sie unter Einrichtung Werte für Ihre Projekt-ID, Ihren Bucket-Namen und Ihre Region fest.
  4. Führen Sie alle Zellen im Notebook in der angegebenen Reihenfolge aus.

Sie können sowohl die Größe der zu erzeugenden Daten als auch die Verzerrung der Daten ändern. Die Standardverzerrungen werden in den Daten eingeführt:

  • Numerische Merkmalverzerrung. Für das Elevation-Feature konvertiert der Code die Maßeinheit in Metern von 10 % der Daten.
  • Numerische Verzerrung der Funktionsverteilung: Bei der Funktion Aspect reduziert der Code den Wert um 25 %.
  • Kategoriale Merkmalsverzerrung. Bei der Funktion Wilderness_Area konvertiert der Code den Wert eines zufälligen 1 % der Daten in eine neue Kategorie mit dem Namen Others.
  • Kategoriale Funktionsverteilung: Bei der Funktion Wilderness_Area erhöht der Code die Häufigkeit der Werte Neota und Cache. Dazu werden vom Code 25 % der Datenpunkte aus den ursprünglichen Werten in die Werte Neota und Cache konvertiert.

Alternativ können Sie die Datendatei workload_simulator/bq_prediction_logs.csv in die BigQuery-Anfrage-Antwort-Log-Tabelle laden. Die CSV-Datei enthält Beispiele für Anfrage-Antwort-Logs mit 2.000 normalen Datenpunkten und 1.000 verzerrten Datenpunkten. Weitere Informationen finden Sie unter Daten aus lokalen Daten in BigQuery laden.

Protokollierte Bereitstellungsdaten visualisieren

Sie können ein Visualisierungstool verwenden, um eine Verbindung zur BigQuery-Ansicht herzustellen und die protokollierten Bereitstellungsdaten zu visualisieren. In den folgenden Beispielen wurden die Daten mit Data Studio erstellt.

Der folgende Screenshot zeigt ein Beispiel-Dashboard, das erstellt wurde, um die Anfrage-Antwort-Logs für Vorhersagen aus dieser Anleitung zu visualisieren.

Visualisierung von Anfrage-Antwort-Logs.

Das Dashboard enthält folgende Informationen:

  • Die Anzahl der vom Vorhersagedienst empfangenen Instanzen ist vom 1. Juni bis zum 6. Juni an jedem Tag gleich (500).
  • Bei den Klassenverteilungen ist die Häufigkeit des vorhergesagten Klassenlabels 3 in den letzten zwei Tagen gestiegen (5. Juni und 6. Juni).
  • Für die Wilderness Area-Werteverteilung wurden die Werte Neota und Cache in den letzten zwei Tagen erhöht.
  • Für eine aussagekräftige Statistik der Funktion Elevation haben die Mindestwerte der letzten zwei Tage deutlich niedrigere Werte als die vorhergehenden vier Tage. Die Standardabweichungswerte haben deutlich höhere Werte als in den vorherigen vier Tagen.

Wie im folgenden Screenshot dargestellt, verzeichnet die Werteverteilung der Funktion Aspect in den letzten zwei Tagen einen deutlichen Rückgang der Werte zwischen 300 und 350.

Liniendiagramm der Verzerrungslinie.

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