1. Übersicht
In diesem Lab analysieren Sie mit dem What-If-Tool ein mit Finanzdaten trainiertes XGBoost-Modell. Nachdem Sie das Modell analysiert haben, stellen Sie es im neuen Vertex AI der Cloud bereit.
Lerninhalte
Die folgenden Themen werden behandelt:
- XGBoost-Modell mit einem öffentlichen Hypotheken-Dataset in einem gehosteten Notebook trainieren
- Modell mit dem What-if-Tool analysieren
- XGBoost-Modell in Vertex AI bereitstellen
Die Gesamtkosten für das Lab in Google Cloud belaufen sich auf 1$.
2. Einführung in Vertex AI
In diesem Lab wird das neueste KI-Produktangebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Zuvor waren mit AutoML trainierte und benutzerdefinierte Modelle über separate Dienste zugänglich. Das neue Angebot vereint beides in einer einzigen API sowie weitere neue Produkte. Sie können auch vorhandene Projekte zu Vertex AI migrieren. Wenn Sie uns Feedback geben möchten, besuchen Sie die Supportseite.
Vertex AI enthält viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab liegt der Fokus auf den unten genannten Produkten: Vorhersagen und Notebooks.
3. Eine 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 basierend auf dem Wert zusammengefasst, der den verschiedenen Blattknoten in einem Baum zugeordnet ist.
Das folgende Diagramm zeigt eine Visualisierung eines einfachen Entscheidungsbaummodells, das anhand der Wettervorhersage auswertet, ob ein Sportspiel ausgetragen werden soll:
Warum verwenden wir XGBoost für dieses Modell? Während traditionelle neuronale Netzwerke nachweislich am besten mit unstrukturierten Daten wie Bildern und Text funktionieren, funktionieren Entscheidungsbäume häufig sehr gut mit strukturierten Daten wie dem Hypotheken-Dataset, das wir in diesem Codelab verwenden werden.
4. Richten Sie Ihre Umgebung ein.
Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Compute Engine API aktivieren
Gehen Sie zu Compute Engine und wählen Sie Aktivieren aus, falls dies noch nicht geschehen ist. Sie benötigen dies zum Erstellen Ihrer Notebookinstanz.
Schritt 2: Vertex AI API aktivieren
Rufen Sie in der Cloud Console den Bereich „Vertex“ auf und klicken Sie auf Vertex AI API aktivieren.
Schritt 3: Notebooks-Instanz erstellen
Klicken Sie in der Cloud Console im Bereich Vertex auf „Notebooks“:
Wählen Sie dort Neue Instanz aus. Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.3 ohne GPUs aus:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen. Nachdem die Instanz erstellt wurde, wählen Sie JupyterLab öffnen aus.
Schritt 4: XGBoost installieren
Nachdem die 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 anschließend eine Python 3-Notebookinstanz im Launcher. Jetzt können Sie in Ihrem Notizbuch 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 ihn ausführen, indem Sie im oberen Menü den Rechtspfeil oder Befehlstaste + 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 Hypotheken-Dataset von ffiec.gov, um ein XGBoost-Modell zu trainieren. Wir haben das ursprüngliche Dataset vorverarbeitet und eine kleinere Version erstellt, die Sie zum Trainieren des Modells verwenden können. Das Modell prognostiziert, ob ein bestimmter Hypothekenantrag genehmigt wird oder nicht.
Schritt 1: Vorverarbeitetes Dataset herunterladen
Wir haben eine Version des Datasets in Google Cloud Storage für Sie verfügbar gemacht. 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 den Pandas-DataFrame erstellen, erstellen wir eine dict des Datentyps jeder Spalte, damit Pandas das Dataset korrekt 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 nach dem Zufallsprinzip zu mischen, falls das ursprüngliche Dataset auf eine bestimmte Weise angeordnet ist. Dazu verwenden wir ein sklearn-Dienstprogramm namens shuffle, das wir in die erste 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 eine Vorschau der ersten fünf Zeilen des Datasets in Pandas anzeigen lassen. Nach dem Ausführen der Zelle oben sollte in etwa Folgendes angezeigt werden:
Mit diesen Features trainieren wir unser Modell. Wenn Sie ganz bis zum Ende scrollen, sehen Sie die letzte Spalte approved. Das ist das Ergebnis, das wir vorhersagen. Der Wert 1 bedeutet, dass ein bestimmter Antrag genehmigt wurde, und 0, dass er abgelehnt wurde.
Führen Sie folgenden Befehl aus, um die Verteilung der genehmigten / abgelehnten Werte im Dataset zu sehen und ein NumPy-Array der Labels zu erstellen:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
Etwa 66% des Datasets enthält genehmigte Bewerbungen.
Schritt 3: Dummy-Spalte für kategoriale Werte erstellen
Dieses Dataset enthält eine Mischung aus kategorialen und numerischen Werten. Für XGBoost müssen jedoch alle Funktionen numerisch sein. Anstelle der Darstellung kategorialer Werte mit der One-Hot-Codierung nutzen wir für unser XGBoost-Modell die Pandas-Funktion get_dummies.
get_dummies wandelt eine Spalte mit mehreren möglichen Werten in eine Reihe von Spalten um, die jeweils nur Nullen und Einsen enthalten. Hätten wir z. B. die Spalte
„Farbe“ für „Farbe“ mit den möglichen Werten "blue" und „Rot“, get_dummies würde dies in zwei Spalten namens „color_blue“ umwandeln und „color_red“ mit allen booleschen Werten 0 und 1.
Führen Sie den folgenden Code aus, um Dummy-Spalten für unsere 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 diesmal die Daten in der Vorschau ansehen, werden Sie feststellen, dass einzelne Elemente (wie unten abgebildet purchaser_type) in mehrere Spalten aufgeteilt sind:
Schritt 4: Daten in Trainings- und Test-Datasets aufteilen
Ein wichtiges Konzept beim maschinellen Lernen ist die Trainings-/Testaufteilung. Wir nehmen den Großteil unserer Daten zum Trainieren unseres Modells und räumen den Rest ein, um unser Modell mit Daten zu testen, die es zuvor noch nicht gesehen hat.
Fügen Sie Ihrem Notebook den folgenden Code hinzu, der die Scikit-learn-Funktion train_test_split zum Aufteilen der Daten verwendet:
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 XGBClassifier-Klasse, um das Modell zu erstellen, und müssen für unsere spezifische Klassifizierungsaufgabe nur den richtigen objective-Parameter übergeben. In diesem Fall verwenden wir reg:logistic, da wir ein binäres Klassifizierungsproblem haben und das Modell einen einzelnen Wert im Bereich von (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 einzigen Codezeile 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.
Dann verwenden wir die accuracy_score()-Funktion von Scikit-learn, um die Genauigkeit unseres Modells basierend auf dessen Leistung mit unseren Testdaten zu berechnen. Wir übergeben ihr die Ground-Truth-Werte zusammen mit den vorhergesagten Werten des Modells für jedes Beispiel in unserem Test-Dataset:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
Die Genauigkeit sollte bei etwa 87% liegen. Bei Ihnen wird sich diese jedoch leicht unterscheiden, da es beim maschinellen Lernen immer ein Element der Zufälligkeit gibt.
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 zur Interpretation Ihres Modells verwenden
Schritt 1: What-if-Tool-Visualisierung erstellen
Um das Was-wäre-wenn-Tool mit Ihrem lokalen Modell zu verbinden, müssen Sie ihm eine Teilmenge Ihrer Testbeispiele zusammen mit den Ground-Truth-Werten für diese Beispiele übergeben. Lassen Sie uns ein Numpy-Array von 500 unserer Testbeispiele und den zugehörigen Ground-Truth-Labels erstellen:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
Zum Instanziieren des What-if-Tools müssen Sie nur ein WitConfigBuilder-Objekt erstellen und ihm das Modell übergeben, das wir analysieren möchten.
Da das What-if-Tool eine Liste von Punktzahlen für jede Klasse in unserem Modell erwartet (in diesem Fall 2), 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)
Es kann eine Minute dauern, bis die Visualisierung geladen ist. Beim Laden sollte Folgendes angezeigt werden:
Die Y-Achse zeigt die Vorhersage des Modells, wobei 1 eine approved-Vorhersage mit hoher Zuverlässigkeit und 0 eine hohe Konfidenz für denied-Vorhersage ist. Die X-Achse ist einfach die Streuung aller geladenen Datenpunkte.
Schritt 2: Einzelne Datenpunkte untersuchen
Die Standardansicht des What-if-Tools ist der Tab Datenpunkteditor. Hier können Sie auf einen einzelnen Datenpunkt klicken, um dessen Merkmale anzuzeigen, Featurewerte 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 in der Nähe des 0,5-Schwellenwerts ausgewählt. Der mit diesem speziellen Datenpunkt verknüpfte Hypothekenantrag stammt aus CFPB. Wir haben diese Funktion in 0 geändert und auch den Wert von agency_code_Department of Housing and Urban Development (HUD) in 1 geändert, um zu sehen, was mit der Vorhersage des Modells passiert, wenn dieser Kredit stattdessen von HUD stammt:
Wie Sie im What-if-Tool unten links sehen können, wurde die approved-Vorhersage des Modells durch eine Änderung dieses Features um 32 % deutlich reduziert. Dies könnte darauf hindeuten, dass die Agentur, von der ein Darlehen erhalten wurde, einen starken Einfluss auf die Ergebnisse des Modells hat. Um sicherzugehen, müssen wir jedoch weitere Analysen durchführen.
Unten links in der Benutzeroberfläche können wir auch den Ground-Truth-Wert für jeden Datenpunkt sehen und mit der Vorhersage des Modells vergleichen:
Schritt 3: Kontrafaktische Analyse
Klicken Sie dann auf einen Datenpunkt und bewegen Sie den Schieberegler Nächsten kontrafaktischen Datenpunkt anzeigen nach rechts:
Wenn Sie diese Option auswählen, wird der Datenpunkt angezeigt, der dem ursprünglich ausgewählten Element die ähnlichsten Featurewerte hat, jedoch die entgegengesetzte Vorhersage. Sie können dann durch die Featurewerte scrollen, um zu sehen, wo sich die beiden Datenpunkte unterscheiden (die Unterschiede sind grün und fett markiert).
Schritt 4: Teilabhängigkeitsdiagramme ansehen
Um zu sehen, wie sich die einzelnen Funktionen insgesamt auf die Vorhersagen des Modells auswirken, klicken Sie das Kästchen Teilabhängigkeitsdiagramme an und achten Sie darauf, dass Globale Teilabhängigkeitsdiagramme ausgewählt sind:
Hier sehen wir, dass bei Krediten, die von HUD stammen, die Wahrscheinlichkeit, dass sie abgelehnt werden, etwas höher ist. Die Grafik zeigt diese Form, weil der Agenturcode ein boolesches Merkmal ist, sodass Werte nur genau 0 oder 1 sein können.
applicant_income_thousands ist ein numerisches Merkmal. Im Diagramm der Teilabhängigkeit können wir sehen, dass ein höheres Einkommen die Wahrscheinlichkeit, dass ein Antrag genehmigt wird, geringfügig erhöht, jedoch nur bis zu etwa 200.000 $. Nach 200.000 $hat diese Funktion keinen Einfluss auf die Vorhersage des Modells.
Schritt 5: Gesamtleistung und Fairness untersuchen
Klicken Sie als Nächstes auf den Tab Leistung und Fairness. Hier werden Gesamtleistungsstatistiken zu den Ergebnissen des Modells für das bereitgestellte Dataset angezeigt, einschließlich Wahrheitsmatrizen, PR-Kurven und ROC-Kurven.
Wählen Sie mortgage_status als Ground Truth-Feature aus, um eine Wahrheitsmatrix aufzurufen:
Diese Wahrheitsmatrix zeigt die richtigen und falschen Vorhersagen unseres Modells als Prozentsatz der Gesamtzahl. Wenn Sie die Quadrate Tatsächliches Ja / Vorhergesagtes Ja und Tatsächliches Nein / Vorhergesagtes Nein addieren, sollte die Genauigkeit Ihres Modells übereinstimmen (in diesem Fall bei etwa 87%, auch wenn Ihr Modell leicht variieren kann, da es beim Trainieren von ML-Modellen ein Element der Zufälligkeit gibt).
Sie können auch mit dem Schieberegler für den Schwellenwert experimentieren, um den positiven Klassifizierungswert, den das Modell zurückgeben muss, zu erhöhen oder zu senken, bevor es entscheidet, approved für den Kredit vorherzusagen. So können Sie sehen, wie sich dies auf die Genauigkeit sowie auf falsch positive und falsch negative Ergebnisse auswirkt. In diesem Fall ist die Genauigkeit um einen Schwellenwert von 0, 55 am höchsten.
Wählen Sie dann im linken Drop-down-Menü Slice nach die Option loan_purpose_Home_purchase aus:
Sie sehen nun die Leistung für die beiden Teilmengen Ihrer Daten: die "0" wird angezeigt, wenn der Kredit nicht für den Kauf einer Immobilie vorgesehen ist, und die „1“ Ein Segment bezieht sich auf den Darlehen für den Kauf einer Immobilie. Überprüfen Sie die Genauigkeit, die falsch positive und die falsch negative Rate zwischen den beiden Segmenten, um Leistungsunterschiede zu ermitteln.
Wenn Sie die Zeilen erweitern, um sich die Wahrheitsmatrizen anzusehen, sehen Sie, dass das Modell „genehmigt“ vorhersagt für ca. 70% Kreditanträge für den Kauf von Immobilien und nur 46% der Darlehen, die nicht für den Kauf von Immobilien vorgesehen sind (die genauen Prozentsätze variieren je nach Modell):
Wenn Sie über die Optionsfelder auf der linken Seite Demografische Gleichheit auswählen, werden die beiden Grenzwerte angepasst. Das Modell prognostiziert dann approved für einen ähnlichen Prozentsatz von Bewerbern in beiden Segmenten. Wie wirkt sich dies auf die Genauigkeit sowie auf falsch positive und falsch negative Ergebnisse für jedes Segment aus?
Schritt 6: Featureverteilung untersuchen
Gehen Sie schließlich zum Tab Funktionen im What-if-Tool. Hier sehen Sie die Verteilung der Werte für jedes Feature in Ihrem Dataset:
Mit diesem Tab können Sie dafür sorgen, dass Ihr Dataset ausgewogen ist. Es sieht beispielsweise so aus, als ob nur sehr wenige Kredite in dem Dataset von der Farm Service Agency stammen. Um die Genauigkeit des Modells zu verbessern, könnten wir erwägen, weitere Kredite von dieser Agentur hinzuzufügen, sofern die Daten verfügbar sind.
Hier finden Sie nur einige Ideen für die explorative Datenanalyse für das What-if-Tool. Probieren Sie einfach weiter mit dem Tool, es gibt noch viele weitere Bereiche zu erkunden!
8. Modell in Vertex AI bereitstellen
Unser Modell läuft zwar lokal, aber es wäre schön, wenn wir von überall aus Vorhersagen treffen könnten (nicht nur von diesem Notebook!). In diesem Schritt stellen wir es in der Cloud bereit.
Schritt 1: Cloud Storage-Bucket für das Modell erstellen
Definieren wir zuerst einige Umgebungsvariablen, die wir im weiteren Codelab verwenden. 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 der XGBoost-Modelldatei erstellen. Wir verweisen Vertex AI beim Bereitstellen auf diese Datei.
Führen Sie den folgenden 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 in XGBoost gespeicherte Modelldatei nach Cloud Storage. Führen Sie den folgenden gsutil-Befehl aus:
!gsutil cp ./model.bst $MODEL_BUCKET
Prüfen Sie im Storage-Browser in der Cloud Console, 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 haben. Zuerst erstellen wir ein Modell, dann erstellen wir einen Endpunkt innerhalb dieses Modells und stellen es bereit.
Erstellen Sie zuerst Ihr Modell mit der gcloud-Befehlszeile:
!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 das XGBoost-Modell gespeichert haben. Der Parameter container-image-uri teilt Vertex AI mit, welcher vorkonfigurierte Container für die Bereitstellung verwendet werden soll. Rufen Sie nach Abschluss dieses Befehls den Abschnitt „Modelle“ Ihrer Vertex-Konsole auf, um die ID Ihres neuen Modells abzurufen. Sie finden sie hier:
Kopieren Sie diese ID und speichern Sie sie in einer Variablen:
MODEL_ID = "your_model_id"
Jetzt ist es an der Zeit, einen Endpunkt innerhalb dieses Modells zu erstellen. Dazu können wir folgenden gcloud-Befehl verwenden:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Wenn dies abgeschlossen ist, sollte der Standort Ihres Endpunkts in der Notebookausgabe protokolliert werden. Suchen Sie nach der Zeile, die angibt, dass der Endpunkt mit einem Pfad erstellt wurde, der so aussieht: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. Ersetzen Sie dann die Werte unten durch die IDs Ihres 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 bis 10 Minuten. Wechseln Sie während der Bereitstellung des Endpunkts zum Abschnitt „Modelle“ der Konsole. Wenn Sie auf Ihr Modell klicken, sollten Sie sehen, wie Ihr Modell bereitgestellt wird:
Wenn die Bereitstellung erfolgreich abgeschlossen wurde, wird an der Stelle, an der sich das Ladesymbol befindet, ein grünes Häkchen angezeigt.
Schritt 4: Bereitgestelltes Modell testen
Prüfen Sie, ob das bereitgestellte Modell funktioniert, indem Sie es mit gcloud testen, um eine Vorhersage zu treffen. Speichern Sie zuerst eine JSON-Datei mit einem Beispiel aus unserem Test-Dataset:
%%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 dem folgenden gcloud-Befehl:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
In der Ausgabe sollten Sie die Vorhersage Ihres Modells sehen. Dieses Beispiel wurde genehmigt, der Wert sollte nahe 1 liegen.
9. Bereinigen
Wenn Sie dieses Notebook weiterverwenden möchten, empfehlen wir Ihnen, es bei Nichtgebrauch auszuschalten. Wählen Sie in der Notebooks-UI 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 Notebookinstanz, anstatt sie zu beenden.
Wenn Sie den von Ihnen bereitgestellten Endpunkt löschen möchten, gehen Sie zum Abschnitt „Endpunkte“ der Vertex-Konsole und klicken Sie auf das Symbol zum Löschen:
Wenn Sie den Storage-Bucket löschen möchten, gehen Sie im Navigationsmenü der Cloud Console zu „Storage“, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
