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 skalowalnych potoków ML za pomocą pakietu Kubeflow Pipelines SDK
- Utwórz i skonteneryzuj niestandardowe zadanie trenowania modelu Scikit-learn, które korzysta z zarządzanych zbiorów danych Vertex AI i będzie uruchamiane w Vertex AI Training w ramach potoku
- Uruchamianie zadania prognozowania zbiorczego w Vertex Pipelines
- Używanie gotowych komponentów do interakcji z usługami Vertex AI dostępnych w bibliotece
google_cloud_pipeline_components
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 5 USD.
2. Wprowadzenie do Vertex AI
W tym module używamy Vertex AI – naszej kompleksowej zarządzanej platformy systemów uczących się w Google Cloud. Vertex AI integruje ofertę systemów uczących się opracowanych przez Google w Google Cloud, tworząc bezproblemowe środowisko programistyczne. Oprócz usług trenowania i wdrażania modeli Vertex AI oferuje również różne usługi MLOps, w tym Vertex Pipelines (które omawiamy w tym module), monitorowanie modeli i Feature Store. Wszystkie oferty usług Vertex AI możesz zobaczyć na schemacie poniżej.
Jeśli masz jakieś uwagi, odwiedź stronę pomocy.
Dlaczego potoki systemów uczących się są przydatne?
Zanim przejdziemy do szczegółów, zastanówmy się, dlaczego warto używać potoku. Załóżmy, ż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ę nieporęczne, jeśli cały przepływ pracy jest traktowany jak monolit. Gdy zaczniesz skalować proces ML, warto udostępnić ten przepływ pracy innym członkom Twojego zespołu, aby mogli go uruchomić i współtworzyć kod. 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 rozwijać kroki niezależnie oraz śledzić w sposób powtarzalny dane wejściowe i wyjściowe z każdego z nich. Możesz też planować lub aktywować uruchomienia potoku na podstawie innych zdarzeń w środowisku Cloud, takich jak uruchamianie uruchomienia potoku po udostępnieniu nowych danych do trenowania.
The tl;dr: potoki pomagają uprościć i odtworzyć przepływy pracy ML.
3. Konfiguracja środowiska Cloud
Aby uruchomić to ćwiczenia z programowania, musisz mieć projekt Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
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
W danych wyjściowych polecenia powinno pojawić się coś takiego:
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. 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ż zasobnik, 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 następujące 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:
W sekcji 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 wybierz 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 uruchomione potoki utworzone w Kubeflow Pipelines i TFX.
- Komponenty Google Cloud Pipeline: ta biblioteka zawiera gotowe komponenty, które ułatwiają interakcję z usługami Vertex AI na etapach potoku.
Krok 1. Utwórz notatnik w Pythonie i zainstaluj biblioteki
Najpierw utwórz notatnik, wybierając Pythona 3 z menu Menu z aplikacjami w instancji notatnika (dostępnego po kliknięciu ikony + w lewym górnym rogu notatnika):
Aby otworzyć menu Menu z aplikacjami, kliknij znak + w lewym górnym rogu instancji notatnika.
Aby zainstalować obie usługi, których będziemy używać w tym module, najpierw ustaw flagę użytkownika w komórce notatnika:
USER_FLAG = "--user"
Następnie uruchom w notatniku to polecenie:
!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 poprawnie zainstalowane. Wersja pakietu SDK KFP powinna być większa niż 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 trakcie tego modułu będziesz się odwoływać do 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ć, uruchamiając to polecenie:
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 go 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 ten moduł został utworzony w tym module, podane niżej rozwiązania będą skuteczne. W przeciwnym razie musisz go ustawić ręcznie:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Krok 3. Zaimportuj biblioteki
Dodaj ten kod, aby zaimportować biblioteki, których będziemy używać w tym ćwiczeniu z programowania:
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ą, jaką musimy zrobić przed utworzeniem potoku, jest zdefiniowanie zmiennych stałych. PIPELINE_ROOT to ścieżka w Cloud Storage, w której będą zapisywane artefakty utworzone przez nasz potok. Używamy tu regionu us-central1, ale jeśli podczas tworzenia zasobnika używasz innego regionu, zaktualizuj zmienną REGION w tym 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 jest lokalizacja w Cloud Storage, w której będą zapisywane artefakty z Twojego potoku. Będzie w formacie 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 fazowych bean opracowanych przez UCI Machine Learning, pochodzących 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 r., 105507, s. DOI
W pierwszym kroku potoku utworzymy zarządzany zbiór danych w Vertex AI z użyciem tabeli BigQuery zawierającej wersję tych danych ziarna. Zbiór danych zostanie przekazany jako dane wejściowe do naszego zadania trenowania. W kodzie trenowania będziemy mieć dostęp do zmiennej środowiskowej umożliwiającej dostęp do tego zarządzanego zbioru danych.
Niestandardowe zadanie trenowania ustawimy w ten sposób:
- Napisz model
DecisionTreeClassifierScikit-learn, aby sklasyfikować typy ziaren w naszych danych - Spakuj kod trenowania do kontenera Dockera i wypchnij go do Container Registry
Dzięki temu będziemy mogli uruchomić zadanie Vertex AI Training bezpośrednio z naszego potoku. Zaczynajmy!
Krok 1. Zdefiniuj kod trenowania w kontenerze Dockera
W instancji Notatniki otwórz Menu z aplikacjami i wybierz Terminal:
Następnie uruchom to polecenie, aby skonfigurować katalog, w którym dodasz skonteneryzowany kod:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Po uruchomieniu tych poleceń po lewej stronie powinien pojawić się katalog o nazwie traincontainer/ (aby go wyświetlić, może być konieczne kliknięcie ikony odświeżania). W katalogu traincontainer/ znajdziesz:
+ Dockerfile
+ trainer/
+ train.py
Pierwszym krokiem w konteneryzacji kodu jest utworzenie pliku 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. Otwórz utworzony właśnie plik Dockerfile i dodaj do niego ten plik:
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 instancji notatnika, możesz użyć polecenia ctrl+s.
Następnie otwórz plik train.py. Tutaj dodamy kod trenowania. Skopiuj poniższy kod do pliku train.py. Powoduje to pobranie danych z zarządzanego zbioru danych, umieszczenie ich w ramach DataFrame Pandas, trenowanie modelu Scikit-learn i przesłanie wytrenowanego modelu 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. Wypchnij kontener do Container Registry
Gdy kod trenowania jest gotowy, możemy go przekazać do Google Container Registry. Później, gdy skonfigurujemy komponent trenowania naszego potoku, wskażemy ten kontener Vertex Pipelines.
Wróć do Terminala i z poziomu głównego katalogu katalogu 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 wypchnij kontener do Container Registry:
docker push $IMAGE_URI
Otwórz sekcję Container Registry w konsoli Cloud, aby sprawdzić, czy znajduje się w nim Twój kontener. 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.
Kopiuję przykłady prognoz zbiorczych do Cloud Storage
Ten plik zawiera 3 przykłady z każdej klasy w zbiorze danych bean. Przykład poniżej nie obejmuje kolumny Class, ponieważ tego właśnie model przewiduje nasz model. Uruchom to polecenie, aby utworzyć 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 z gotowymi komponentami
Teraz gdy kod trenowania znajduje się w chmurze, możemy go wywoływać z potoku. Zdefiniowany przez nas potok będzie korzystać z 3 gotowych komponentów z zainstalowanej wcześniej biblioteki google_cloud_pipeline_components. Te wstępnie zdefiniowane komponenty upraszczają kod, który musimy napisać, aby skonfigurować nasz potok, i pozwolą nam korzystać z usług Vertex AI, takich jak trenowanie modeli i prognozowanie zbiorcze.
Oto, co zrobi nasz 3-etapowy potok:
- Tworzenie zarządzanego zbioru danych w Vertex AI
- Uruchom zadanie treningowe w Vertx AI przy użyciu skonfigurowanego przez nas niestandardowego kontenera
- Uruchom zbiorcze zadanie prognozowania na naszym wytrenowanym modelu klasyfikacji Scikit-learn
Krok 1. Zdefiniuj potok
Ponieważ korzystamy z gotowych komponentów, możemy skonfigurować cały potok w jego definicji. Do komórki notatnika dodaj:
@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. Skompiluj i uruchom potok
Po zdefiniowaniu potoku możesz go skompilować. W ten sposób wygenerujesz 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. Wykorzystamy to 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 wyświetlić się logi z linkiem umożliwiającym wyświetlenie uruchomionego potoku w konsoli:
Otwórz odpowiedni link. Możesz też uzyskać do niego dostęp, otwierając panel potoku. Po zakończeniu potok powinien wyglądać tak:
Uruchomienie tego potoku zajmie 5–10 minut, ale zanim się zakończy, możesz przejść do następnego kroku. Dowiesz się więcej o tym, co dzieje się na poszczególnych etapach procesu potoku.
8. Informacje o wykonaniu potoku
Przyjrzyjmy się bliżej każdemu z 3 etapów procesu sprzedaży.
Krok 1 potoku. Tworzenie zarządzanego zbioru danych
Pierwszym krokiem w naszym potoku jest utworzenie zarządzanego zbioru danych w Vertex AI. Jeśli klikniesz w sekcji Potoki w konsoli ten link do zbioru danych:
Zobaczysz zbiór danych w Vertex AI, który zawiera 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 modelu 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 je w kolejnym kroku procesu.
Etap 2 potoku. Wytrenowanie modelu w Vertex AI Training
Gdy niestandardowe zadanie trenowania jest uruchomione, możesz kliknąć, aby wyświetlić logi bezpośrednio w konsoli Vertex Pipelines:
Szczegóły tego zadania trenowania możesz też wyświetlić w panelu treningowym 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 potok otrzyma prognozy na przykładach przesłanych w pliku CSV. Po zakończeniu zadania prognozowania zbiorczego Vertex AI zapisze plik CSV w lokalizacji podanej 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.
Kliknij zadanie po zakończeniu, aby wyświetlić adres URL prognoz zbiorczych w Cloud Storage:
Kliknij ten link, aby przejść do katalogu Cloud Storage, w którym znajdziesz wyniki prognozy, a następnie kliknij, aby pobrać jeden z plików prediction.results. W pliku powinny być widoczne 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 konkretnej instancji wraz z klasą prognozowaną przez nasz model. W tym przykładzie nasz model uznał, że to „HOROZ”. fasola.
Moduł ukończony.
🎉 Gratulacje! 🎉
Wiesz już, jak używać Vertex AI do:
- Użyj pakietu Kubeflow Pipelines SDK do tworzenia kompleksowych potoków z komponentami niestandardowymi
- Uruchamiaj potoki w Vertex Pipelines i uruchamiaj je za pomocą pakietu SDK
- Wyświetlanie i analizowanie wykresu Vertex Pipelines w konsoli
- Dodaj do potoku usługi Vertex AI z użyciem gotowych komponentów potoku
- Zaplanuj cykliczne zadania potoku
Więcej informacji o różnych częściach Vertex znajdziesz w dokumentacji.
9. Czyszczenie
Aby uniknąć opłat, zalecamy usunięcie zasobów utworzonych w tym module.
Krok 1. Zatrzymaj lub usuń instancję Notatników
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym module, zalecamy wyłączenie go, gdy nie jest używany. W interfejsie notatników w konsoli Cloud wybierz notatnik, a następnie kliknij Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, wybierz Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik na dane, w menu nawigacyjnym w konsoli Google Cloud otwórz Cloud Storage, wybierz swój zasobnik i kliknij Usuń:
