1. Übersicht
In diesem Lab verwenden Sie das What-if Tool, um ein XGBoost-Modell zu analysieren, das mit Finanzdaten trainiert wurde. Nach der Analyse des Modells stellen Sie es in der neuen Vertex AI von Google Cloud bereit.
Lerninhalte
Die folgenden Themen werden behandelt:
- XGBoost-Modell mit einem öffentlichen Hypothekendataset in einem gehosteten Notebook trainieren
- Modell mit dem What-If-Tool analysieren
- XGBoost-Modell in Vertex AI bereitstellen
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 1$.
2. Einführung in Vertex AI
In diesem Lab wird das neueste KI-Produkt von Google Cloud verwendet. Vertex AI vereint die ML-Angebote von Google Cloud in einer nahtlosen Entwicklungsumgebung. Bisher musste auf mit AutoML trainierte und benutzerdefinierte Modelle über verschiedene Dienste zugegriffen werden. Das neue Angebot kombiniert diese und weitere, neue Produkte zu einer einzigen API. Sie können auch vorhandene Projekte zu Vertex AI migrieren. Wenn Sie Feedback haben, lesen Sie bitte die Supportseite.
Vertex AI umfasst viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab konzentrieren wir uns auf die unten hervorgehobenen Produkte: Prediction und Notebooks.
3. Kurze Einführung in XGBoost
XGBoost ist ein Framework für maschinelles Lernen, das Entscheidungsbäume und Gradient Boosting verwendet, um Vorhersagemodelle zu erstellen. Dabei werden mehrere Entscheidungsbäume auf Grundlage des Scores, der mit verschiedenen Blattknoten in einem Baum verknüpft ist, zusammengefasst.
Das Diagramm unten ist eine Visualisierung eines einfachen Entscheidungsbaummodells, das anhand der Wettervorhersage bewertet, ob ein Sportspiel stattfinden soll:
Warum verwenden wir XGBoost für dieses Modell? Während herkömmliche neuronale Netze bei unstrukturierten Daten wie Bildern und Texten am besten abschneiden, sind Entscheidungsbäume oft sehr gut für strukturierte Daten wie das Hypothekendataset geeignet, das wir in diesem Codelab verwenden.
4. Richten Sie Ihre Umgebung ein.
Für dieses Codelab benötigen Sie ein Google Cloud Platform-Projekt mit aktivierter Abrechnung. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Compute Engine API aktivieren
Rufen Sie Compute Engine auf und wählen Sie Aktivieren aus, falls die API noch nicht aktiviert ist. Sie benötigen diese, um Ihre Notebook-Instanz zu erstellen.
Schritt 2: Vertex AI API aktivieren
Rufen Sie den Vertex-Bereich Ihrer Cloud Console auf und klicken Sie auf Vertex AI API aktivieren.
Schritt 3: Notebooks-Instanz erstellen
Klicken Sie in der Cloud Console im Vertex-Abschnitt auf „Notebooks“:
Wählen Sie dort Neue Instanz aus. Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.3 ohne GPUs aus:
Übernehmen Sie die Standardoptionen und klicken Sie auf Erstellen. Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen.
Schritt 4: XGBoost installieren
Nachdem Ihre JupyterLab-Instanz geöffnet wurde, müssen Sie das XGBoost-Paket hinzufügen.
Wählen Sie dazu im Launcher „Terminal“ aus:
Führen Sie dann den folgenden Befehl aus, um die neueste von Vertex AI unterstützte Version von XGBoost zu installieren:
pip3 install xgboost==1.2
Öffnen Sie nach Abschluss des Vorgangs über den Launcher eine Python 3-Notebook-Instanz. Sie können jetzt mit Ihrem Notebook loslegen.
Schritt 5: Python-Pakete importieren
Fügen Sie in der ersten Zelle Ihres Notebooks die folgenden Importe hinzu und führen Sie die Zelle aus. Sie können es ausführen, indem Sie im oberen Menü auf die Rechtspfeiltaste oder auf die Tastenkombination „Befehl + Eingabetaste“ drücken:
import pandas as pd
import xgboost as xgb
import numpy as np
import collections
import witwidget
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.utils import shuffle
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
5. Daten herunterladen und verarbeiten
Wir verwenden ein Hypothekendataset von ffiec.gov, um ein XGBoost-Modell zu trainieren. Wir haben das Original-Dataset vorverarbeitet und eine kleinere Version erstellt, die Sie zum Trainieren des Modells verwenden können. Das Modell sagt voraus, ob ein bestimmter Hypothekenantrag genehmigt wird.
Schritt 1: Vorverarbeiteten Datensatz herunterladen
Wir haben eine Version des Datasets in Google Cloud Storage für Sie bereitgestellt. Sie können es herunterladen, indem Sie den folgenden gsutil-Befehl in Ihrem Jupyter-Notebook ausführen:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
Schritt 2: Dataset mit Pandas lesen
Bevor wir unseren Pandas DataFrame erstellen, erstellen wir ein dict für den Datentyp jeder Spalte, damit Pandas unser Dataset richtig liest:
COLUMN_NAMES = collections.OrderedDict({
'as_of_year': np.int16,
'agency_code': 'category',
'loan_type': 'category',
'property_type': 'category',
'loan_purpose': 'category',
'occupancy': np.int8,
'loan_amt_thousands': np.float64,
'preapproval': 'category',
'county_code': np.float64,
'applicant_income_thousands': np.float64,
'purchaser_type': 'category',
'hoepa_status': 'category',
'lien_status': 'category',
'population': np.float64,
'ffiec_median_fam_income': np.float64,
'tract_to_msa_income_pct': np.float64,
'num_owner_occupied_units': np.float64,
'num_1_to_4_family_units': np.float64,
'approved': np.int8
})
Als Nächstes erstellen wir einen DataFrame und übergeben ihm die oben angegebenen Datentypen. Es ist wichtig, die Daten zu mischen, falls das ursprüngliche Dataset in einer bestimmten Reihenfolge sortiert ist. Dazu verwenden wir das sklearn-Tool shuffle, das wir in der ersten Zelle importiert haben:
data = pd.read_csv(
'mortgage-small.csv',
index_col=False,
dtype=COLUMN_NAMES
)
data = data.dropna()
data = shuffle(data, random_state=2)
data.head()
Mit data.head() können wir uns in Pandas eine Vorschau der ersten fünf Zeilen unseres Datasets ansehen. Nach dem Ausführen der Zelle oben sollte etwa Folgendes angezeigt werden:
Das sind die Funktionen, die wir zum Trainieren unseres Modells verwenden. Wenn Sie ganz nach unten scrollen, sehen Sie die letzte Spalte approved. Das ist das, was wir vorhersagen. Der Wert 1 gibt an, dass eine bestimmte Anwendung genehmigt wurde, und 0, dass sie abgelehnt wurde.
Wenn Sie die Verteilung der genehmigten / abgelehnten Werte im Dataset sehen und ein NumPy-Array der Labels erstellen möchten, führen Sie Folgendes aus:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
Etwa 66% des Datasets enthalten genehmigte Anträge.
Schritt 3: Dummy-Spalte für kategorische Werte erstellen
Dieser Datensatz enthält eine Mischung aus kategorischen und numerischen Werten. Für XGBoost müssen jedoch alle Features numerisch sein. Anstatt kategoriale Werte mit One-Hot-Codierung darzustellen, verwenden wir für unser XGBoost-Modell die Pandas-Funktion get_dummies.
Mit get_dummies wird eine Spalte mit mehreren möglichen Werten in eine Reihe von Spalten umgewandelt, die jeweils nur 0 und 1 enthalten. Wenn wir beispielsweise eine Spalte „color“ mit den möglichen Werten „blue“ und „red“ haben, würde get_dummies diese in zwei Spalten namens „color_blue“ und „color_red“ mit allen booleschen 0- und 1-Werten umwandeln.
Führen Sie den folgenden Code aus, um Dummy-Spalten für die kategorialen Features zu erstellen:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
Wenn Sie sich die Daten dieses Mal in der Vorschau ansehen, werden einzelne Features (wie purchaser_type unten) in mehrere Spalten aufgeteilt:
Schritt 4: Daten in Trainings- und Test-Datasets aufteilen
Ein wichtiges Konzept beim maschinellen Lernen ist die Aufteilung in Trainings- und Testsätze. Wir verwenden den Großteil unserer Daten, um unser Modell zu trainieren, und behalten den Rest zurück, um unser Modell mit Daten zu testen, die es noch nie zuvor gesehen hat.
Fügen Sie Ihrem Notebook den folgenden Code hinzu, mit dem die Scikit-learn-Funktion train_test_split verwendet wird, um die Daten aufzuteilen:
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Jetzt können Sie Ihr Modell erstellen und trainieren.
6. XGBoost-Modell erstellen, trainieren und bewerten
Schritt 1: XGBoost-Modell definieren und trainieren
Das Erstellen eines Modells in XGBoost ist einfach. Wir verwenden die Klasse XGBClassifier, um das Modell zu erstellen. Dazu müssen wir nur den richtigen objective-Parameter für unsere spezifische Klassifizierungsaufgabe übergeben. In diesem Fall verwenden wir reg:logistic, da es sich um ein binäres Klassifizierungsproblem handelt und das Modell einen einzelnen Wert im Bereich (0,1) ausgeben soll: 0 für „nicht genehmigt“ und 1 für „genehmigt“.
Mit dem folgenden Code wird ein XGBoost-Modell erstellt:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
Sie können das Modell mit einer Zeile Code trainieren, indem Sie die Methode fit() aufrufen und ihr die Trainingsdaten und Labels übergeben.
model.fit(x_train, y_train)
Schritt 2: Genauigkeit des Modells bewerten
Jetzt können wir unser trainiertes Modell verwenden, um mit der Funktion predict() Vorhersagen für unsere Testdaten zu generieren.
Anschließend verwenden wir die accuracy_score()-Funktion von Scikit-learn, um die Genauigkeit unseres Modells basierend auf seiner Leistung bei unseren Testdaten zu berechnen. Wir übergeben die Ground Truth-Werte zusammen mit den vorhergesagten Werten des Modells für jedes Beispiel in unserem Testsatz:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
Die Genauigkeit sollte bei etwa 87% liegen. Da maschinelles Lernen immer auch ein Zufallselement enthält, kann die Genauigkeit bei Ihnen leicht abweichen.
Schritt 3: Modell speichern
Führen Sie den folgenden Code aus, um das Modell bereitzustellen und in einer lokalen Datei zu speichern:
model.save_model('model.bst')
7. What-If-Tool zum Interpretieren des Modells verwenden
Schritt 1: What-If Tool-Visualisierung erstellen
Wenn Sie das What-If Tool mit Ihrem lokalen Modell verbinden möchten, müssen Sie ihm eine Teilmenge Ihrer Testbeispiele zusammen mit den Ground Truth-Werten für diese Beispiele übergeben. Erstellen wir ein NumPy-Array mit 500 unserer Testbeispiele und den zugehörigen Ground-Truth-Labels:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
Das What-If Tool wird instanziiert, indem ein WitConfigBuilder-Objekt erstellt und das zu analysierende Modell übergeben wird.
Da das What-If-Tool eine Liste mit Ergebnissen für jede Klasse in unserem Modell (in diesem Fall 2) erwartet, verwenden wir die predict_proba-Methode von XGBoost mit dem What-If-Tool:
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_custom_predict_fn(model.predict_proba)
.set_target_feature('mortgage_status')
.set_label_vocab(['denied', 'approved']))
WitWidget(config_builder, height=800)
Das Laden der Visualisierung dauert eine Minute. Wenn die Seite geladen ist, sollten Sie Folgendes sehen:
Auf der y-Achse sehen wir die Vorhersage des Modells. 1 steht für eine approved-Vorhersage mit hoher Konfidenz und 0 für eine denied-Vorhersage mit hoher Konfidenz. Die x-Achse stellt nur die Verteilung aller geladenen Datenpunkte dar.
Schritt 2: Einzelne Datenpunkte ansehen
Die Standardansicht im What-If-Tool ist der Tab Datapoint editor (Editor für Datenpunkte). Hier können Sie auf einen beliebigen einzelnen Datenpunkt klicken, um seine Merkmale zu sehen, Merkmalswerte zu ändern und zu sehen, wie sich diese Änderung auf die Vorhersage des Modells für einen einzelnen Datenpunkt auswirkt.
Im folgenden Beispiel haben wir einen Datenpunkt ausgewählt, der nahe am Grenzwert von 0,5 liegt. Der mit diesem bestimmten Datenpunkt verknüpfte Hypothekenantrag stammt vom CFPB. Wir haben diesen Wert auf 0 geändert und auch den Wert von agency_code_Department of Housing and Urban Development (HUD) auf 1 geändert, um zu sehen, wie sich das auf die Vorhersage des Modells auswirken würde, wenn dieses Darlehen stattdessen von HUD stammen würde:
Wie im unteren linken Bereich des What-If-Tools zu sehen ist, hat sich die approved-Vorhersage des Modells durch die Änderung dieses Features um 32 % verringert. Das könnte darauf hindeuten, dass die Agentur, von der ein Darlehen stammt, einen starken Einfluss auf die Modellausgabe hat. Wir müssen jedoch weitere Analysen durchführen, um sicher zu sein.
Unten links in der Benutzeroberfläche sehen wir auch den Ground Truth-Wert für jeden Datenpunkt und können ihn mit der Vorhersage des Modells vergleichen:
Schritt 3: Kontrafaktische Analyse
Klicken Sie dann auf einen beliebigen Datenpunkt und ziehen Sie den Schieberegler Nächstgelegenen kontrafaktischen Datenpunkt anzeigen nach rechts:
Wenn Sie diese Option auswählen, wird der Datenpunkt mit den ähnlichsten Feature-Werten zum ausgewählten Originaldatenpunkt, aber mit der gegenteiligen Vorhersage angezeigt. Anschließend können Sie durch die Feature-Werte scrollen, um zu sehen, wo sich die beiden Datenpunkte unterschieden haben. Die Unterschiede sind grün und fett hervorgehoben.
Schritt 4: Diagramme zur partiellen Abhängigkeit ansehen
Wenn Sie sehen möchten, wie sich die einzelnen Features insgesamt auf die Vorhersagen des Modells auswirken, setzen Sie ein Häkchen bei Diagramme zur partiellen Abhängigkeit und achten Sie darauf, dass Globale Diagramme zur partiellen Abhängigkeit ausgewählt ist:
Hier sehen wir, dass Kredite, die von HUD stammen, eine etwas höhere Wahrscheinlichkeit haben, abgelehnt zu werden. Der Graph hat diese Form, weil der Agenturcode ein boolesches Attribut ist. Die Werte können also nur genau 0 oder 1 sein.
applicant_income_thousands ist ein numerisches Merkmal. Im Diagramm zur partiellen Abhängigkeit sehen wir, dass ein höheres Einkommen die Wahrscheinlichkeit einer Genehmigung des Antrags leicht erhöht, aber nur bis zu etwa 200.000 $. Nach 200.000 $hat dieses Feature keine Auswirkungen auf die Vorhersage des Modells.
Schritt 5: Gesamtleistung und Fairness untersuchen
Rufen Sie als Nächstes den Tab Leistung und Fairness auf. Hier sehen Sie die Gesamtleistungsstatistiken zu den Ergebnissen des Modells für das bereitgestellte Dataset, einschließlich Konfusionsmatrizen, PR-Kurven und ROC-Kurven.
Wählen Sie mortgage_status als Ground Truth-Merkmal aus, um eine Wahrheitsmatrix zu sehen:
Diese Wahrheitsmatrix zeigt die korrekten und falschen Vorhersagen unseres Modells als Prozentsatz der Gesamtzahl. Wenn Sie die Felder Tatsächlich „Ja“ / Vorhersage „Ja“ und Tatsächlich „Nein“ / Vorhersage „Nein“ addieren, sollte sich dieselbe Genauigkeit wie für Ihr Modell ergeben (in diesem Fall etwa 87 %). Die Genauigkeit Ihres Modells kann jedoch leicht abweichen, da beim Trainieren von ML-Modellen ein gewisser Zufallsfaktor besteht.
Sie können auch mit dem Schwellenwert-Schieberegler experimentieren, indem Sie die positive Klassifikationspunktzahl erhöhen und senken, die das Modell zurückgeben muss, bevor es approved für das Darlehen vorhersagt. So können Sie sehen, wie sich das auf die Genauigkeit, falsch positive und falsch negative Ergebnisse auswirkt. In diesem Fall ist die Genauigkeit bei einem Schwellenwert von 0, 55 am höchsten.
Wählen Sie dann links im Drop-down-Menü Aufschlüsseln nach die Option loan_purpose_Home_purchase aus:
Sie sehen jetzt die Leistung der beiden Teilmengen Ihrer Daten: Der Bereich „0“ wird angezeigt, wenn das Darlehen nicht für den Kauf eines Hauses bestimmt ist, und der Bereich „1“, wenn das Darlehen für den Kauf eines Hauses bestimmt ist. Sehen Sie sich die Genauigkeit, die Rate der fälschlicherweise positiven und die Rate der fälschlicherweise negativen Ergebnisse zwischen den beiden Segmenten an, um Leistungsunterschiede zu erkennen.
Wenn Sie die Zeilen maximieren, um die Konfusionsmatrizen zu sehen, können Sie erkennen, dass das Modell für etwa 70% der Darlehensanträge für den Kauf von Häusern „genehmigt“ vorhersagt und nur für 46% der Darlehen, die nicht für den Kauf von Häusern bestimmt sind (die genauen Prozentsätze variieren je nach Modell):
Wenn Sie links in den Optionsfeldern Demografische Parität auswählen, werden die beiden Grenzwerte so angepasst, dass das Modell für einen ähnlichen Prozentsatz von Bewerbern in beiden Segmenten approved vorhersagt. Wie wirkt sich das auf die Genauigkeit, falsch positiven und falsch negativen Ergebnisse für die einzelnen Slices aus?
Schritt 6: Verteilung der Funktionen ansehen
Rufen Sie dann im What-If-Tool den Tab Features auf. Hier sehen Sie die Verteilung der Werte für jedes Feature in Ihrem Dataset:
Auf diesem Tab können Sie prüfen, ob Ihr Dataset ausgewogen ist. Beispiel: Nur sehr wenige Darlehen im Dataset stammen von der Farm Service Agency. Um die Genauigkeit des Modells zu verbessern, könnten wir in Betracht ziehen, weitere Darlehen von dieser Agentur hinzuzufügen, sofern die Daten verfügbar sind.
Hier haben wir nur einige Ideen für die explorative Datenanalyse mit dem What-if Tool beschrieben. Sie können das Tool gerne weiter ausprobieren. Es gibt noch viele weitere Bereiche zu entdecken.
8. Modell in Vertex AI bereitstellen
Wir haben unser Modell lokal zum Laufen gebracht, aber es wäre schön, wenn wir von überall aus Vorhersagen treffen könnten (nicht nur in diesem Notebook). In diesem Schritt stellen wir sie in der Cloud bereit.
Schritt 1: Cloud Storage-Bucket für das Modell erstellen
Definieren wir zuerst einige Umgebungsvariablen, die wir im restlichen Codelab verwenden werden. Geben Sie unten den Namen Ihres Google Cloud-Projekts, den Namen des Cloud Storage-Buckets, den Sie erstellen möchten (muss global eindeutig sein), und den Versionsnamen für die erste Version Ihres Modells ein:
# Update the variables below to your own Google Cloud project ID and GCS bucket name. You can leave the model name we've specified below:
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
MODEL_NAME = 'xgb_mortgage'
Jetzt können wir einen Storage-Bucket zum Speichern unserer XGBoost-Modelldatei erstellen. Wir verweisen Vertex AI bei der Bereitstellung auf diese Datei.
Führen Sie diesen gsutil-Befehl in Ihrem Notebook aus, um einen regionalen Storage-Bucket zu erstellen:
!gsutil mb -l us-central1 $MODEL_BUCKET
Schritt 2: Modelldatei in Cloud Storage kopieren
Als Nächstes kopieren wir die gespeicherte XGBoost-Modelldatei in Cloud Storage. Führen Sie den folgenden gsutil-Befehl aus:
!gsutil cp ./model.bst $MODEL_BUCKET
Rufen Sie den Storage-Browser in der Cloud Console auf, um zu prüfen, ob die Datei kopiert wurde:
Schritt 3: Modell erstellen und auf einem Endpunkt bereitstellen
Wir sind fast bereit, das Modell in der Cloud bereitzustellen. In Vertex AI kann ein Modell mehrere Endpunkte enthalten. Zuerst erstellen wir ein Modell, dann einen Endpunkt in diesem Modell und stellen es bereit.
Erstellen Sie zuerst Ihr Modell mit der gcloud-CLI:
!gcloud beta ai models upload \
--display-name=$MODEL_NAME \
--artifact-uri=$MODEL_BUCKET \
--container-image-uri=us-docker.pkg.dev/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest \
--region=us-central1
Der Parameter artifact-uri verweist auf den Speicherort, an dem Sie Ihr XGBoost-Modell gespeichert haben. Der Parameter container-image-uri gibt an, welcher vorkonfigurierte Container für die Bereitstellung verwendet werden soll. Wenn dieser Befehl abgeschlossen ist, rufen Sie in der Vertex Console den Modellbereich auf, um die ID Ihres neuen Modells zu erhalten. So finden Sie die Funktion:
Kopieren Sie die ID und speichern Sie sie in einer Variablen:
MODEL_ID = "your_model_id"
Jetzt ist es an der Zeit, einen Endpunkt in diesem Modell zu erstellen. Dazu verwenden wir den folgenden gcloud-Befehl:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Wenn der Vorgang abgeschlossen ist, sollte der Speicherort Ihres Endpunkts in der Notebook-Ausgabe protokolliert werden. Suchen Sie nach der Zeile, in der angegeben ist, dass der Endpunkt mit einem Pfad wie dem folgenden erstellt wurde: projects/project_ID/locations/us-central1/endpoints/endpoint_ID.. Ersetzen Sie dann die Werte unten durch die IDs des oben erstellten Endpunkts:
ENDPOINT_ID = "your_endpoint_id"
Führen Sie den folgenden gcloud-Befehl aus, um den Endpunkt bereitzustellen:
!gcloud beta ai endpoints deploy-model $ENDPOINT_ID \
--region=us-central1 \
--model=$MODEL_ID \
--display-name=xgb_mortgage_v1 \
--machine-type=n1-standard-2 \
--traffic-split=0=100
Die Bereitstellung des Endpunkts dauert etwa 5–10 Minuten. Während Ihr Endpunkt bereitgestellt wird, können Sie in der Console zum Bereich „Modelle“ wechseln. Klicken Sie auf Ihr Modell. Das Deployment Ihres Endpunkts sollte angezeigt werden:
Wenn die Bereitstellung erfolgreich abgeschlossen ist, wird anstelle des rotierenden Ladesymbols ein grünes Häkchen angezeigt.
Schritt 4: Bereitgestelltes Modell testen
Um sicherzugehen, dass Ihr bereitgestelltes Modell funktioniert, testen Sie es mit gcloud, um eine Vorhersage zu treffen. Speichern Sie zuerst eine JSON-Datei mit einem Beispiel aus unserem Testset:
%%writefile predictions.json
{
"instances": [
[2016.0, 1.0, 346.0, 27.0, 211.0, 4530.0, 86700.0, 132.13, 1289.0, 1408.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]
]
}
Testen Sie Ihr Modell mit diesem gcloud-Befehl:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
In der Ausgabe sollte die Vorhersage Ihres Modells angezeigt werden. Dieses Beispiel wurde genehmigt. Sie sollten also einen Wert sehen, der nahe 1 liegt.
9. Bereinigen
Wenn Sie dieses Notebook weiterhin verwenden möchten, empfehlen wir, es auszuschalten, wenn Sie es nicht verwenden. Wählen Sie in der Notebooks-Benutzeroberfläche in der Cloud Console das Notebook und dann Beenden aus:
Wenn Sie alle Ressourcen löschen möchten, die Sie in diesem Lab erstellt haben, löschen Sie einfach die Notebook-Instanz, anstatt sie zu beenden.
Wenn Sie den bereitgestellten Endpunkt löschen möchten, rufen Sie in der Vertex-Konsole den Abschnitt „Endpoints“ auf und klicken Sie auf das Löschsymbol:
Wenn Sie den Storage-Bucket löschen möchten, rufen Sie in der Cloud Console über das Navigationsmenü „Storage“ auf, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
