1. Omówienie
W tym module dowiesz się, jak analizować metadane z uruchomień Vertex Pipelines za pomocą metadanych Vertex ML.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Użyj pakietu Kubeflow Pipelines SDK, aby utworzyć potok ML, który tworzy zbiór danych w Vertex AI oraz trenuje i wdraża niestandardowy model Scikit-learn w tym zbiorze danych.
- Zapisywanie niestandardowych komponentów potoku, które generują artefakty i metadane
- Porównaj uruchomienia Vertex Pipelines, zarówno w konsoli Cloud, jak i automatycznie
- Śledź historię danych artefaktów wygenerowanych przez potok
- Wysyłanie zapytania o metadane uruchamiania potoku
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 2 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystano najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje ofertę systemów uczących się z całego Google Cloud, tworząc bezproblemowe środowisko programistyczne. Wcześniej modele wytrenowane z użyciem AutoML i modele niestandardowe były dostępne w oddzielnych usługach. Nowa oferta jest łączona w 1 interfejs API wraz z innymi nowymi usługami. Możesz też przenieść istniejące projekty do Vertex AI.
Oprócz usług trenowania i wdrażania modeli Vertex AI oferuje również różne usługi MLOps, w tym Vertex Pipelines, ML Metadata, Monitorowanie modeli i Feature Store. Wszystkie oferty usług Vertex AI możesz zobaczyć na schemacie poniżej.
Tematem tego modułu są potoki Vertex i metadane Vertex ML.
Jeśli chcesz podzielić się opinią na temat Vertex AI, 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ą automatyzować i odtwarzać przepływ 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.
Uruchamianie Cloud Shell
W tym module będziesz pracować w sesji Cloud Shell, która jest tłumaczem poleceń hostowanym przez maszynę wirtualną działającą w chmurze Google. Możesz równie łatwo uruchomić tę sekcję lokalnie na swoim komputerze, ale użycie Cloud Shell zapewni wszystkim dostęp do powtarzalnego środowiska w spójnym środowisku. Po ukończeniu modułu możesz powtórzyć tę sekcję na swoim komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli dopiero zaczynasz korzystać z Cloud Shell, wyświetli się ekran pośredni (w części strony widocznej po przewinięciu) z opisem tej funkcji. W takim przypadku kliknij Dalej (nie zobaczysz go więcej). Tak wygląda ten jednorazowy ekran:
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość czynności z tego ćwiczenia z programowania można wykonać w przeglądarce lub na Chromebooku.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się informacja, że użytkownik jest już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
Uruchom to polecenie w Cloud Shell, aby sprawdzić, czy polecenie gcloud zna Twój projekt:
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
Cloud Shell ma kilka zmiennych środowiskowych, w tym GOOGLE_CLOUD_PROJECT, która zawiera nazwę naszego bieżącego projektu Cloud. Wykorzystamy to w różnych miejscach tego modułu. Możesz go sprawdzić, uruchamiając polecenie:
echo $GOOGLE_CLOUD_PROJECT
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.
Tworzenie zasobnika 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 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
Tworzenie instancji Vertex AI Workbench
W sekcji Vertex AI w konsoli Cloud kliknij Workbench:
W sekcji notatników zarządzanych 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.
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.
- Vertex AI SDK: ten pakiet SDK optymalizuje sposób wywoływania interfejsu Vertex AI API. Wykorzystamy go do uruchomienia naszego potoku w Vertex AI.
Utwórz notatnik w Pythonie i zainstaluj biblioteki
Najpierw w menu Menu z aplikacjami w instancji notatnika utwórz notatnik, wybierając Pythona 3:
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
!pip3 install {USER_FLAG} kfp==1.8.9
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)
Następnie sprawdź, czy wersja pakietu SDK KFP jest prawidłowo zainstalowana. Wartość powinna być większa niż 1,8:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
Następnie sprawdź, czy pakiet SDK Vertex AI jest w wersji 1.6.2 lub nowszej:
!pip list | grep aiplatform
Ustawianie identyfikatora projektu i zasobnika
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"
Importuj biblioteki
Dodaj ten kod, aby zaimportować biblioteki, których będziemy używać w tym ćwiczeniu z programowania:
import matplotlib.pyplot as plt
import pandas as pd
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath
from google.cloud import aiplatform
# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1
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. Tworzenie 3-etapowego potoku z komponentami niestandardowymi
Tematem tego modułu jest zrozumienie metadanych z uruchomień potoku. Aby to zrobić, potrzebujemy potoku do uruchomienia w Vertex Pipelines. Zdefiniujemy tutaj 3-etapowy potok z tymi komponentami niestandardowymi:
get_dataframe: pobieranie danych z tabeli BigQuery i przekształcanie ich w platformę DataFrame biblioteki Pandastrain_sklearn_model: użyj Pandas DataFrame do wytrenowania i wyeksportowania modelu Scikit Learn oraz niektórych wskaźnikówdeploy_model: wdrażanie wyeksportowanego modelu Scikit Learn w punkcie końcowym w Vertex AI
W tym potoku użyjemy zbioru danych fasadowych z uczenia maszynowego UCI pochodzącego 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
Jest to tabelaryczny zbiór danych, a w naszym potoku użyjemy go do wytrenowania, oceny i wdrożenia modelu Scikit-learn, który klasyfikuje ziarno na 1 z 7 typów na podstawie ich cech. Zacznijmy kodować!
Tworzenie komponentów opartych na funkcjach w Pythonie
Za pomocą pakietu SDK KFP możemy tworzyć komponenty oparte na funkcjach w Pythonie. Wykorzystamy to w 3 komponentach w tym potoku.
Pobierz dane BigQuery i przekonwertuj je do pliku CSV
Najpierw utworzymy komponent get_dataframe:
@component(
packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
base_image="python:3.9",
output_component_file="create_dataset.yaml"
)
def get_dataframe(
bq_table: str,
output_data_path: OutputPath("Dataset")
):
from google.cloud import bigquery
import pandas as pd
import os
project_number = os.environ["CLOUD_ML_PROJECT_ID"]
bqclient = bigquery.Client(project=project_number)
table = bigquery.TableReference.from_string(
bq_table
)
rows = bqclient.list_rows(
table
)
dataframe = rows.to_dataframe(
create_bqstorage_client=True,
)
dataframe = dataframe.sample(frac=1, random_state=2)
dataframe.to_csv(output_data_path)
Przyjrzyjmy się bliżej temu, co dzieje się w tym komponencie:
- Dekorator
@componentkompiluje tę funkcję do komponentu podczas uruchamiania potoku. Będziesz go używać za każdym razem, gdy będziesz pisać komponent niestandardowy. - Parametr
base_imageokreśla obraz kontenera, którego będzie używać ten komponent. - Ten komponent będzie używać kilku bibliotek Pythona, które określamy za pomocą parametru
packages_to_install. - Parametr
output_component_filejest opcjonalny i określa plik yaml, w którym ma zostać zapisany skompilowany komponent. Po uruchomieniu komórki powinien być widoczny plik zapisany w instancji notatnika. Jeśli chcesz komuś udostępnić ten komponent, możesz wysłać tej osobie wygenerowany plik yaml i poprosić o wczytanie go z tym kodem:
# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')
- Następnie komponent używa biblioteki klienta BigQuery w języku Python, aby pobrać dane z BigQuery do ramki DataFrame Pandas, a potem tworzy artefakt wyjściowy tych danych w pliku CSV. Zostaną one przekazane jako dane wejściowe do następnego komponentu
Utwórz komponent do trenowania modelu Scikit-learn
W tym komponencie wykorzystamy wygenerowany wcześniej plik CSV i użyjemy go do wytrenowania modelu drzewa decyzyjnego w Scikit-learn. Ten komponent eksportuje wynikowy model Scikit wraz z artefaktem Metrics, który obejmuje dokładność naszego modelu, platformę oraz rozmiar zbioru danych używanego do trenowania:
@component(
packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
base_image="python:3.9",
output_component_file="beans_model_component.yaml",
)
def sklearn_train(
dataset: Input[Dataset],
metrics: Output[Metrics],
model: Output[Model]
):
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from joblib import dump
import pandas as pd
df = pd.read_csv(dataset.path)
labels = df.pop("Class").tolist()
data = df.values.tolist()
x_train, x_test, y_train, y_test = train_test_split(data, labels)
skmodel = DecisionTreeClassifier()
skmodel.fit(x_train,y_train)
score = skmodel.score(x_test,y_test)
print('accuracy is:',score)
metrics.log_metric("accuracy",(score * 100.0))
metrics.log_metric("framework", "Scikit Learn")
metrics.log_metric("dataset_size", len(df))
dump(skmodel, model.path + ".joblib")
Zdefiniuj komponent, aby przesłać i wdrożyć model w Vertex AI
Na koniec nasz ostatni komponent pobierze wytrenowany model z poprzedniego kroku, prześle go do Vertex AI i wdroży w punkcie końcowym:
@component(
packages_to_install=["google-cloud-aiplatform"],
base_image="python:3.9",
output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
model: Input[Model],
project: str,
region: str,
vertex_endpoint: Output[Artifact],
vertex_model: Output[Model]
):
from google.cloud import aiplatform
aiplatform.init(project=project, location=region)
deployed_model = aiplatform.Model.upload(
display_name="beans-model-pipeline",
artifact_uri = model.uri.replace("model", ""),
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
)
endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
vertex_endpoint.uri = endpoint.resource_name
vertex_model.uri = deployed_model.resource_name
W tym przykładzie używamy pakietu SDK Vertex AI, aby przesłać model za pomocą gotowego kontenera do prognozowania. Następnie wdraża model w punkcie końcowym i zwraca identyfikatory URI do zasobów modelu oraz punktu końcowego. W dalszej części tego ćwiczenia w Codelabs dowiesz się, co oznacza zwracanie tych danych w postaci artefaktów.
Definiowanie i kompilowanie potoku
Po zdefiniowaniu 3 komponentów utworzymy definicję potoku. Opisuje to przepływ artefaktów danych wejściowych i wyjściowych między krokami:
@pipeline(
# Default pipeline root. You can override it when submitting the pipeline.
pipeline_root=PIPELINE_ROOT,
# A name for the pipeline.
name="mlmd-pipeline",
)
def pipeline(
bq_table: str = "",
output_data_path: str = "data.csv",
project: str = PROJECT_ID,
region: str = REGION
):
dataset_task = get_dataframe(bq_table)
model_task = sklearn_train(
dataset_task.output
)
deploy_task = deploy_model(
model=model_task.outputs["model"],
project=project,
region=region
)
W ten sposób wygenerujesz plik JSON, którego użyjesz do uruchomienia potoku:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)
Uruchom 2 uruchomienia potoku
Następnie uruchomimy 2 uruchomienia naszego potoku. Najpierw zdefiniujmy sygnaturę czasową, która będzie używana w przypadku identyfikatorów zadań potoku:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Pamiętaj, że uruchomiony potok przyjmuje 1 parametr: bq_table, którego chcemy używać do danych treningowych. To uruchomienie potoku będzie korzystać z mniejszej wersji zbioru danych bean:
run1 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
enable_caching=True,
)
Następnie utwórz kolejne uruchomienie potoku z użyciem większej wersji tego samego zbioru danych.
run2 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
enable_caching=True,
)
Na koniec uruchom wykonania potoku w przypadku obu uruchomień. Najlepiej zrobić to w 2 osobnych komórkach notatnika, aby móc zobaczyć dane wyjściowe każdego uruchomienia.
run1.submit()
Następnie zacznij drugi bieg:
run2.submit()
Po uruchomieniu tej komórki zobaczysz link umożliwiający wyświetlenie każdego potoku w konsoli Vertex AI. Otwórz ten link, aby zobaczyć więcej informacji o swoim potoku:
Gdy się zakończy (na uruchomienie tego potoku zajmuje około 10–15 minut), zobaczysz coś takiego:
Masz już 2 zakończone uruchomienia potoku, możesz więc przyjrzeć się bliżej artefaktom potoku, wskaźnikom i historii danych.
6. Informacje o artefaktach potoku i historii danych
Na wykresie potoku po każdym kroku zobaczysz małe prostokąty. Są to artefakty, czyli dane wyjściowe wygenerowane w danym kroku potoku. Istnieje wiele rodzajów artefaktów. W tym potoku mamy artefakty zbioru danych, wskaźników, modelu i punktu końcowego. Kliknij suwak Rozwiń artefakty u góry interfejsu, aby zobaczyć więcej informacji o każdym z nich:
Kliknięcie artefaktu spowoduje wyświetlenie dodatkowych informacji na jego temat, w tym jego identyfikatora URI. Na przykład kliknięcie artefaktu vertex_endpoint spowoduje wyświetlenie identyfikatora URI, w którym znajdziesz ten wdrożony punkt końcowy w konsoli Vertex AI:
Artefakt Metrics umożliwia przekazywanie niestandardowych danych powiązanych z konkretnym krokiem potoku. W komponencie sklearn_train naszego potoku zarejestrowaliśmy wskaźniki dotyczące dokładności, platformy i rozmiaru zbioru danych naszego modelu. Kliknij artefakt danych, aby wyświetlić te informacje:
Każdy artefakt ma pochodzenie danych, które opisuje inne artefakty, z którymi jest połączony. Kliknij ponownie artefakt vertex_endpoint potoku, a potem kliknij przycisk Wyświetl historię danych:
Otworzy się nowa karta, na której możesz zobaczyć wszystkie artefakty powiązane z wybranym artefaktem. Wykres historii danych będzie wyglądać mniej więcej tak:
Spowoduje to wyświetlenie modelu, wskaźników i zbioru danych powiązanego z tym punktem końcowym. Dlaczego to jest przydatne? Być może masz model wdrożony w wielu punktach końcowych lub potrzebujesz informacji o konkretnym zbiorze danych używanym do trenowania modelu wdrożonego w punkcie końcowym, który oglądasz. Wykres historii danych pomaga zrozumieć każdy artefakt w kontekście reszty systemu ML. Dostęp do historii danych można też uzyskać w sposób zautomatyzowany, co zobaczymy w dalszej części tego ćwiczenia z programowania.
7. Porównanie uruchomień potoku
Jest duża szansa, że ten sam potok będzie uruchamiany wiele razy, z różnymi parametrami wejściowymi lub nowymi danymi albo przez osoby z Twojego zespołu. Do śledzenia uruchomień potoku przydałaby się metoda ich porównywania pod kątem różnych wskaźników. W tej sekcji omówimy 2 sposoby porównywania uruchomień.
Porównywanie uruchomień w interfejsie potoków
W konsoli Cloud przejdź do panelu potoków. Tutaj znajdziesz przegląd każdego uruchomionego przez Ciebie uruchomienia potoku. Sprawdź 2 ostatnie uruchomienia, a następnie kliknij u góry przycisk Porównaj:
Wyświetli się strona, na której możemy porównać parametry wejściowe i dane dla każdego z wybranych uruchomień. W przypadku tych 2 uruchomień zwróć uwagę na różne tabele BigQuery, rozmiary zbiorów danych i wartości dokładności:
Za pomocą tej funkcji interfejsu możesz porównywać więcej niż 2 uruchomienia, a nawet uruchamiać z różnych potoków.
Porównanie uruchomień z pakietem SDK Vertex AI
W przypadku wielu wykonań potoków może Ci się przydać możliwość zautomatyzowanego dostarczania tych danych do porównania, co pozwoli Ci dokładniej analizować szczegóły wskaźników i tworzyć wizualizacje.
Aby uzyskać dostęp do metadanych uruchomienia, możesz użyć metody aiplatform.get_pipeline_df(). Pobieramy tutaj metadane z ostatnich 2 uruchomień tego samego potoku i wczytamy je do DataFrame biblioteki Pandas. Parametr pipeline odnosi się do nazwy, którą nadaliśmy potokowi w jego definicji:
df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df
Po wydrukowaniu DataFrame zobaczysz coś takiego:
W tym miejscu nasz potok został wykonany tylko 2 razy, ale możesz sobie wyobrazić, ile wskaźników można mieć do uzyskania w przypadku większej liczby uruchomień. Następnie utworzymy niestandardową wizualizację w matplotlib, aby zobaczyć zależność między dokładnością naszego modelu a ilością danych używanych do trenowania.
Uruchom to polecenie w nowej komórce notatnika:
plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()
Powinien pojawić się ekran podobny do tego:
8. Wysyłanie zapytań o wskaźniki potoku
Oprócz pobierania DataFrame wszystkich wskaźników potoku warto też automatycznie tworzyć zapytania dotyczące artefaktów utworzonych w systemie ML. Następnie możesz utworzyć panel niestandardowy lub pozwolić innym osobom w organizacji na uzyskanie szczegółowych informacji o konkretnych artefaktach.
Pobieranie wszystkich artefaktów modelu
Aby umożliwić wykonywanie zapytań o artefakty w ten sposób, utworzymy MetadataServiceClient:
API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
client_options={
"api_endpoint": API_ENDPOINT
}
)
Następnie wyślemy do tego punktu końcowego żądanie list_artifacts i przekażemy filtr wskazujący, które artefakty powinny znaleźć się w odpowiedzi. Najpierw pobierzmy wszystkie artefakty w naszym projekcie, które są modelami. Aby to zrobić, uruchom w notatniku to polecenie:
MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)
Otrzymana odpowiedź model_artifacts zawiera możliwy do iteracji obiekt dla każdego artefaktu modelu w projekcie wraz z powiązanymi metadanymi z każdym modelem.
Filtrowanie i wyświetlanie obiektów w DataFrame
Byłoby przydatne, gdybyśmy mogli łatwiej zwizualizować powstałe zapytanie dotyczące artefaktu. Teraz pobierzmy wszystkie artefakty ze stanem LIVE, które zostały utworzone po 10 sierpnia 2021 r. Po uruchomieniu tego żądania wyświetlimy wyniki w ramce DataFrame biblioteki Pandas. Najpierw wykonaj żądanie:
LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
"parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
"filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)
Następnie wyświetl wyniki w DataFrame:
data = {'uri': [], 'createTime': [], 'type': []}
for i in live_artifacts:
data['uri'].append(i.uri)
data['createTime'].append(i.create_time)
data['type'].append(i.schema_title)
df = pd.DataFrame.from_dict(data)
df
Zobaczysz menu podobne do tego:
Oprócz tych, które tu próbowano, możesz też filtrować artefakty na podstawie innych kryteriów.
Moduł ukończony.
🎉 Gratulacje! 🎉
Wiesz już, jak używać Vertex AI do:
- Użyj pakietu Kubeflow Pipelines SDK, aby utworzyć potok ML, który tworzy zbiór danych w Vertex AI oraz trenuje i wdraża niestandardowy model Scikit-learn w tym zbiorze danych.
- Zapisywanie niestandardowych komponentów potoku, które generują artefakty i metadane
- Porównaj uruchomienia Vertex Pipelines, zarówno w konsoli Cloud, jak i automatycznie
- Śledź historię danych artefaktów wygenerowanych przez potok
- Wysyłanie zapytania o metadane uruchamiania 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.
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ń:
Usuwanie punktów końcowych Vertex AI
Aby usunąć wdrożony punkt końcowy, przejdź do sekcji Punkty końcowe w konsoli Vertex AI i kliknij ikonę usuwania:
Usuwanie zasobnika 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ń:
