Informacje o tym ćwiczeniu (w Codelabs)
1. Omówienie
W tym module dowiesz się, jak używać Vertex AI – niedawno wprowadzonej przez Google Cloud zarządzanej platformy systemów uczących się – do tworzenia kompleksowych przepływów pracy ML. Dowiesz się, jak przejść od nieprzetworzonych danych do wdrożonego modelu. Te warsztaty pozwolą Ci też tworzyć i wdrażać własne projekty ML przy użyciu Vertex AI. W tym module używamy Cloud Shell do utworzenia niestandardowego obrazu Dockera, aby zademonstrować niestandardowe kontenery do trenowania w Vertex AI.
Chociaż używamy tutaj kodu modelu TensorFlow, możesz go łatwo zastąpić inną platformą.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Kompilowanie i konteneryzowanie kodu trenowania modelu za pomocą Cloud Shell
- Przesyłanie zadania trenowania modelu niestandardowego do Vertex AI
- Wdróż w punkcie końcowym wytrenowany model i użyj tego punktu końcowego do otrzymywania prognoz
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 2 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystano najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje ofertę systemów uczących się z całego Google Cloud, tworząc bezproblemowe środowisko programistyczne. Wcześniej modele wytrenowane z użyciem AutoML i modele niestandardowe były dostępne w oddzielnych usługach. Nowa oferta jest łączona w 1 interfejs API wraz z innymi nowymi usługami. Możesz też przenieść istniejące projekty do Vertex AI. Jeśli masz jakieś uwagi, odwiedź stronę pomocy.
Vertex oferuje wiele różnych narzędzi, które mogą pomóc Ci na każdym etapie przepływu pracy ML, jak widać na tym schemacie. Skupimy się na korzystaniu z Vertex Training i Prediction (wyróżnionych poniżej).
3. Skonfiguruj środowisko
Samodzielne konfigurowanie środowiska
Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
Zapamiętaj identyfikator projektu, unikalną nazwę we wszystkich projektach Google Cloud (powyższa nazwa jest już zajęta i nie będzie Ci odpowiadać).
Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Google Cloud.
Ukończenie tego ćwiczenia z programowania nie powinno kosztować zbyt wiele. Postępuj zgodnie z instrukcjami podanymi w sekcji „Czyszczenie” W tym samouczku znajdziesz wskazówki, jak wyłączyć zasoby, aby uniknąć naliczania opłat. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.
Krok 1. Uruchom Cloud Shell
W tym module będziesz pracować w sesji Cloud Shell, która jest tłumaczem poleceń hostowanym przez maszynę wirtualną działającą w chmurze Google. Możesz równie łatwo uruchomić tę sekcję lokalnie na swoim komputerze, ale użycie Cloud Shell zapewni wszystkim dostęp do powtarzalnego środowiska w spójnym środowisku. Po ukończeniu modułu możesz powtórzyć tę sekcję na swoim komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli dopiero zaczynasz korzystać z Cloud Shell, wyświetli się ekran pośredni (w części strony widocznej po przewinięciu) z opisem tej funkcji. W takim przypadku kliknij Dalej (nie zobaczysz go więcej). Tak wygląda ten jednorazowy ekran:
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość czynności z tego ćwiczenia z programowania można wykonać w przeglądarce lub na Chromebooku.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się informacja, że użytkownik jest już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
Uruchom to polecenie w Cloud Shell, aby sprawdzić, czy polecenie gcloud zna Twój projekt:
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
Cloud Shell ma kilka zmiennych środowiskowych, w tym GOOGLE_CLOUD_PROJECT, która zawiera nazwę naszego bieżącego projektu Cloud. Wykorzystamy to w różnych miejscach tego modułu. Możesz go sprawdzić, uruchamiając polecenie:
echo $GOOGLE_CLOUD_PROJECT
Krok 2. Włącz interfejsy API
W późniejszych krokach zobaczysz, gdzie te usługi są potrzebne (i dlaczego). Na razie uruchom to polecenie, aby przyznać projektowi dostęp do usług Compute Engine, Container Registry i Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Powinien wyświetlić się komunikat o powodzeniu podobny do tego:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Krok 3. Utwórz zasobnik Cloud Storage
Aby uruchomić zadanie trenowania w Vertex AI, potrzebujesz zasobnika na dane, w którym będą przechowywane zapisane zasoby modelu. Aby utworzyć zasobnik, uruchom te polecenia w terminalu Cloud Shell:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Krok 4. Alias Python 3
Kod w tym module używa języka Python 3. Aby mieć pewność, że podczas uruchamiania skryptów utworzonych w tym module będziesz używać języka Python 3, utwórz alias, uruchamiając w Cloud Shell to polecenie:
alias python=python3
Model, który będziemy trenować i udostępniać w tym module, powstał na podstawie tego samouczka z Dokumentów TensorFlow. Samouczek wykorzystuje zbiór danych Auto SpG firmy Kaggle do przewidywania spalania pojazdu.
4. Konteneryzowanie kodu trenowania
Prześlemy to zadanie treningowe do Vertex, umieszczając kod trenowania w kontenerze Dockera i wypchając ten kontener do Google Container Registry. Korzystając z tej metody, możemy wytrenować model utworzony na podstawie dowolnej platformy.
Krok 1. Skonfiguruj pliki
Na początek w terminalu w Cloud Shell uruchom następujące polecenia, aby utworzyć pliki potrzebne dla kontenera Dockera:
mkdir mpg
cd mpg
touch Dockerfile
mkdir trainer
touch trainer/train.py
W usłudze mpg/ powinien być teraz dostępny katalog podobny do tego:
+ Dockerfile
+ trainer/
+ train.py
Aby wyświetlić i edytować te pliki, użyjemy wbudowanego edytora kodu Cloud Shell. Możesz przełączać się między edytorem a terminalem, klikając przycisk na prawym górnym pasku menu w Cloud Shell:
Krok 2. Utwórz plik Dockerfile
Aby skonteneryzować kod, najpierw utworzymy plik Dockerfile. W pliku Dockerfile znajdą się wszystkie polecenia potrzebne do uruchomienia obrazu. Zainstaluje wszystkie używane biblioteki i skonfiguruje punkt wejścia dla kodu trenowania.
W edytorze plików Cloud Shell otwórz katalog mpg/ i kliknij dwukrotnie, aby otworzyć plik Dockerfile:
Następnie skopiuj do tego pliku te dane:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-3
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"]
Ten plik Dockerfile wykorzystuje obraz Dockera TensorFlow Enterprise 2.3. Kontenery do deep learningu w Google Cloud mają wstępnie zainstalowane wiele popularnych platform do uczenia maszynowego i platformy do badania danych. Używamy m.in. TF Enterprise 2.3, Pandas czy Scikit-learn. Po pobraniu tego obrazu plik Dockerfile konfiguruje punkt wejścia dla kodu trenowania, który dodamy w następnym kroku.
Krok 3. Dodaj kod trenowania modelu
W edytorze Cloud Shell otwórz plik train.py i skopiuj poniższy kod (został on zaczerpnięty z samouczka w dokumentacji TensorFlow).
# This will be replaced with your bucket name after running the `sed` command in the tutorial
BUCKET = "BUCKET_NAME"
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.
"""
"""Import it using pandas"""
dataset_path = "https://storage.googleapis.com/io-vertex-codelab/auto-mpg.csv"
dataset = pd.read_csv(dataset_path, na_values = "?")
dataset.tail()
"""### 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')
Po skopiowaniu powyższego kodu do pliku mpg/trainer/train.py wróć do terminala w Cloud Shell i uruchom to polecenie, aby dodać do pliku nazwę własnego zasobnika:
sed -i "s|BUCKET_NAME|$BUCKET_NAME|g" trainer/train.py
Krok 4. Utwórz i przetestuj kontener lokalnie
W terminalu uruchom to polecenie, aby zdefiniować zmienną z identyfikatorem URI obrazu kontenera w Google Container Registry:
IMAGE_URI="gcr.io/$GOOGLE_CLOUD_PROJECT/mpg:v1"
Następnie utwórz kontener, uruchamiając to polecenie z poziomu głównego katalogu mpg:
docker build ./ -t $IMAGE_URI
Po utworzeniu kontenera wypchnij go do Google Container Registry:
docker push $IMAGE_URI
Jeśli chcesz sprawdzić, czy obraz został przekazany do Container Registry, po otwarciu sekcji Container Registry w konsoli zobaczysz coś takiego:
Po przekazaniu kontenera do Container Registry możemy teraz rozpocząć zadanie trenowania modelu niestandardowego.
5. Uruchamianie zadania trenowania w Vertex AI
Vertex udostępnia 2 opcje trenowania modeli:
- AutoML: trenuj wysokiej jakości modele przy minimalnym nakładzie pracy i bez specjalistycznej wiedzy z zakresu systemów uczących się.
- Trenowanie niestandardowe: uruchamiaj niestandardowe aplikacje treningowe w chmurze za pomocą jednego z gotowych kontenerów Google Cloud lub użyj własnego.
W tym module używamy trenowania niestandardowego z wykorzystaniem własnego niestandardowego kontenera w Google Container Registry. Zacznij od sekcji Trenowanie w sekcji Vertex w konsoli Cloud:
Krok 1. Rozpoczynanie pracy
Kliknij Utwórz, aby wpisać parametry zadania trenowania i wdrożonego modelu:
- W sekcji Zbiór danych wybierz Brak zarządzanego zbioru danych.
- Następnie wybierz Trenowanie niestandardowe (zaawansowane) jako metodę trenowania i kliknij Dalej.
- W polu Nazwa modelu wpisz
mpg(lub inną nazwę modelu) - Kliknij Dalej.
W kroku „Ustawienia kontenera” wybierz Kontener niestandardowy:
W pierwszym polu (obraz kontenera) kliknij Przeglądaj i znajdź kontener przesłany do Container Registry. Powinna wyglądać mniej więcej tak:
Pozostałe pola pozostaw puste i kliknij Dalej.
W tym samouczku nie będziemy stosować dostrajania hiperparametrów, więc pole Włącz dostrajanie hiperparametrów pozostaw odznaczone i kliknij Dalej.
W sekcji Obliczenia i ceny pozostaw wybrany region bez zmian i jako typ maszyny wybierz n1-standard-4:
Model w tej wersji demonstracyjnej szybko trenuje, więc korzystamy z maszyny mniejszego typu.
W kroku Kontener prognozy wybierz Brak kontenera prognozy:
6. Wdróż punkt końcowy modelu
W tym kroku utworzymy punkt końcowy dla wytrenowanego modelu. Możemy użyć tych informacji, aby uzyskać prognozy w naszym modelu za pomocą interfejsu Vertex AI API. Aby to zrobić, udostępniliśmy wersję wyeksportowanych zasobów wytrenowanego modelu w publicznym zasobniku GCS.
W organizacji często jeden zespół lub osoba zajmuje się tworzeniem modelu, a inny zespół zajmuje się jego wdrażaniem. Omówimy krok po kroku, jak utworzyć wytrenowany model i wdrożyć go na potrzeby prognozowania.
Za pomocą pakietu SDK Vertex AI utworzysz model, wdrożymy go w punkcie końcowym i pobierzemy prognozę.
Krok 1. Zainstaluj pakiet Vertex SDK
W terminalu Cloud Shell uruchom to polecenie, aby zainstalować pakiet Vertex AI SDK:
pip3 install google-cloud-aiplatform --upgrade --user
Możemy używać tego pakietu SDK do interakcji z wieloma różnymi częściami Vertex.
Krok 2. Utwórz model i wdróż punkt końcowy
Następnie utworzymy plik Pythona i użyjemy pakietu SDK, aby utworzyć zasób modelu i wdrożyć go w punkcie końcowym. W edytorze plików w Cloud Shell wybierz File (Plik), a następnie New File (Nowy plik):
Nazwij plik deploy.py. Otwórz ten plik w edytorze i skopiuj ten kod:
from google.cloud import aiplatform
# Create a model resource from public model assets
model = aiplatform.Model.upload(
display_name="mpg-imported",
artifact_uri="gs://io-vertex-codelab/mpg-model/",
serving_container_image_uri="gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-3:latest"
)
# Deploy the above model to an endpoint
endpoint = model.deploy(
machine_type="n1-standard-4"
)
Następnie wróć do terminala w Cloud Shell, wróć do katalogu głównego (cd) i uruchom ten skrypt Pythona:
cd ..
python3 deploy.py | tee deploy-output.txt
W miarę tworzenia zasobów zobaczysz w terminalu aktualizacje. Potrwa to 10–15 minut. Aby sprawdzić, czy działa prawidłowo, w Vertex AI otwórz sekcję Modele w konsoli:
Kliknij mgp-imported. Powinien wyświetlić się punkt końcowy dla tworzonego modelu:
Po zakończeniu wdrażania punktu końcowego w terminalu Cloud Shell zobaczysz coś takiego jak ten dziennik:
Endpoint model deployed. Resource name: projects/your-project-id/locations/us-central1/endpoints/your-endpoint-id
Użyjesz go w następnym kroku do uzyskania prognozy dotyczącej wdrożonego punktu końcowego.
Krok 3. Uzyskaj prognozy we wdrożonym punkcie końcowym
W edytorze Cloud Shell utwórz nowy plik o nazwie predict.py:
Otwórz predict.py i wklej do niego ten kod:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="ENDPOINT_STRING"
)
# A test example we'll send to our model for prediction
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])
Następnie wróć do Terminala i wpisz to polecenie, aby zastąpić ENDPOINT_STRING w pliku prognozy własnym punktem końcowym:
ENDPOINT=$(cat deploy-output.txt | sed -nre 's:.*Resource name\: (.*):\1:p' | tail -1)
sed -i "s|ENDPOINT_STRING|$ENDPOINT|g" predict.py
Teraz uruchom plik predict.py, aby pobrać prognozę z punktu końcowego wdrożonego modelu:
python3 predict.py
Powinna wyświetlić się odpowiedź interfejsu API wraz z przewidywanym zużyciem paliwa dla naszej prognozy testowej.
🎉 Gratulacje! 🎉
Wiesz już, jak używać Vertex AI do:
- Wytrenuj model, przesyłając kod trenowania w kontenerze niestandardowym. W tym przykładzie użyto modelu TensorFlow, ale możesz wytrenować model utworzony za pomocą dowolnej platformy, korzystając z niestandardowych kontenerów.
- Wdróż model TensorFlow przy użyciu gotowego kontenera w ramach tego samego przepływu pracy co podczas trenowania.
- Utwórz punkt końcowy modelu i wygeneruj prognozę.
Więcej informacji o różnych częściach Vertex AI znajdziesz w dokumentacji. Jeśli chcesz zobaczyć wyniki zadania trenowania rozpoczętego w kroku 5, przejdź do sekcji trenowania w konsoli Vertex.
7. Czyszczenie
Aby usunąć wdrożony punkt końcowy, przejdź do sekcji Punkty końcowe w konsoli Vertex i kliknij ikonę usuwania:
Aby usunąć zasobnik na dane, w menu nawigacyjnym w konsoli Cloud przejdź do Cloud Storage, wybierz swój zasobnik i kliknij Usuń:
