1. Przegląd
Z tego modułu dowiesz się, jak uruchomić zadanie trenowania modelu niestandardowego za pomocą pakietu Kubeflow Pipelines SDK w Vertex Pipelines.
Czego się dowiesz
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 ze zbiorów danych zarządzanych przez Vertex AI i będzie uruchamiane w Vertex AI Training w ramach potoku.
- Uruchamianie zadania prognozowania zbiorczego w Vertex Pipelines
- Używaj gotowych komponentów do interakcji z usługami Vertex AI, które są dostępne w bibliotece
google_cloud_pipeline_components.
Całkowity koszt ukończenia tego laboratorium 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 ML w Google Cloud. Vertex AI integruje usługi ML Google w Google Cloud, zapewniając płynne środowisko programistyczne. Oprócz usług trenowania i wdrażania modeli Vertex AI obejmuje też różne usługi MLOps, w tym Vertex Pipelines (które są głównym tematem tego laboratorium), monitorowanie modeli, Feature Store i inne. Wszystkie usługi Vertex AI znajdziesz na diagramie poniżej.
Jeśli masz jakieś uwagi, odwiedź stronę pomocy.
Dlaczego potoki ML są przydatne?
Zanim przejdziemy do szczegółów, dowiedzmy się, dlaczego warto używać potoku. Wyobraź sobie, że tworzysz przepływ pracy uczenia maszynowego, 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, co może być trudne do zarządzania, jeśli cały przepływ pracy jest traktowany jako monolit. Gdy zaczniesz skalować proces uczenia maszynowego, możesz udostępnić swój przepływ pracy innym członkom zespołu, aby mogli go uruchamiać i dodawać kod. Bez niezawodnego, powtarzalnego procesu może to być trudne. W przypadku potoków każdy krok procesu uczenia maszynowego jest osobnym kontenerem. Dzięki temu możesz opracowywać poszczególne kroki niezależnie od siebie oraz śledzić dane wejściowe i wyjściowe każdego z nich w powtarzalny sposób. Możesz też zaplanować lub wywołać uruchomienie potoku na podstawie innych zdarzeń w środowisku Cloud, np. uruchomić potok, gdy dostępne są nowe dane treningowe.
W skrócie: potoki pomagają upraszczać i odtwarzać przepływy pracy uczenia maszynowego.
3. Konfigurowanie środowiska w chmurze
Aby wykonać to ćwiczenie, musisz mieć projekt w Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z 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 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
W wyniku polecenia powinny pojawić się informacje podobne do tych:
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. Zasobnik musi być regionalny. Używamy tutaj regionu us-central, ale możesz użyć innego regionu (wystarczy go zastąpić w całym tym laboratorium). Jeśli masz już zasobnik, możesz pominąć ten krok.
Aby utworzyć zasobnik, uruchom w terminalu Cloud Shell te polecenia:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Następnie przyznamy kontu usługi obliczeniowej dostęp do tego zasobnika. Dzięki temu Vertex Pipelines będzie mieć 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. Tworzenie instancji Vertex AI Workbench
W sekcji Vertex AI w konsoli Cloud kliknij Workbench:
Następnie w sekcji Notatniki zarządzane przez użytkownika kliknij Nowy notatnik:
Następnie wybierz typ instancji TensorFlow Enterprise 2.3 (z LTS) bez procesorów graficznych:
Użyj opcji domyślnych, a potem kliknij Utwórz.
Krok 5. Otwórz notatnik
Po utworzeniu instancji wybierz Otwórz JupyterLab:
4. Konfigurowanie Vertex Pipelines
Aby korzystać z Vertex Pipelines, musimy zainstalować kilka dodatkowych bibliotek:
- Kubeflow Pipelines: to pakiet SDK, którego użyjemy do utworzenia potoku. Vertex Pipelines obsługuje uruchamianie potoków 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 w Pythonie i zainstaluj biblioteki
Najpierw w menu Launchera w instancji notatnika (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 Launchera, 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 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 ramach tego laboratorium będziesz odwoływać się do identyfikatora projektu w chmurze 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ą, w której będzie przechowywana nazwa zasobnika. Jeśli został utworzony w tym laboratorium, poniższe polecenie zadziała. W przeciwnym razie musisz ustawić to 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 ten kod:
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. Określ stałe
Ostatnią rzeczą, którą musimy zrobić przed utworzeniem potoku, jest zdefiniowanie niektórych stałych zmiennych. PIPELINE_ROOT to ścieżka w Cloud Storage, w której będą zapisywane artefakty utworzone przez nasz potok. Jako regionu używamy tutaj us-central1, ale jeśli podczas tworzenia zasobnika użyto innego regionu, 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 powinna zostać wyświetlona ścieżka do katalogu głównego potoku. Jest to lokalizacja w Cloud Storage, w której będą zapisywane artefakty z potoku. Będzie mieć 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 Dry beans z UCI Machine Learning, pochodzącego z publikacji: KOKLU, M. and OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques” (Wieloklasowa klasyfikacja suchych fasoli przy użyciu technik rozpoznawania obrazów i uczenia maszynowego). W Computers and Electronics in Agriculture, 174, 105507. DOI
W pierwszym kroku potoku utworzymy zarządzany zbiór danych w Vertex AI za pomocą tabeli BigQuery, która zawiera wersję tych danych o ziarnach. Zbiór danych zostanie przekazany jako dane wejściowe do zadania trenowania. W naszym kodzie trenowania będziemy mieć dostęp do zmiennej środowiskowej, aby uzyskać dostęp do tego zarządzanego zbioru danych.
Oto jak skonfigurujemy niestandardowe zadanie trenowania:
- Napisz model Scikit-learn
DecisionTreeClassifier, aby klasyfikować typy fasoli w naszych danych. - Spakuj kod trenowania w kontenerze Dockera i prześlij go do Container Registry.
Dzięki temu będziemy mogli uruchomić zadanie Vertex AI Training bezpośrednio z potoku. Zaczynajmy!
Krok 1. Zdefiniuj kod trenowania w kontenerze Docker
W instancji notatnika otwórz menu z aplikacjami i wybierz Terminal:
Następnie uruchom to polecenie, aby skonfigurować katalog, w którym dodasz kod w kontenerze:
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/ (może być konieczne kliknięcie ikony odświeżania, aby go zobaczyć). W katalogu traincontainer/ zobaczysz te elementy:
+ Dockerfile
+ trainer/
+ train.py
Pierwszym krokiem w procesie kontenerowania kodu jest utworzenie pliku 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. Otwórz utworzony 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 edytowania ich w instancji notatnika, możesz użyć ikony ctrl+s.
Następnie otwórz plik train.py. W tym miejscu dodamy kod szkoleniowy. Skopiuj do pliku train.py ten tekst. Pobiera dane z naszego zarządzanego zbioru danych, umieszcza je w strukturze DataFrame biblioteki pandas, trenuje model Scikit-learn i 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 uruchom to polecenie, aby zastąpić YOUR_GCS_BUCKET w powyższym skrypcie nazwą swojego 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
Możesz też zrobić to ręcznie. Jeśli tak zrobisz, pamiętaj, aby podczas aktualizowania skryptu nie umieszczać w nazwie zasobnika znaku gs://.
Nasz kod trenowania znajduje się teraz w kontenerze Dockera i możemy rozpocząć trenowanie w chmurze.
Krok 2. Prześlij kontener do Container Registry
Po ukończeniu kodu trenowania możemy przesłać go do Google Container Registry. Gdy później skonfigurujemy komponent trenowania w naszym potoku, wskażemy ten kontener w Vertex Pipelines.
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 przenieś kontener do Container Registry:
docker push $IMAGE_URI
Przejdź do sekcji Container Registry w konsoli Cloud, aby sprawdzić, czy kontener jest tam dostępny. 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 zadziałało, musimy podać 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 prognozowania zbiorczego do Cloud Storage
Poniższy plik zawiera po 3 przykłady z każdej klasy w naszym zbiorze danych o fasoli. Poniższy przykład nie zawiera kolumny Class, ponieważ to właśnie będzie prognozować nasz model. Aby utworzyć ten plik CSV lokalnie w notatniku, uruchom to polecenie:
%%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
W następnym kroku, podczas definiowania potoku, odwołamy się do tego pliku.
7. Tworzenie potoku za pomocą gotowych komponentów
Teraz, gdy nasz kod trenowania znajduje się w chmurze, możemy wywołać go z potoku. Zdefiniowany przez nas potok będzie korzystać z 3 gotowych komponentów z zainstalowanej wcześniej biblioteki google_cloud_pipeline_components. Te predefiniowane komponenty upraszczają kod, który musimy napisać, aby skonfigurować potok, i umożliwiają korzystanie z usług Vertex AI, takich jak trenowanie modelu i prognozowanie zbiorcze.
Nasz 3-etapowy potok będzie wykonywać te czynności:
- Tworzenie zarządzanego zbioru danych w Vertex AI
- Uruchamianie zadania trenowania w Vertex AI przy użyciu skonfigurowanego przez nas kontenera niestandardowego
- Uruchamianie zadania prognozy zbiorczej na wytrenowanym modelu klasyfikacji Scikit-learn
Krok 1. Określ potok
Ponieważ używamy gotowych komponentów, możemy skonfigurować cały potok w definicji potoku. Dodaj do komórki notatnika 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. Skompiluj i uruchom potok
Po zdefiniowaniu potoku możesz go skompilować. Spowoduje to wygenerowanie pliku 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, przekazując kilka parametrów specyficznych dla projektu:
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 w konsoli powinny pojawić się logi z linkiem do wyświetlenia uruchomienia potoku:
Przejdź do tego linku. Możesz też otworzyć panel Pipelines. Po zakończeniu potok powinien wyglądać tak:
Uruchomienie tego potoku zajmie 5–10 minut, ale możesz przejść do następnego kroku, zanim się zakończy. W dalszej części dowiesz się więcej o tym, co dzieje się na każdym z tych etapów potoku.
8. Informacje o wykonaniu potoku
Przyjrzyjmy się bliżej każdemu z 3 etapów potoku.
Krok 1 potoku: tworzenie zarządzanego zbioru danych
Pierwszy krok w naszym potoku polega na utworzeniu zarządzanego zbioru danych w Vertex AI. Jeśli w sekcji Potoki w konsoli klikniesz link do tego zbioru danych:
Zbiór danych pojawi się w Vertex AI. Będzie on zawierać link do źródła danych w BigQuery oraz informacje o różnych kolumnach w zbiorze danych. Po przesłaniu zarządzanego zbioru danych do Vertex AI możesz go użyć do trenowania modelu AutoML lub modelu niestandardowego.
W przypadku zadań związanych z modelami niestandardowymi, które korzystają z zarządzanych zbiorów danych, Vertex AI przekazuje specjalne zmienne środowiskowe do zadań trenowania i dzieli dane na zbiory do trenowania i testowania. Wykorzystamy go w następnym kroku potoku.
Krok 2. potoku: trenowanie modelu w Vertex AI Training
Podczas działania zadania trenowania niestandardowego możesz kliknąć, aby wyświetlić logi bezpośrednio w konsoli Vertex Pipelines:
Szczegóły niestandardowego zadania trenowania możesz też sprawdzić w panelu trenowania w Vertex AI. Po zakończeniu zadania trenowania w Vertex AI zostanie utworzony zasób Model. Następnie możemy wdrożyć ten model w punkcie końcowym na potrzeby prognoz online lub utworzyć zadanie prognozowania zbiorczego, co zrobimy w kolejnym kroku potoku.
Krok 3 potoku: uruchamianie zadania prognozowania zbiorczego w naszym modelu
Na koniec nasz potok uzyska 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 przez nas w Cloud Storage. Gdy ten krok potoku zacznie się wykonywać, 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 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 dla konkretnego wystąpienia wraz z klasą, którą przewidział nasz model. W tym przykładzie nasz model uważa, że to ziarno to „HOROZ”.
To już koniec tego laboratorium!
🎉 Gratulacje! 🎉
Dowiedziałeś się, jak używać Vertex AI do:
- Używanie pakietu Kubeflow Pipelines SDK do tworzenia kompleksowych potoków z komponentami niestandardowymi
- Uruchamianie potoków w Vertex Pipelines i rozpoczynanie uruchomień potoków za pomocą pakietu SDK
- Wyświetlanie i analizowanie wykresu Vertex Pipelines w konsoli
- Używanie gotowych komponentów potoku do dodawania usług Vertex AI do potoku
- Planowanie cyklicznych zadań potoku
Więcej informacji o różnych częściach Vertex znajdziesz w dokumentacji.
9. Czyszczenie
Aby uniknąć obciążenia konta opłatami, zalecamy usunięcie zasobów utworzonych w ramach tego modułu.
Krok 1. Zatrzymaj lub usuń instancję notatników
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym module, zalecamy wyłączanie go, gdy nie jest używany. W interfejsie Notebooks w konsoli Cloud wybierz notebooka, a następnie kliknij Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, kliknij Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik Storage, w menu nawigacyjnym w konsoli Cloud otwórz Storage, wybierz zasobnik i kliknij Usuń:
