1. Przegląd
Z tego modułu dowiesz się, jak używać Vertex AI, czyli nowo ogłoszonej przez Google Cloud zarządzanej platformy ML, do tworzenia kompleksowych przepływów pracy związanych z uczeniem maszynowym. Dowiesz się, jak przejść od nieprzetworzonych danych do wdrożonego modelu, i będziesz gotowy(-a) do opracowywania i wdrażania własnych projektów ML w Vertex AI. W tym laboratorium używamy Cloud Shell do utworzenia niestandardowego obrazu Dockera, aby zademonstrować niestandardowe kontenery do trenowania w Vertex AI.
W tym przypadku używamy TensorFlow do kodu modelu, ale możesz go łatwo zastąpić inną platformą.
Czego się dowiesz
Poznasz takie zagadnienia jak:
- Tworzenie i konteneryzowanie kodu trenowania modelu za pomocą Cloud Shell
- Przesyłanie zadania trenowania modelu niestandardowego do Vertex AI
- Wdrożenie wytrenowanego modelu w punkcie końcowym i używanie tego punktu końcowego do uzyskiwania prognoz.
Całkowity koszt przeprowadzenia tego laboratorium w Google Cloud wynosi około 2 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystujemy najnowszą ofertę produktów AI dostępną w Google Cloud. Vertex AI integruje oferty ML w Google Cloud, zapewniając płynne środowisko programistyczne. Wcześniej modele wytrenowane za pomocą AutoML i modele niestandardowe były dostępne w ramach osobnych usług. Nowa oferta łączy je w jeden interfejs API wraz z innymi nowymi usługami. Możesz też przeprowadzić migrację istniejących projektów do Vertex AI. Jeśli masz jakieś uwagi, odwiedź stronę pomocy.
Vertex zawiera wiele różnych narzędzi, które pomagają na każdym etapie procesu ML, co widać na poniższym diagramie. Skupimy się na korzystaniu z usług Vertex Training i Prediction, które są wyróżnione poniżej.
3. Konfigurowanie środowiska
Samodzielne konfigurowanie środowiska
Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. (Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć).
Zapamiętaj identyfikator projektu, czyli unikalną nazwę we wszystkich projektach Google Cloud (podana powyżej nazwa jest już zajęta i nie będzie działać w Twoim przypadku).
Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów Google Cloud.
Ukończenie tego laboratorium nie powinno wiązać się z dużymi kosztami, a nawet z żadnymi. Wykonaj instrukcje z sekcji „Czyszczenie”, w której znajdziesz informacje o tym, jak wyłączyć zasoby, aby uniknąć naliczenia opłat po zakończeniu tego samouczka. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.
Krok 1. Uruchom Cloud Shell
W tym module będziesz pracować w sesji Cloud Shell, czyli w interpreterze poleceń hostowanym przez maszynę wirtualną działającą w chmurze Google. Możesz równie łatwo uruchomić tę sekcję lokalnie na własnym komputerze, ale korzystanie z Cloud Shell zapewnia wszystkim możliwość odtworzenia działania w spójnym środowisku. Po zakończeniu modułu możesz spróbować ponownie wykonać tę sekcję na własnym komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni (część strony widoczna po przewinięciu) z opisem tego środowiska. W takim przypadku kliknij Dalej, a ten ekran nie będzie się już wyświetlać. Ten wyświetlany jednorazowo ekran wygląda tak:
Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym module, a być może wszystkie, możesz wykonać w przeglądarce lub na Chromebooku.
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.
Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:
gcloud auth list
Wynik polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli nie, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Wynik polecenia
Updated property [core/project].
Cloud Shell ma kilka zmiennych środowiskowych, w tym GOOGLE_CLOUD_PROJECT, która zawiera nazwę naszego bieżącego projektu w chmurze. Będziemy go używać w różnych miejscach w tym laboratorium. Możesz to sprawdzić, uruchamiając to polecenie:
echo $GOOGLE_CLOUD_PROJECT
Krok 2. Włącz interfejsy API
W dalszych krokach dowiesz się, gdzie i dlaczego te usługi są potrzebne. 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, potrzebujemy zasobnika pamięci masowej do przechowywania zapisanych zasobów modelu. Aby utworzyć zasobnik, uruchom w terminalu Cloud Shell te polecenia:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Krok 4. Utwórz alias Pythona 3
Kod w tym laboratorium korzysta z języka Python 3. Aby mieć pewność, że podczas uruchamiania skryptów, które utworzysz w tym module, używasz Pythona 3, utwórz alias, uruchamiając w Cloud Shell to polecenie:
alias python=python3
Model, który wytrenujemy i wdrożymy w tym laboratorium, jest oparty na tym samouczku z dokumentacji TensorFlow. W samouczku używany jest zbiór danych Auto MPG z Kaggle do przewidywania spalania pojazdu.
4. Konteneryzacja kodu trenowania
Prześlemy to zadanie trenowania do Vertex AI, umieszczając kod trenowania w kontenerze Dockera i przesyłając ten kontener do Google Container Registry. Dzięki temu możemy wytrenować model utworzony w dowolnej platformie.
Krok 1. Skonfiguruj pliki
Aby rozpocząć, uruchom w terminalu Cloud Shell te polecenia, aby utworzyć pliki potrzebne do kontenera Dockera:
mkdir mpg
cd mpg
touch Dockerfile
mkdir trainer
touch trainer/train.py
Powinien się teraz wyświetlić katalog mpg/ 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 pasku menu w prawym górnym rogu Cloud Shell:
Krok 2. Utwórz plik Dockerfile
Aby skonteneryzować kod, najpierw utworzymy plik Dockerfile. W pliku Dockerfile umieścimy wszystkie polecenia potrzebne do uruchomienia obrazu. Zainstaluje wszystkie używane przez nas biblioteki i skonfiguruje punkt wejścia dla naszego kodu szkoleniowego.
W edytorze plików Cloud Shell otwórz katalog mpg/, a następnie kliknij dwukrotnie, aby otworzyć plik Dockerfile:
Następnie skopiuj do tego pliku ten kod:
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 używa obrazu Dockera Deep Learning Container TensorFlow Enterprise 2.3. Kontenery do deep learningu w Google Cloud mają fabrycznie zainstalowanych wiele popularnych platform ML i narzędzi do nauki o danych. Używana przez nas platforma obejmuje m.in. TF Enterprise 2.3, Pandas i Scikit-learn. Po pobraniu tego obrazu ten plik Dockerfile konfiguruje punkt wejścia dla naszego kodu szkoleniowego, który dodamy w następnym kroku.
Krok 3. Dodaj kod trenowania modelu
Następnie otwórz plik train.py w edytorze Cloud Shell i skopiuj poniższy kod (pochodzi on 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ę swojego zasobnika:
sed -i "s|BUCKET_NAME|$BUCKET_NAME|g" trainer/train.py
Krok 4. Tworzenie i testowanie kontenera 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 w katalogu głównym mpg:
docker build ./ -t $IMAGE_URI
Po utworzeniu kontenera przenieś go do Google Container Registry:
docker push $IMAGE_URI
Aby sprawdzić, czy obraz został przesłany do Container Registry, w sekcji Container Registry w konsoli powinna pojawić się informacja podobna do tej:
Po przeniesieniu kontenera do Container Registry możemy rozpocząć niestandardowe zadanie trenowania modelu.
5. Uruchamianie zadania trenowania w Vertex AI
Vertex oferuje 2 opcje trenowania modeli:
- AutoML trenowanie wysokiej jakości modeli przy minimalnym nakładzie pracy i bez specjalistycznej wiedzy z tej dziedziny.
- Trenowanie niestandardowe: uruchamiaj w chmurze niestandardowe aplikacje do trenowania, korzystając z jednego z gotowych kontenerów Google Cloud lub własnego.
W tym module używamy trenowania niestandardowego za pomocą własnego kontenera niestandardowego w Google Container Registry. Na początek otwórz sekcję Trenowanie w sekcji Vertex w konsoli Cloud:
Krok 1. Rozpocznij zadanie trenowania
Kliknij Utwórz, aby wprowadzić parametry zadania trenowania i wdrożonego modelu:
- W sekcji Zbiór danych wybierz Brak zarządzanego zbioru danych.
- Następnie jako metodę trenowania wybierz Trenowanie niestandardowe (zaawansowane) i kliknij Dalej.
- W polu Nazwa modelu wpisz
mpg(lub dowolną inną nazwę). - Kliknij Dalej.
W kroku Ustawienia kontenera wybierz Kontener niestandardowy:
W pierwszym polu (Obraz kontenera) kliknij Przeglądaj i znajdź kontener, który został 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 używać dostrajania hiperparametrów, więc pozostaw pole Włącz dostrajanie hiperparametrów niezaznaczone i kliknij Dalej.
W sekcji Obliczenia i ceny pozostaw wybrany region bez zmian i wybierz typ maszyny n1-standard-4:
Ponieważ model w tej wersji demonstracyjnej trenuje się szybko, używamy mniejszego typu maszyny.
W kroku Kontener prognozy wybierz Brak kontenera prognozy:
6. Wdrażanie punktu końcowego modelu
W tym kroku utworzymy punkt końcowy dla wytrenowanego modelu. Możemy go użyć do uzyskiwania prognoz dotyczących naszego modelu za pomocą interfejsu Vertex AI API. W tym celu udostępniliśmy wersję wyeksportowanych zasobów wytrenowanego modelu w publicznym zasobniku GCS.
W organizacji często zdarza się, że za tworzenie modelu odpowiada jeden zespół lub jedna osoba, a za jego wdrażanie – inny zespół. W tym artykule pokażemy, jak wziąć wytrenowany model i wdrożyć go w celu prognozowania.
Użyjemy pakietu Vertex AI SDK, aby utworzyć model, wdrożyć go w punkcie końcowym i uzyskać prognozę.
Krok 1. Zainstaluj pakiet Vertex SDK
Aby zainstalować pakiet Vertex AI SDK, uruchom w terminalu Cloud Shell to polecenie:
pip3 install google-cloud-aiplatform --upgrade --user
Za pomocą tego pakietu SDK możemy wchodzić w interakcje 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 do utworzenia zasobu modelu i wdrożenia go w punkcie końcowym. W edytorze plików w Cloud Shell wybierz File (Plik), a następnie New File (Nowy plik):
Nadaj plikowi nazwę 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, cd do katalogu głównego i uruchom utworzony właśnie skrypt Pythona:
cd ..
python3 deploy.py | tee deploy-output.txt
W terminalu będą się pojawiać aktualizacje dotyczące tworzenia zasobów. Potrwa to 10–15 minut. Aby upewnić się, że działa prawidłowo, otwórz sekcję Modele w konsoli Vertex AI:
Kliknij mgp-imported. Powinien pojawić się tworzony punkt końcowy dla tego modelu:
Po zakończeniu wdrażania punktu końcowego w terminalu Cloud Shell zobaczysz log podobny do tego:
Endpoint model deployed. Resource name: projects/your-project-id/locations/us-central1/endpoints/your-endpoint-id
Użyjesz go w następnym kroku, aby uzyskać prognozę dotyczącą wdrożonego punktu końcowego.
Krok 3. Uzyskiwanie prognoz w przypadku wdrożonego punktu końcowego
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 predict 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 uzyskać prognozę z wdrożonego punktu końcowego modelu:
python3 predict.py
Powinna się pojawić zarejestrowana odpowiedź interfejsu API wraz z przewidywanym spalaniem w przypadku naszego testowego przewidywania.
🎉 Gratulacje! 🎉
Dowiedziałeś się, jak używać Vertex AI do:
- Wytrenuj model, podając kod trenowania w kontenerze niestandardowym. W tym przykładzie użyto modelu TensorFlow, ale za pomocą kontenerów niestandardowych możesz wytrenować model utworzony w dowolnej platformie.
- Wdróż model TensorFlow za pomocą gotowego kontenera w ramach tego samego przepływu pracy, którego używasz do trenowania.
- Utwórz punkt końcowy modelu i wygeneruj prognozę.
Więcej informacji o poszczególnych częściach Vertex AI znajdziesz w dokumentacji. Jeśli chcesz zobaczyć wyniki zadania trenowania, które zostało rozpoczęte 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 Storage, w menu nawigacyjnym w konsoli Cloud otwórz Storage, wybierz zasobnik i kliknij Usuń:
