1. Omówienie
W tym module dowiesz się, jak uruchomić zadanie trenowania modelu niestandardowego za pomocą pakietu Kubeflow Pipelines SDK w Vertex Pipelines.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Tworzenie skalowanych potoków ML za pomocą pakietu Kubeflow Pipelines SDK
- Utwórz i zamknij w kontenerze niestandardowe zadanie trenowania modelu Scikit-learn, które korzysta ze zbiorów danych zarządzanych przez Vertex AI i będzie uruchamiane w ramach trenowania Vertex AI w potoku
- Uruchamianie zadania prognozowania zbiorczego w Vertex Pipelines
- Korzystanie z gotowych komponentów do interakcji z usługami Vertex AI, które są dostępne w bibliotece
google_cloud_pipeline_components.
Łączny koszt przeprowadzenia tego laboratorium w Google Cloud wynosi około 5 USD.
2. Wprowadzenie do Vertex AI
W tym module używamy Vertex AI, czyli kompleksowej zarządzanej platformy ML w Google Cloud. Vertex AI integruje rozwiązania ML od Google w Google Cloud, zapewniając bezproblemowe środowisko programistyczne. Oprócz usług trenowania i wdrażania modeli Vertex AI obejmuje też wiele usług MLOps, takich jak Vertex Pipelines (omawiana w tym module), Model Monitoring, Feature Store i inne. Wszystkie usługi Vertex AI znajdziesz na diagramie poniżej.
Jeśli chcesz podzielić się opinią, odwiedź stronę pomocy.
Dlaczego potoki systemów uczących się są przydatne?
Zanim przejdziemy do szczegółów, wyjaśnijmy, dlaczego warto używać potoku. Wyobraź sobie, że tworzysz przepływ pracy ML, który obejmuje przetwarzanie danych, trenowanie modelu, dostrajanie hiperparametrów, ocenę i wdrażanie modelu. Każdy z tych kroków może mieć różne zależności, które mogą stać się niepraktyczne, jeśli potraktujesz cały proces jako monolit. Gdy zaczniesz wdrażać proces uczenia maszynowego na większą skalę, możesz udostępnić przepływ pracy związanej z uczeniem maszynowym innym członkom zespołu, aby mogli go uruchomić i wnosić poprawki do kodu. Bez niezawodnego, powtarzalnego procesu może to być trudne. W przypadku potoków każdy krok procesu ML jest oddzielnym kontenerem. Dzięki temu możesz opracowywać kroki niezależnie od siebie i śledzić dane wejściowe i wyjściowe z każdego kroku w powtarzalny sposób. Możesz też zaplanować lub uruchomić uruchomienie potoku na podstawie innych zdarzeń w środowisku Cloud, np. uruchomić uruchomienie potoku, gdy dostępne są nowe dane szkoleniowe.
Podsumowanie: potoki pomagają upraszczać i powtarzać przepływy pracy związane z systemami uczącymi się.
3. Konfigurowanie środowiska w chmurze
Aby uruchomić to ćwiczenie, musisz mieć projekt Google Cloud Platform z włączonym rozliczeniem. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
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 też uruchomić tę sekcję lokalnie na swoim komputerze, ale korzystanie z Cloud Shell daje wszystkim dostęp do powtarzalnego środowiska w spójnym środowisku. Po zakończeniu ćwiczeń możesz ponownie wykonać tę sekcję na swoim komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud Console kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli nigdy wcześniej nie korzystałeś(-aś) z Cloud Shell, zobaczysz ekran pośredni (poniżej zgięcia), który wyjaśnia, czym jest to środowisko. W takim przypadku kliknij Dalej (nie zobaczysz go już więcej). Tak wygląda ten jednorazowy ekran:
Uproszczenie i połączenie z Cloud Shell 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ść, jeśli nie wszystkie, czynności w tym CodeLab możesz wykonać w przeglądarce lub na Chromebooku.
Po połączeniu z Cloud Shell powinieneś zobaczyć, że jesteś już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
Aby potwierdzić uwierzytelnianie, uruchom w Cloud Shell to polecenie:
gcloud auth list
W wyjściu polecenia powinna pojawić się informacja podobna do tej:
Aby sprawdzić, czy 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 ustawić je 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 Cloud. Wykorzystamy to w różnych miejscach tego modułu. Aby go wyświetlić, wykonaj jedną z tych czynności:
echo $GOOGLE_CLOUD_PROJECT
Krok 2. Włącz interfejsy API
W kolejnych krokach dowiesz się, gdzie i po co są potrzebne te usługi. Na razie uruchom to polecenie, aby przyznać swojemu 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 udanym przeprowadzeniu operacji 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 Cloud Storage do przechowywania zapisanych komponentów modelu. Zasobnik musi być regionalny. Używamy tutaj regionu us-central, ale możesz użyć innego regionu (po prostu zastąp go w tym module). Jeśli masz już taki folder, możesz pominąć ten krok.
Aby utworzyć zasobnik, uruchom te polecenia w terminalu Cloud Shell:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Następnie damy kontu usługi Compute dostęp do tego zasobnika. Dzięki temu Vertex Pipelines będzie mieć wymagane uprawnienia do zapisywania plików w tym zasobniku. Aby dodać to uprawnienie, uruchom to polecenie:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
Krok 4. Utwórz instancję Vertex AI Workbench
W sekcji Vertex AI w konsoli Cloud kliknij Workbench:
Następnie na karcie Notatniki zarządzane przez użytkownika kliknij Nowy notatnik:
Następnie wybierz typ instancji TensorFlow Enterprise 2.3 (z LTS) bez GPU:
Użyj opcji domyślnych i kliknij Utwórz.
Krok 5. Otwórz notatnik
Po utworzeniu instancji kliknij Otwórz JupyterLab:
4. Konfiguracja Vertex Pipelines
Istnieje kilka dodatkowych bibliotek, które musimy zainstalować, aby używać Vertex Pipelines:
- Kubeflow Pipelines: to pakiet SDK, którego użyjemy do utworzenia naszego potoku. Vertex Pipelines obsługuje uruchamianie ścieżek utworzonych za pomocą Kubeflow Pipelines lub TFX.
- Komponenty potoku Google Cloud: ta biblioteka zawiera gotowe komponenty, które ułatwiają interakcję z usługami Vertex AI z poziomu kroków potoku.
Krok 1. Utwórz notatnik Pythona i zainstaluj biblioteki
Najpierw w menu w interfejsie Notebooka (do którego możesz przejść, klikając ikonę + w lewym górnym rogu notatnika) utwórz notatnik, wybierając Python 3:
Aby otworzyć menu menu, kliknij znak + w lewym górnym rogu instancji notebooka.
Aby zainstalować obie usługi, których użyjemy w tym laboratorium, najpierw ustaw flagę użytkownika w komórce notebooka:
USER_FLAG = "--user"
Następnie w notatniku wykonaj te czynności:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
Po zainstalowaniu tych pakietów musisz ponownie uruchomić jądro:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Na koniec sprawdź, czy pakiety zostały prawidłowo zainstalowane. Wersja pakietu KFP SDK powinna być ≥1.8:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
Krok 2. Ustaw identyfikator projektu i zasobnik
W tym laboratorium będziesz używać identyfikatora projektu Cloud i utworzonego wcześniej zasobnika. Następnie utworzymy zmienne dla każdego z nich.
Jeśli nie znasz identyfikatora projektu, możesz go uzyskać, wykonując te czynności:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
W przeciwnym razie ustaw je tutaj:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Następnie utwórz zmienną do przechowywania nazwy zasobnika. Jeśli utworzysz go w tym module, wykonaj te czynności. W przeciwnym razie musisz go ustawić ręcznie:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Krok 3. Zaimportuj biblioteki
Aby zaimportować biblioteki, których będziemy używać w tym ćwiczeniu, dodaj:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
Krok 4. Zdefiniuj stałe
Ostatnią rzeczą, którą musimy zrobić przed utworzeniem potoku, jest zdefiniowanie stałych zmiennych. PIPELINE_ROOT to ścieżka do Cloud Storage, na której będą zapisywane artefakty utworzone przez nasz potok. Tutaj używamy regionu us-central1, ale jeśli podczas tworzenia zasobnika został użyty inny region, zaktualizuj zmienną REGION w poniższym kodzie:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Po uruchomieniu powyższego kodu powinien wyświetlić się katalog główny potoku. To lokalizacja w Cloud Storage, do której będą zapisywane artefakty z potoku. Numer ten ma format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Konfigurowanie zadania trenowania modelu niestandardowego
Zanim skonfigurujemy potok, musimy napisać kod zadania trenowania modelu niestandardowego. Do wytrenowania modelu użyjemy zbioru danych UCI Machine Learning od: KOKLU, M., OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques” (Wieloklasowa klasyfikacja fasoli w praktyce przy użyciu technik rozpoznawania i uczenia maszynowego). 174, 105507 r. DOI.
Pierwszy krok potoku spowoduje utworzenie w Vertex AI zbioru danych zarządzanego na podstawie tabeli BigQuery zawierającej wersję tych danych. Zbiór danych zostanie przekazany jako dane wejściowe do zadania trenowania. W kodzie trenowania mamy dostęp do zmiennej środowiskowej, która umożliwia dostęp do tego zarządzanego zbioru danych.
Niestandardowe zadanie trenowania ustawimy w ten sposób:
- Napisz model Scikit-learn
DecisionTreeClassifierdo klasyfikowania typów fasoli w danych - Spakuj kod trenowania w kontenerze Dockera i prześlij go do Container Registry
Dzięki temu będziemy mogli uruchomić zadanie trenowania Vertex AI bezpośrednio z naszego potoku. Zaczynajmy!
Krok 1. Zdefiniuj kod trenowania w kontenerze Dockera
W instancji Notebooks otwórz menu i wybierz Terminal:
Następnie uruchom te polecenia, aby skonfigurować katalog, w którym umieścisz kod w kontenerze:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Po wykonaniu tych poleceń po lewej stronie powinien pojawić się katalog o nazwie traincontainer/ (aby go zobaczyć, konieczne może być kliknięcie ikony odświeżania). W katalogu traincontainer/ zobaczysz te informacje:
+ Dockerfile
+ trainer/
+ train.py
Pierwszym krokiem w konteneryzacji kodu jest utworzenie pliku Dockerfile. W pliku Dockerfile uwzględnimy wszystkie polecenia potrzebne do uruchomienia obrazu. Spowoduje to zainstalowanie wszystkich bibliotek, których używamy, i ustawienie punktu wejścia dla kodu treningowego. Otwórz utworzony właśnie plik Dockerfile i dodaj te informacje:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Aby zapisywać pliki podczas ich edytowania w sesji notebooka, możesz użyć ctrl+s.
Następnie otwórz plik train.py. Tutaj dodamy kod treningowy. Skopiuj poniższy kod do pliku train.py. Ta instrukcja pobiera dane z zarządzanego zbioru danych, umieszcza je w ramach struktury DataFrame biblioteki Pandas, trenuje model Scikit-learn, a potem przesyła wytrenowany model do Cloud Storage:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
Następnie wróć do notatnika i wykonaj to polecenie, aby zastąpić YOUR_GCS_BUCKET z powyższego skryptu nazwą Twojego zasobnika Cloud Storage:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
Jeśli wolisz, możesz to zrobić ręcznie. Jeśli to zrobisz, pamiętaj, aby podczas aktualizowania skryptu nie dodawać elementu gs:// do nazwy zasobnika.
Teraz nasz kod trenowania znajduje się w kontenerze Dockera, więc możemy zacząć trenowanie w chmurze.
Krok 2. Prześlij kontener do Container Registry
Gdy kod trenowania jest gotowy, możemy go przekazać do Google Container Registry. Podczas konfigurowania komponentu trenowania w naszym potoku skonfigurujemy ścieżki Vertex tak, aby wskazywały na ten kontener.
Wróć do Terminala i w katalogu głównym traincontainer/ zdefiniuj zmienną z identyfikatorem URI obrazu kontenera w Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Następnie utwórz kontener, uruchamiając to polecenie:
docker build ./ -t $IMAGE_URI
Na koniec prześlij kontener do Container Registry:
docker push $IMAGE_URI
Przejdź do sekcji Rejestr kontenerów w konsoli Cloud, aby sprawdzić, czy Twój kontener się tam znajduje. Będzie to wyglądać mniej więcej tak:
6. Konfigurowanie zadania prognozowania zbiorczego
Ostatnim krokiem naszego potoku będzie uruchomienie zadania prognozowania zbiorczego. Aby to działało, musimy udostępnić w Cloud Storage plik CSV zawierający przykłady, dla których chcemy uzyskać prognozy. Utworzymy ten plik CSV w naszym notatniku i skopiujemy go do Cloud Storage za pomocą narzędzia wiersza poleceń gsutil.
Kopiowanie przykładów zbiorczej prognozy do Cloud Storage
Ten plik zawiera 3 przykłady z każdej klasy w naszym zbiorze danych dotyczących fasoli. Poniższy przykład nie obejmuje kolumny Class, ponieważ tego właśnie oczekuje nasz model. Aby utworzyć ten plik CSV lokalnie w notatniku:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
Następnie skopiuj plik do zasobnika Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
Wspomniamy o tym pliku w następnym kroku podczas tworzenia potoku.
7. Tworzenie potoku za pomocą gotowych komponentów
Teraz, gdy kod trenujący znajduje się w chmurze, możemy go wywołać z potoku. Określony przez nas potok będzie używać 3 wstępnie skompilowanych komponentów z zainstalowanej wcześniej biblioteki google_cloud_pipeline_components. Te wstępnie zdefiniowane komponenty upraszczają kod, który musimy napisać, aby skonfigurować przepływ danych, i umożliwią nam korzystanie z usług Vertex AI, takich jak trenowanie modelu i prognozy zbiorcze.
Oto, co zrobi nasz 3-etapowy potok:
- Tworzenie zarządzanego zbioru danych w Vertex AI
- Uruchom zadanie treningowe w Vertex AI przy użyciu skonfigurowanego przez nas niestandardowego kontenera
- Przeprowadź zadanie prognozowania zbiorczego na wytrenowanym modelu klasyfikacji Scikit-learn.
Krok 1. Określ ścieżkę
Korzystamy z wstępnie skompilowanych komponentów, więc możemy skonfigurować cały potok w definicji potoku. Dodaj do komórki w notatniku te elementy:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
Krok 2. Zkompiluj i uruchom potok
Po zdefiniowaniu potoku możesz go skompilować. Poniższe polecenie wygeneruje plik JSON, którego użyjesz do uruchomienia potoku:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
Następnie utwórz zmienną TIMESTAMP. Użyjemy go w identyfikatorze zadania:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Następnie zdefiniuj zadanie potoku, podając kilka parametrów związanych z projektem:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
Na koniec uruchom zadanie, aby utworzyć nowe wykonanie potoku:
pipeline_job.submit()
Po uruchomieniu tej komórki powinny pojawić się logi z linkiem do wyświetlenia w konsoli uruchomionego potoku:
Przejdź do tego linku. Możesz też uzyskać do niego dostęp, otwierając panel potoku. Po zakończeniu potok powinien wyglądać tak:
Przetwarzanie tego potoku danych może zająć 5–10 minut, ale możesz przejść do następnego kroku przed jego zakończeniem. Dowiesz się więcej o tym, co dzieje się na poszczególnych etapach procesu potoku.
8. Interpretowanie wykonania potoku
Przyjrzyjmy się bliżej każdemu z 3 etapów procesu.
Krok 1. Tworzenie zarządzanego zbioru danych
Pierwszym krokiem w naszym potoku jest utworzenie zarządzanego zbioru danych w Vertex AI. Jeśli w konsoli klikniesz ten link do zbioru danych w sekcji Procesy:
Zbiór danych zobaczysz w Vertex AI. Zawiera on link do źródła danych w BigQuery oraz informacje o różnych kolumnach w Twoim zbiorze danych. Po przesłaniu zarządzanego zbioru danych do Vertex AI możesz go użyć do wytrenowania modelu AutoML lub niestandardowego.
W przypadku zadań modelu niestandardowego, które korzystają z zarządzanych zbiorów danych, Vertex AI przekazuje do zadań trenowania specjalne zmienne środowiskowe i obsługuje podział danych na zbiory do trenowania i testowania. Wykorzystamy to w następnym kroku.
Krok 2. Potok: trenowanie modelu w Vertex AI Training
Podczas wykonywania niestandardowego zadania trenowania możesz kliknąć, aby wyświetlić logi bezpośrednio w konsoli Vertex Pipelines:
Szczegóły niestandardowego zadania treningowego możesz też sprawdzić w panelu Trening w Vertex AI. Po zakończeniu zadania trenowania w Vertex AI zostanie utworzony zasób modelu. Możemy następnie wdrożyć ten model w punkcie końcowym na potrzeby prognoz online lub utworzyć zadanie prognozowania zbiorczego, które zrobimy w następnym kroku potoku.
Krok 3 potoku. Uruchamianie zadania prognozowania zbiorczego w naszym modelu
Na koniec nasz system przetwarzania danych otrzyma prognozy dotyczące przykładów przekazanych w pliku CSV. Po zakończeniu zadania prognozowania zbiorczego Vertex AI zapisze plik CSV w lokalizacji określonej w Cloud Storage. Gdy ten krok potoku zacznie działać, możesz przejść do sekcji Prognozy zbiorcze w konsoli Vertex AI, aby zobaczyć utworzone zadanie.
Po zakończeniu zadania kliknij je, aby wyświetlić adres URL Cloud Storage prognoz zbiorczych:
Kliknij ten link, aby przejść do katalogu Cloud Storage, w którym znajdziesz wyniki prognozowania, a następnie kliknij, aby pobrać jeden z plików prediction.results. W pliku powinny się pojawić wiersze podobne do tych:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
Obejmuje to wartości cech w przypadku konkretnej instancji oraz klasę przewidzianą przez nasz model. W tym przykładzie nasz model uznał, że jest to fasola „HOROZ”.
To już koniec tego modułu.
🎉 Gratulacje! 🎉
Wiesz już, jak używać Vertex AI do:
- Korzystanie z pakietu Kubeflow Pipelines SDK do tworzenia kompleksowych ścieżek z komponentami niestandardowymi
- Uruchamianie potoków w usłudze Vertex Pipelines i uruchamianie ich uruchomień za pomocą pakietu SDK
- Wyświetlanie i analizowanie wykresu Vertex Pipelines w konsoli
- Dodawanie usług Vertex AI do potoku za pomocą gotowych komponentów
- Planowanie cyklicznych zadań potoku
Więcej informacji o różnych elementach Vertex znajdziesz w dokumentacji.
9. Czyszczenie
Aby uniknąć opłat, zalecamy usunięcie zasobów utworzonych w ramach tego modułu.
Krok 1. Zatrzymaj lub usuń instancję Notebooks
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym laboratorium, zalecamy jego wyłączenie, gdy go nie używasz. W interfejsie Notebooków w konsoli Cloud Console wybierz notebook, a następnie wybierz Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, kliknij Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik na dane, w menu nawigacyjnym w konsoli Cloud przejdź do Cloud Storage, wybierz swój zasobnik i kliknij Usuń:
