1. Übersicht
In diesem Lab nutzen Sie Vertex AI, um ein TensorFlow-Modell mithilfe von Code in einem benutzerdefinierten Container zu trainieren und bereitzustellen.
Wir verwenden hier TensorFlow für den Modellcode, können es aber ganz einfach durch ein anderes Framework ersetzen.
Lerninhalte
Die folgenden Themen werden behandelt:
- Modelltrainingscode in Vertex Workbench erstellen und containerisieren
- Benutzerdefinierten Modelltrainingsjob an Vertex AI senden
- Trainiertes Modell auf einem Endpunkt bereitstellen und diesen für Vorhersagen verwenden
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud belaufen sich auf etwa 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: 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. 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 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. Damit erstellen Sie einen Container für Ihren benutzerdefinierten Trainingsjob.
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 neueste 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 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 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 zum Containerisieren unseres Codes besteht darin, ein Dockerfile zu erstellen. In unser Dockerfile geben wir alle Befehle ein, die zum Ausführen des Images erforderlich sind. Dadurch werden alle verwendeten Bibliotheken installiert und der Einstiegspunkt für unseren Trainingscode eingerichtet. Erstellen Sie im 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"]
Dieses Dockerfile verwendet das Deep Learning Container TensorFlow Enterprise 2.3-Docker-Image. In den Deep-Learning-Containern in Google Cloud sind viele gängige ML- und Data-Science-Frameworks vorinstalliert. Wir verwenden TF Enterprise 2.3, Pandas, Scikit-learn und andere. Nach dem Herunterladen dieses Images wird in 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 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 in Ihrem 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: Trainingscode für das Modell 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
Im mpg/-Verzeichnis sollte jetzt Folgendes zu sehen sein:
+ Dockerfile
+ trainer/
+ train.py
Öffnen Sie als Nächstes die Datei train.py, die Sie gerade erstellt haben, und kopieren Sie den unten stehenden Code. Dieser Code wurde aus der Anleitung 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 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 ordnungsgemäß 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 der Container in Container Registry übertragen wurde, können Sie einen Trainingsjob für ein benutzerdefiniertes 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 ML-Kenntnissen 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 nutzen wir das benutzerdefinierte Training über unseren eigenen benutzerdefinierten Container in Google Container Registry. Gehen Sie zuerst im Vertex-Bereich der Cloud Console zum Abschnitt Models (Modelle):
Schritt 1: Trainingsjob starten
Klicken Sie auf Erstellen, um die Parameter für den 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 bei Modellname mpg oder einen anderen Namen für Ihr Modell 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 restlichen Felder leer und klicken Sie auf Weiter.
Da wir in dieser Anleitung keine Hyperparameter-Abstimmung verwenden, lassen Sie das Kästchen "Hyperparameter-Abstimmung aktivieren" nicht angeklickt und klicken Sie auf Weiter.
Lassen Sie die ausgewählte Region unter Computing und Preise unverändert und wählen Sie als Maschinentyp n1-standard-4 aus:
Lassen Sie die Felder für den 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.
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 den exportierten Modell-Assets suchen soll. Im Rahmen unserer Trainingspipeline erstellt Vertex eine Modellressource anhand dieses Asset-Pfads. 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. Zur Verwendung dieses Modells 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.
Belassen Sie Traffic-Aufteilung bei 100 und geben Sie für Mindestanzahl von Rechenknoten 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 erhalten eine E-Mail, wenn die Bereitstellung abgeschlossen ist. Wenn die Bereitstellung des Endpunkts abgeschlossen ist, wird Folgendes angezeigt, darunter ein Endpunkt, der unter Ihrer Modellressource bereitgestellt ist:
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 den folgenden Befehl 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 Ihrem Notebook hinzu, um das SDK zu importieren und einen Verweis auf den soeben 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"
)
Du musst zwei Werte im obigen String endpoint_name durch deine Projektnummer und deinen Endpunkt ersetzen. Ihre Projektnummer finden Sie in Ihrem Projekt-Dashboard. Dort finden Sie den Wert der 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 mit Vertex AI Folgendes tun können:
- 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 Notebook, das Sie in diesem Lab erstellt haben, weiter verwenden möchten, sollten Sie es deaktivieren, wenn Sie es nicht verwenden. Wählen Sie in der Workbench-UI in der Cloud Console das Notebook und dann Beenden aus.
Wenn Sie das Notizbuch vollständig löschen möchten, klicken Sie rechts oben auf die Schaltfläche Löschen.
Wenn Sie den von Ihnen bereitgestellten Endpunkt löschen möchten, gehen Sie in der Vertex AI-Konsole zum Abschnitt Endpunkte, klicken Sie auf den von Ihnen erstellten Endpunkt und wählen Sie dann Bereitstellung des Modells am Endpunkt aufheben aus:
Wenn Sie den Speicher-Bucket löschen möchten, klicken Sie in der Cloud Console im Navigationsmenü auf „Speicher“, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
