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 zwar TensorFlow für den Modellcode, Sie können es aber auch problemlos durch ein anderes Framework ersetzen.
Lerninhalte
Die folgenden Themen werden behandelt:
- Code für das Modelltraining in Vertex Workbench erstellen und containerisieren
- Benutzerdefinierten Modelltrainingsjob an Vertex AI senden
- Trainiertes Modell auf einem Endpunkt bereitstellen und mit diesem Endpunkt Vorhersagen abrufen
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-Angebot von Google Cloud verwendet. Vertex AI integriert die ML-Angebote in Google Cloud für eine nahtlose Entwicklung. Bisher konnten auf mit AutoML trainierte Modelle und benutzerdefinierte Modelle über separate Dienste zugegriffen werden. Das neue Angebot kombiniert beide zusammen mit anderen neuen Produkten in einer einzigen API. Sie können auch vorhandene Projekte zu Vertex AI migrieren. Wenn du Feedback hast, sieh auf der Supportseite nach.
Vertex AI umfasst viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab liegt der Schwerpunkt auf den unten aufgeführten Produkten: Training, Prediction und Workbench.
3. Richten Sie Ihre Umgebung ein.
Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Eine Anleitung zum Erstellen eines Projekts finden Sie hier.
Schritt 1: Compute Engine API aktivieren
Rufen Sie Compute Engine auf und wählen Sie Aktivieren aus, falls die Option noch nicht aktiviert ist. Sie benötigen dies zum Erstellen Ihrer Notebookinstanz.
Schritt 2: Vertex AI API aktivieren
Rufen Sie den Bereich „Vertex AI“ der Cloud Console auf und klicken Sie auf Vertex AI API aktivieren.
Schritt 3: Container Registry API aktivieren
Rufen Sie Container Registry auf und wählen Sie Aktivieren aus, falls noch nicht geschehen. Sie verwenden es, um einen Container für Ihren benutzerdefinierten Trainingsjob zu erstellen.
Schritt 4: Vertex AI Workbench-Instanz erstellen
Klicken Sie im Bereich Vertex AI der Cloud Console 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:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen.
Das Modell, das wir in diesem Lab trainieren und bereitstellen, basiert auf dieser Anleitung aus den TensorFlow-Dokumenten. In der Anleitung wird der Auto MPG-Dataset von Kaggle verwendet, um den Kraftstoffverbrauch 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 Google Container Registry übertragen. Mit diesem Ansatz können wir ein Modell trainieren, das mit einem beliebigen Framework erstellt wurde.
Öffnen Sie dazu im Launcher-Menü ein Terminalfenster in Ihrer Notebookinstanz:
Erstellen Sie ein neues Verzeichnis mit dem Namen mpg und wechseln Sie dorthin:
mkdir mpg
cd mpg
Schritt 1: Dockerfile erstellen
Der erste Schritt bei der Containerisierung unseres Codes besteht darin, ein Dockerfile zu erstellen. In unserem Dockerfile werden alle Befehle enthalten sein, die zum Ausführen unseres Images erforderlich sind. Dadurch werden alle 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 fügen Sie Folgendes ein:
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 TensorFlow Enterprise 2.3-Docker-Image verwendet. Die Deep Learning Container in Google Cloud sind mit vielen gängigen ML- und Data-Science-Frameworks vorinstalliert. Die von uns verwendete Version enthält unter anderem TF Enterprise 2.3, Pandas und Scikit-learn. Nach dem Herunterladen dieses Images richtet dieses Dockerfile den Einstiegspunkt für unseren Trainingscode ein. Diese Dateien haben wir 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 diese Information, um die 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 (Standort) ist wichtig, da es sich in derselben Region befinden muss, in der Sie später in der Anleitung einen Modellendpunkt bereitstellen:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Schritt 3: Code zum Trainieren des Modells hinzufügen
Führen Sie in Ihrem Terminal den folgenden Befehl aus, um ein Verzeichnis für unseren Trainingscode und eine Python-Datei zu erstellen, in die wir den Code einfügen:
mkdir trainer
touch trainer/train.py
In Ihrem mpg/-Verzeichnis sollte nun Folgendes vorhanden sein:
+ Dockerfile
+ trainer/
+ train.py
Öffnen Sie als Nächstes die soeben erstellte train.py-Datei und kopieren Sie den folgenden Code. Er wurde aus dem Tutorial in den TensorFlow-Dokumenten ü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 der Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Erstellen Sie dann den Container, indem Sie im Stammverzeichnis Ihres mpg-Verzeichnisses Folgendes ausführen:
docker build ./ -t $IMAGE_URI
Führen Sie den Container in Ihrer Notebookinstanz aus, um sicherzustellen, dass er richtig funktioniert:
docker run $IMAGE_URI
Das Modell sollte das Training in 1–2 Minuten mit einer Validierungsgenauigkeit von etwa 72 % abschließen. Die genaue Genauigkeit kann variieren. Wenn Sie den Container lokal ausgeführt haben, übertragen Sie ihn per Push in die Google Container Registry:
docker push $IMAGE_URI
Nachdem unser Container in die Container Registry übertragen wurde, können wir jetzt einen benutzerdefinierten Trainingsjob für das Modell starten.
5. Trainingsjob in Vertex AI ausführen
Vertex AI bietet zwei Optionen zum Trainieren von Modellen:
- AutoML: Trainieren Sie mit minimalem Aufwand und minimalen Fachkenntnissen zu maschinellem Lernen hochwertige Modelle.
- Benutzerdefiniertes Training: Sie können Ihre benutzerdefinierten Trainingsanwendungen in der Cloud mit einem der vordefinierten Container von Google Cloud ausführen oder Ihren eigenen verwenden.
In diesem Lab verwenden wir benutzerdefiniertes Training über unseren eigenen benutzerdefinierten Container in der Google Container Registry. Rufen Sie zuerst in der Cloud Console im Bereich „Vertex“ den Bereich 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 beliebigen Namen) für Modellname ein. Wählen Sie dann Benutzerdefinierter Container aus:
Klicken Sie im Textfeld Container-Image auf Durchsuchen und suchen Sie das Docker-Image, das Sie gerade in Container Registry hochgeladen haben. Lassen Sie die anderen Felder leer und klicken Sie auf Continue (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 Rechenleistung und Preise die ausgewählte Region unverändert und wählen Sie n1-standard-4 als Maschinentyp aus:
Lassen Sie die Felder für den Beschleuniger leer und wählen Sie Continue (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.
Lassen Sie die Standardeinstellungen für den vorkonfigurierten Container unverändert. Geben Sie unter Modellverzeichnis Ihren GCS-Bucket mit dem Unterverzeichnis „mpg“ ein. Dies ist der Pfad im Modelltrainingsskript, in den Sie das trainierte Modell exportieren:
Vertex sucht an diesem Speicherort, wenn es Ihr Modell bereitstellt. Jetzt sind Sie bereit für das Training. Klicken Sie auf Training starten, um den Trainingsjob zu starten. Im Bereich „Training“ Ihrer Konsole sehen Sie dann in etwa Folgendes:
6. Modellendpunkt bereitstellen
Beim Einrichten des Trainingsjobs haben wir angegeben, wo Vertex AI nach unseren exportierten Modell-Assets suchen soll. Im Rahmen unserer Trainingspipeline erstellt Vertex eine Modellressource basierend auf diesem Asset-Pfad. Die Modellressource selbst ist kein bereitgestelltes Modell. Sobald Sie jedoch 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. So können wir über die Vertex AI API Vorhersagen für unser Modell abrufen.
Schritt 1: Endpunkt bereitstellen
Wenn der Trainingsjob abgeschlossen ist, sollte im Bereich Modelle der Console ein Modell mit dem Namen mpg (oder dem von Ihnen festgelegten Namen) angezeigt werden:
Beim Ausführen Ihres Trainingsjobs hat Vertex eine Modellressource für Sie erstellt. Wenn Sie dieses Modell verwenden möchten, 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 einen Namen wie „v1“ ein. Lassen Sie Standard für den Zugriff ausgewählt und klicken Sie auf Weiter.
Lassen Sie die Trafficaufteilung bei 100 und geben Sie für die Mindestanzahl von Computing-Knoten den Wert 1 ein. Wählen Sie unter Maschinentyp den Maschinentyp n1-standard-2 aus. Lassen Sie die restlichen Standardeinstellungen ausgewählt und klicken Sie auf Weiter. Da das Monitoring für dieses Modell nicht aktiviert wird, klicken Sie als Nächstes auf Bereitstellen, um die Endpunktbereitstellung zu starten.
Die Bereitstellung des Endpunkts dauert 10 bis 15 Minuten. Sie werden per E-Mail benachrichtigt, wenn die Bereitstellung abgeschlossen ist. Wenn die Bereitstellung des Endpunkts abgeschlossen ist, wird Folgendes angezeigt: Ein Endpunkt, der unter Ihrer Modellressource bereitgestellt wurde:
Schritt 2: Vorhersagen für das bereitgestellte Modell abrufen
Wir rufen Vorhersagen für unser trainiertes Modell aus einem Python-Notebook mithilfe 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 in einer Zelle Folgendes 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 String endpoint_name oben durch Ihre Projektnummer und Ihren Endpunkt ersetzen. Sie finden Ihre Projektnummer im Projekt-Dashboard unter „Projektnummer“.
Sie finden Ihre Endpunkt-ID hier im Endpunktbereich der Console:
Erstellen Sie abschließend eine Vorhersage für Ihren Endpunkt, indem Sie den folgenden Code kopieren und in einer neuen Zelle 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])
In diesem Beispiel sind bereits normalisierte Werte vorhanden. Das ist das Format, das unser Modell erwartet.
Führen Sie diese Zelle aus. Sie sollten eine Vorhersageausgabe von etwa 25 Kilometern pro Gallone sehen.
🎉 Glückwunsch! 🎉
Sie haben gelernt, wie Sie Vertex AI für Folgendes verwenden:
- Trainieren Sie ein Modell, indem Sie den Trainingscode in einem benutzerdefinierten Container bereitstellen. In diesem Beispiel wurde ein TensorFlow-Modell verwendet. Sie können aber auch ein Modell trainieren, das mit einem beliebigen Framework erstellt wurde, und dabei benutzerdefinierte Container verwenden.
- Stellen Sie ein TensorFlow-Modell mithilfe eines vordefinierten Containers als Teil des Workflows bereit, den Sie für das Training verwendet haben.
- Erstellen Sie einen Modellendpunkt und generieren Sie eine Vorhersage.
Weitere Informationen zu den verschiedenen Teilen 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 verwenden. Wählen Sie in der Workbench-Benutzeroberfläche in der Cloud Console das Notebook und dann Beenden aus.
Wenn Sie das Notizbuch 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 von Ihnen erstellten Endpunkt und wählen Sie dann Modell von Endpunkt zurückziehen aus:
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“:
