1. Übersicht
In diesem Lab verwenden Sie Vertex AI, um ein TensorFlow-Modell mit Code in einem benutzerdefinierten Container zu trainieren und bereitzustellen.
Wir verwenden hier TensorFlow für den Modellcode, aber Sie könnten ihn problemlos durch ein anderes Framework ersetzen.
Lerninhalte
Die folgenden Themen werden behandelt:
- Modelltrainingscode in Vertex Workbench erstellen und in Containern verpacken
- Benutzerdefinierten Modelltrainingsjob an Vertex AI senden
- Trainiertes Modell auf einem Endpunkt bereitstellen und diesen Endpunkt verwenden, um Vorhersagen zu erhalten
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 aufgeführten Produkte: Training, Prediction und Workbench.
3. 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 AI-Bereich Ihrer Cloud Console auf und klicken Sie auf Vertex AI API aktivieren.
Schritt 3: Container Registry API aktivieren
Rufen Sie die Container Registry auf und wählen Sie Aktivieren aus, falls noch nicht geschehen. Damit erstellen Sie einen Container für Ihren benutzerdefinierten Trainingsjob.
Schritt 4: Vertex AI Workbench-Instanz erstellen
Klicken Sie in der Cloud Console im Bereich „Vertex AI“ auf „Workbench“:
Klicken Sie dort unter Nutzerverwaltete Notebooks auf Neues Notebook:
Wählen Sie dann die aktuelle Version des Instanztyps TensorFlow Enterprise (mit LTS) ohne GPUs aus:
Übernehmen Sie die Standardoptionen und klicken Sie auf Erstellen.
Das Modell, das wir in diesem Lab trainieren und bereitstellen, basiert auf dieser Anleitung aus der TensorFlow-Dokumentation. In diesem Tutorial wird das Auto MPG-Dataset von Kaggle verwendet, um die Kraftstoffeffizienz eines Fahrzeugs vorherzusagen.
4. Trainingscode containerisieren
Wir senden diesen Trainingsjob an Vertex, indem wir unseren Trainingscode in einen Docker-Container einfügen und diesen Container per Push in die Google Container Registry übertragen. Mit diesem Ansatz können wir ein Modell trainieren, das mit einem beliebigen Framework erstellt wurde.
Öffnen Sie zuerst über das Launcher-Menü ein Terminalfenster in Ihrer Notebook-Instanz:
Erstellen Sie ein neues Verzeichnis mit dem Namen mpg und wechseln Sie dorthin:
mkdir mpg
cd mpg
Schritt 1: Dockerfile erstellen
Der erste Schritt beim Containerisieren unseres Codes ist das Erstellen eines Dockerfile. Unser Dockerfile enthält alle Befehle, die zum Ausführen unseres Images erforderlich sind. Dadurch werden alle von uns verwendeten Bibliotheken installiert und der Einstiegspunkt für unseren Trainingscode eingerichtet. Erstellen Sie über Ihr Terminal ein leeres Dockerfile:
touch Dockerfile
Öffnen Sie das Dockerfile und kopieren Sie Folgendes hinein:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
In diesem Dockerfile wird das Deep Learning Container-Docker-Image für TensorFlow Enterprise 2.3 verwendet. In den Deep Learning-Containern in Google Cloud sind viele gängige ML- und Data-Science-Frameworks vorinstalliert. Die von uns verwendete Version umfasst TF Enterprise 2.3, Pandas, Scikit-learn und andere. Nach dem Herunterladen dieses Images wird mit diesem Dockerfile der Einstiegspunkt für unseren Trainingscode eingerichtet. Wir haben diese Dateien noch nicht erstellt. Im nächsten Schritt fügen wir den Code zum Trainieren und Exportieren unseres Modells hinzu.
Schritt 2: Cloud Storage-Bucket erstellen
In unserem Trainingsjob exportieren wir unser trainiertes TensorFlow-Modell in einen Cloud Storage-Bucket. Vertex verwendet dies, um unsere exportierten Modell-Assets zu lesen und das Modell bereitzustellen. Führen Sie im Terminal den folgenden Befehl aus, um eine Umgebungsvariable für Ihr Projekt zu definieren. Ersetzen Sie dabei your-cloud-project durch die ID Ihres Projekts:
PROJECT_ID='your-cloud-project'
Führen Sie als Nächstes den folgenden Befehl im Terminal aus, um einen neuen Bucket in Ihrem Projekt zu erstellen. Das Flag -l (location) ist wichtig, da es sich in derselben Region befinden muss, in der Sie später im Tutorial einen Modellendpunkt bereitstellen:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Schritt 3: Code für das Modelltraining hinzufügen
Führen Sie im Terminal den folgenden Befehl aus, um ein Verzeichnis für den Trainingscode und eine Python-Datei zu erstellen, in die wir den Code einfügen:
mkdir trainer
touch trainer/train.py
Im Verzeichnis „mpg/“ sollten sich nun folgende Dateien befinden:
+ Dockerfile
+ trainer/
+ train.py
Öffnen Sie als Nächstes die gerade erstellte Datei train.py und kopieren Sie den folgenden Code (er wurde aus dem Tutorial in der TensorFlow-Dokumentation übernommen).
Aktualisieren Sie am Anfang der Datei die Variable BUCKET mit dem Namen des Storage-Buckets, den Sie im vorherigen Schritt erstellt haben:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Schritt 4: Container lokal erstellen und testen
Definieren Sie im Terminal eine Variable mit dem URI Ihres Container-Images in Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Erstellen Sie dann den Container, indem Sie den folgenden Befehl im Stammverzeichnis Ihres mpg-Verzeichnisses ausführen:
docker build ./ -t $IMAGE_URI
Führen Sie den Container in Ihrer Notebook-Instanz aus, um sicherzustellen, dass er richtig funktioniert:
docker run $IMAGE_URI
Das Training des Modells sollte in 1–2 Minuten abgeschlossen sein und eine Validierungsgenauigkeit von etwa 72 % erreichen (die genaue Genauigkeit kann variieren). Wenn Sie den Container lokal ausgeführt haben, übertragen Sie ihn per Push an Google Container Registry:
docker push $IMAGE_URI
Nachdem wir unseren Container in die Container Registry übertragen haben, können wir jetzt einen benutzerdefinierten Modelltrainingsjob starten.
5. Trainingsjob in Vertex AI ausführen
Vertex AI bietet zwei Optionen für das Trainieren von Modellen:
- AutoML: Mit minimalem Aufwand und minimalen Fachkenntnissen zu maschinellem Lernen hochwertige Modelle trainieren.
- Benutzerdefiniertes Training: Führen Sie Ihre benutzerdefinierten Trainingsanwendungen in der Cloud aus. Verwenden Sie dazu einen der vordefinierten Container von Google Cloud oder einen eigenen Container.
In diesem Lab verwenden wir benutzerdefiniertes Training über unseren eigenen benutzerdefinierten Container in Google Container Registry. Rufen Sie zuerst in der Cloud Console im Bereich „Vertex“ den Abschnitt Modelle auf:
Schritt 1: Trainingsjob starten
Klicken Sie auf Erstellen, um die Parameter für Ihren Trainingsjob und das bereitgestellte Modell einzugeben:
- Wählen Sie unter Dataset die Option Kein verwaltetes Dataset aus.
- Wählen Sie dann Benutzerdefiniertes Training (erweitert) als Trainingsmethode aus und klicken Sie auf Weiter.
- Klicken Sie auf Weiter.
Geben Sie im nächsten Schritt mpg (oder einen anderen Namen für Ihr Modell) für Modellname ein. Wählen Sie dann Benutzerdefinierter Container aus:
Klicken Sie im Textfeld Container-Image auf Durchsuchen und suchen Sie nach dem Docker-Image, das Sie gerade in Container Registry hochgeladen haben. Lassen Sie die anderen Felder leer und klicken Sie auf Weiter.
In dieser Anleitung wird keine Hyperparameter-Abstimmung verwendet. Lassen Sie das Kästchen „Hyperparameter-Abstimmung aktivieren“ deaktiviert und klicken Sie auf Weiter.
Lassen Sie unter Compute und Preise die ausgewählte Region unverändert und wählen Sie n1-standard-4 als Maschinentyp aus:
Lassen Sie die Felder für die Beschleuniger leer und wählen Sie Weiter aus. Da das Modell in dieser Demo schnell trainiert wird, verwenden wir einen kleineren Maschinentyp.
Wählen Sie im Schritt Vorhersagecontainer die Option Vordefinierter Container und dann TensorFlow 2.6 aus.
Behalten Sie die Standardeinstellungen für den vordefinierten Container bei. Geben Sie unter Modellverzeichnis Ihren GCS-Bucket mit dem Unterverzeichnis „mpg“ ein. Dies ist der Pfad in Ihrem Modelltrainingsskript, in dem Sie Ihr trainiertes Modell exportieren:
Vertex sucht an diesem Speicherort, wenn Ihr Modell bereitgestellt wird. Jetzt kann es losgehen! Klicken Sie auf Training starten, um den Trainingsjob zu starten. Im Bereich „Training“ der Konsole sehen Sie etwa Folgendes:
6. Modellendpunkt bereitstellen
Beim Einrichten des Trainingsjobs haben wir angegeben, wo Vertex AI nach den exportierten Modell-Assets suchen soll. Im Rahmen unserer Trainingspipeline wird in Vertex eine Modellressource basierend auf diesem Asset-Pfad erstellt. Die Modellressource selbst ist kein bereitgestelltes Modell. Sobald Sie ein Modell haben, können Sie es auf einem Endpunkt bereitstellen. Weitere Informationen zu Modellen und Endpunkten in Vertex AI finden Sie in der Dokumentation.
In diesem Schritt erstellen wir einen Endpunkt für unser trainiertes Modell. Damit können wir Vorhersagen für unser Modell über die Vertex AI API abrufen.
Schritt 1: Endpunkt bereitstellen
Wenn Ihr Trainingsjob abgeschlossen ist, sollte in der Console im Abschnitt Modelle ein Modell mit dem Namen mpg (oder dem von Ihnen gewählten Namen) angezeigt werden:
Als Ihr Trainingsjob ausgeführt wurde, hat Vertex eine Modellressource für Sie erstellt. Um dieses Modell verwenden zu können, müssen Sie einen Endpunkt bereitstellen. Sie können viele Endpunkte pro Modell haben. Klicken Sie auf das Modell und dann auf Auf Endpunkt bereitstellen.
Wählen Sie Neuen Endpunkt erstellen aus und geben Sie ihm einen Namen, z. B. „v1“. Lassen Sie Standard für den Zugriff ausgewählt und klicken Sie auf Weiter.
Lassen Sie Trafficaufteilung auf 100 und geben Sie 1 für Mindestanzahl von Computing-Knoten ein. Wählen Sie unter Maschinentyp die Option n1-standard-2 (oder einen beliebigen anderen Maschinentyp) aus. Lassen Sie die restlichen Standardeinstellungen ausgewählt und klicken Sie auf Weiter. Wir aktivieren das Monitoring für dieses Modell nicht. Klicken Sie daher als Nächstes auf Bereitstellen, um die Endpunktbereitstellung zu starten.
Die Bereitstellung des Endpunkts dauert 10 bis 15 Minuten. Sie erhalten eine E‑Mail, wenn die Bereitstellung abgeschlossen ist. Wenn die Bereitstellung des Endpunkts abgeschlossen ist, wird Folgendes angezeigt. Hier ist ein Endpunkt unter Ihrer Modellressource bereitgestellt:
Schritt 2: Vorhersagen für das bereitgestellte Modell abrufen
Wir rufen Vorhersagen für unser trainiertes Modell über ein Python-Notebook mit der Vertex Python API ab. Kehren Sie zu Ihrer Notebook-Instanz zurück und erstellen Sie über den Launcher ein Python 3-Notebook:
Führen Sie in Ihrem Notebook Folgendes in einer Zelle aus, um das Vertex AI SDK zu installieren:
!pip3 install google-cloud-aiplatform --upgrade --user
Fügen Sie dann eine Zelle in Ihr Notebook ein, um das SDK zu importieren und einen Verweis auf den gerade bereitgestellten Endpunkt zu erstellen:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Sie müssen zwei Werte im obigen endpoint_name-String durch Ihre Projektnummer und Ihren Endpunkt ersetzen. Sie finden die Projektnummer im Projekt-Dashboard.
Sie finden Ihre Endpunkt-ID im Bereich „Endpunkte“ der Console:
Führen Sie schließlich eine Vorhersage für Ihren Endpunkt aus, indem Sie den folgenden Code in eine neue Zelle kopieren und ausführen:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Dieses Beispiel enthält bereits normalisierte Werte, was dem Format entspricht, das unser Modell erwartet.
Führen Sie diese Zelle aus. Sie sollten eine Vorhersage von etwa 6, 8 km/l sehen.
🎉 Das wars! 🎉
Sie haben gelernt, wie Sie Vertex AI für folgende Aufgaben verwenden:
- Trainieren Sie ein Modell, indem Sie den Trainingscode in einem benutzerdefinierten Container bereitstellen. In diesem Beispiel haben Sie ein TensorFlow-Modell verwendet. Sie können jedoch ein Modell, das mit einem beliebigen Framework erstellt wurde, mit benutzerdefinierten Containern trainieren.
- Stellen Sie ein TensorFlow-Modell mit einem vordefinierten Container im Rahmen desselben Workflows bereit, den Sie für das Training verwendet haben.
- Modellendpunkt erstellen und Vorhersage generieren
Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.
7. Bereinigen
Wenn Sie das in diesem Lab erstellte Notebook weiterhin verwenden möchten, sollten Sie es deaktivieren, wenn Sie es nicht nutzen. Wählen Sie in der Workbench-Benutzeroberfläche in der Cloud Console das Notebook und dann Beenden aus.
Wenn Sie das Notebook vollständig löschen möchten, klicken Sie oben rechts auf die Schaltfläche „Löschen“.
Wenn Sie den bereitgestellten Endpunkt löschen möchten, rufen Sie in der Vertex AI Console den Bereich Endpunkte auf, klicken Sie auf den erstellten Endpunkt und wählen Sie dann Bereitstellung des Modells vom Endpunkt aufheben aus:
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“:
