1. Przegląd
Z tego modułu dowiesz się, jak analizować metadane z uruchomień Vertex Pipelines za pomocą Vertex ML Metadata.
Czego się dowiesz
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 na tym zbiorze danych niestandardowy model Scikit-learn
- Tworzenie niestandardowych komponentów potoku, które generują artefakty i metadane
- Porównywanie uruchomień Vertex Pipelines w konsoli Cloud i programowo
- Śledzenie pochodzenia artefaktów wygenerowanych przez potok
- Wykonywanie zapytań dotyczących metadanych uruchomienia potoku
Całkowity koszt ukończenia tego modułu w Google Cloud wynosi około 2 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystujemy najnowszą ofertę produktów AI dostępną w Google Cloud. Vertex AI integruje usługi ML w Google Cloud, zapewniając płynne środowisko programistyczne. Wcześniej modele wytrenowane za pomocą AutoML i modele niestandardowe były dostępne w ramach osobnych usług. Nowa oferta łączy je w jeden interfejs API wraz z innymi nowymi usługami. Możesz też przeprowadzić migrację istniejących projektów do Vertex AI.
Oprócz usług trenowania i wdrażania modeli Vertex AI obejmuje też różne usługi MLOps, w tym Vertex Pipelines, ML Metadata, Model Monitoring, Feature Store i inne. Wszystkie usługi Vertex AI znajdziesz na diagramie poniżej.
Ten moduł dotyczy Vertex Pipelines i Vertex ML Metadata.
Jeśli masz jakieś uwagi dotyczące Vertex AI, 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 ML, możesz udostępnić przepływ pracy ML 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ą automatyzować i odtwarzać przepływ pracy związany z systemami uczącymi się.
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.
Uruchamianie Cloud Shell
W tym module będziesz pracować w sesji Cloud Shell, czyli w interpreterze poleceń hostowanym przez maszynę wirtualną działającą w chmurze Google. Możesz równie łatwo uruchomić tę sekcję lokalnie na własnym komputerze, ale korzystanie z Cloud Shell zapewnia wszystkim możliwość odtworzenia działania w spójnym środowisku. Po zakończeniu modułu możesz spróbować ponownie wykonać tę sekcję na własnym komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni (część strony widoczna po przewinięciu) z opisem tego środowiska. W takim przypadku kliknij Dalej, a ten ekran nie będzie się już wyświetlać. Ten wyświetlany jednorazowo ekran wygląda tak:
Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym module, a być może wszystkie, możesz wykonać w przeglądarce lub na Chromebooku.
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.
Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:
gcloud auth list
Wynik polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli nie, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Wynik polecenia
Updated property [core/project].
Cloud Shell ma kilka zmiennych środowiskowych, w tym GOOGLE_CLOUD_PROJECT, która zawiera nazwę bieżącego projektu w chmurze. Będziemy go używać w różnych miejscach w tym module. Możesz to sprawdzić, uruchamiając to polecenie:
echo $GOOGLE_CLOUD_PROJECT
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.
Tworzenie zasobnika Cloud Storage
Aby uruchomić zadanie trenowania w Vertex AI, potrzebujemy zasobnika pamięci 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
Tworzenie instancji 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 procesorów graficznych:
Użyj opcji domyślnych, a następnie kliknij Utwórz.
Otwieranie notatnika
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.
- Vertex AI SDK: ten pakiet SDK optymalizuje wywoływanie interfejsu Vertex AI API. Użyjemy go do uruchomienia potoku w Vertex AI.
Tworzenie notatnika w Pythonie i instalowanie bibliotek
Najpierw w menu Launchera w instancji notatnika utwórz notatnik, wybierając Python 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 masz prawidłowo zainstalowaną wersję pakietu KFP SDK. Powinien wynosić co najmniej 1,8:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
Następnie sprawdź, czy wersja pakietu SDK Vertex AI jest >= 1.6.2:
!pip list | grep aiplatform
Ustawianie identyfikatora projektu i zasobnika
W tym module 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 module, poniższe polecenie zadziała. W przeciwnym razie musisz ustawić to ręcznie:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Importowanie bibliotek
Aby zaimportować biblioteki, których będziemy używać w tym ćwiczeniu, dodaj ten kod:
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
Definiowanie stałych
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. Tworzenie 3-etapowego potoku z komponentami niestandardowymi
Ten moduł skupia się na zrozumieniu metadanych z uruchomień potoku. Aby to zrobić, potrzebujemy potoku do uruchomienia w usłudze Vertex Pipelines. Od tego zaczniemy. Zdefiniujemy tu 3-etapowy potok z tymi komponentami niestandardowymi:
get_dataframe: pobieranie danych z tabeli BigQuery i przekształcanie ich w Pandas DataFrametrain_sklearn_model: użyj Pandas DataFrame, aby wytrenować i wyeksportować model Scikit Learn wraz z niektórymi danymideploy_model: Wdrażanie wyeksportowanego modelu Scikit Learn w punkcie końcowym w Vertex AI
W tym potoku użyjemy zbioru danych UCI Machine Learning Dry beans dataset, pochodzącego z: 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
Jest to zbiór danych w formie tabeli. W naszym potoku użyjemy go do trenowania, oceniania i wdrażania modelu Scikit-learn, który klasyfikuje ziarna fasoli w 7 typach na podstawie ich cech. Zaczynamy kodować!
Tworzenie komponentów opartych na funkcjach Pythona
Za pomocą pakietu KFP SDK możemy tworzyć komponenty na podstawie funkcji Pythona. Użyjemy go w 3 komponentach tego potoku.
Pobieranie danych BigQuery i konwertowanie ich do formatu 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 korzystać z kilku bibliotek Pythona, które określimy za pomocą parametru
packages_to_install. - Parametr
output_component_filejest opcjonalny i określa plik YAML, do którego ma zostać zapisany skompilowany komponent. Po uruchomieniu komórki zobaczysz, że plik został zapisany w instancji notatnika. Jeśli chcesz udostępnić ten komponent komuś innemu, możesz wysłać mu wygenerowany plik YAML i poprosić go o załadowanie go w ten sposób:
# 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 ten komponent używa biblioteki klienta BigQuery w Pythonie, aby pobrać dane z BigQuery do obiektu DataFrame biblioteki Pandas, a potem tworzy artefakt wyjściowy tych danych w postaci pliku CSV. Zostanie on przekazany jako dane wejściowe do następnego komponentu.
Tworzenie komponentu do trenowania modelu Scikit-learn
W tym komponencie użyjemy wygenerowanego wcześniej pliku CSV do wytrenowania modelu drzewa decyzyjnego Scikit-learn. Ten komponent eksportuje wynikowy model Scikit wraz z artefaktem Metrics, który zawiera dokładność modelu, platformę i rozmiar zbioru danych użytego do jego wytrenowania:
@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")
Definiowanie komponentu do przesyłania i wdrażania modelu w Vertex AI
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
Używamy tutaj pakietu Vertex AI SDK, aby przesłać model za pomocą gotowego kontenera do prognozowania. Następnie wdraża model w punkcie końcowym i zwraca identyfikatory URI zasobów modelu i punktu końcowego. W dalszej części tego ćwiczenia dowiesz się więcej o tym, co oznacza zwracanie tych danych jako artefaktów.
Definiowanie i kompilowanie potoku
Po zdefiniowaniu 3 komponentów utworzymy definicję potoku. Opisuje, jak artefakty wejściowe i wyjściowe przepływają między poszczególnymi 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
)
Spowoduje to wygenerowanie pliku JSON, którego użyjesz do uruchomienia potoku:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)
Uruchamianie 2 potoków
Następnie uruchomimy 2 potoki. Najpierw zdefiniujmy sygnaturę czasową, która będzie używana w identyfikatorach zadań potoku:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Pamiętaj, że nasz potok przyjmuje 1 parametr podczas stosowania: bq_table, którego chcemy użyć w przypadku danych treningowych. To uruchomienie potoku będzie korzystać z mniejszej wersji zbioru danych dotyczącego fasoli:
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 kolejny przebieg potoku, używając 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 wykonywanie potoku w przypadku obu uruchomień. Najlepiej jest to zrobić w 2 osobnych komórkach notatnika, aby zobaczyć dane wyjściowe każdego uruchomienia.
run1.submit()
Następnie rozpocznij drugi przebieg:
run2.submit()
Po uruchomieniu tej komórki zobaczysz link do wyświetlenia każdego potoku w konsoli Vertex AI. Otwórz ten link, aby zobaczyć więcej szczegółów dotyczących potoku:
Po zakończeniu (potok działa około 10–15 minut) zobaczysz coś takiego:
Teraz, gdy masz już 2 ukończone uruchomienia potoku, możesz przyjrzeć się bliżej artefaktom, danym i pochodzeniu potoku.
6. Informacje o artefaktach i pochodzeniu potoku
Na wykresie ścieżki zobaczysz małe pola po każdym kroku. Są to artefakty, czyli dane wyjściowe wygenerowane na etapie potoku. Istnieje wiele rodzajów artefaktów. W tym konkretnym potoku mamy artefakty zbioru danych, rodzajów danych, modelu i punktu końcowego. Aby wyświetlić więcej szczegółów o każdym artefakcie, kliknij suwak Rozwiń artefakty u góry interfejsu:
Kliknięcie artefaktu spowoduje wyświetlenie większej ilości informacji na jego temat, w tym jego identyfikatora URI. Na przykład kliknięcie artefaktu vertex_endpoint spowoduje wyświetlenie identyfikatora URI, pod którym można znaleźć wdrożony punkt końcowy w konsoli Vertex AI:
Metrics artefakt umożliwia przekazywanie danych niestandardowych powiązanych z określonym etapem potoku. W sklearn_train komponentu naszego potoku rejestrowaliśmy dane dotyczące dokładności modelu, platformy i rozmiaru zbioru danych. Kliknij artefakt danych, aby wyświetlić szczegóły:
Każdy artefakt ma pochodzenie, które opisuje inne artefakty, z którymi jest powiązany. Ponownie kliknij artefakt vertex_endpoint w potoku, a potem kliknij przycisk View Lineage (Wyświetl pochodzenie):
Otworzy się nowa karta, na której zobaczysz wszystkie artefakty połączone z wybranym przez Ciebie artefaktem. Wykres pochodzenia danych będzie wyglądać mniej więcej tak:
Wyświetla model, dane i zbiór danych powiązane z tym punktem końcowym. Dlaczego ta funkcja jest przydatna? Możesz mieć model wdrożony w wielu punktach końcowych lub potrzebować informacji o konkretnym zbiorze danych używanym do trenowania modelu wdrożonego w punkcie końcowym, który Cię interesuje. Wykres pochodzenia pomaga zrozumieć każdy artefakt w kontekście pozostałych elementów systemu ML. Pochodzenie możesz też uzyskać programowo, co pokażemy w dalszej części tego ćwiczenia z programowania.
7. Porównywanie uruchomień potoków
Prawdopodobnie jeden potok będzie uruchamiany wielokrotnie, być może z różnymi parametrami wejściowymi, nowymi danymi lub przez różne osoby z Twojego zespołu. Aby śledzić uruchomienia potoku, warto mieć możliwość porównywania ich według różnych danych. W tej sekcji omówimy 2 sposoby porównywania przebiegów.
Porównywanie uruchomień w interfejsie potoków
W konsoli Cloud otwórz panel Potoki. Znajdziesz tu podsumowanie wszystkich uruchomień potoku. Sprawdź 2 ostatnie przebiegi, a potem kliknij przycisk Porównaj u góry:
Przeniesie nas to na stronę, na której możemy porównać parametry wejściowe i dane dla każdego z wybranych przez nas przebiegów. Zwróć uwagę na różne tabele BigQuery, rozmiary zbiorów danych i wartości dokładności w przypadku tych 2 uruchomień:
Za pomocą tej funkcji interfejsu możesz porównać więcej niż 2 uruchomienia, a nawet uruchomienia z różnych potoków.
Porównywanie przebiegów za pomocą pakietu Vertex AI SDK
W przypadku wielu wykonań potoku możesz potrzebować sposobu na programowe uzyskiwanie tych danych porównawczych, aby dokładniej analizować szczegóły danych i tworzyć wizualizacje.
Aby uzyskać dostęp do metadanych wykonania, możesz użyć metody aiplatform.get_pipeline_df(). Pobierzemy metadane 2 ostatnich uruchomień tego samego potoku i wczytamy je do struktury 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 ramki danych zobaczysz coś takiego:
W tym przypadku wykonaliśmy potok tylko 2 razy, ale możesz sobie wyobrazić, ile wskaźników uzyskasz przy większej liczbie wykonań. Następnie utworzymy niestandardową wizualizację za pomocą biblioteki matplotlib, aby zobaczyć zależność między dokładnością modelu a ilością danych użytych 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 dane dotyczące potoku
Oprócz uzyskania ramki danych ze wszystkimi danymi potoku możesz też programowo wysyłać zapytania o artefakty utworzone w systemie ML. Możesz tam utworzyć niestandardowy panel lub umożliwić innym osobom w organizacji uzyskiwanie szczegółowych informacji o konkretnych artefaktach.
Pobieranie wszystkich artefaktów modelu
Aby wysyłać zapytania 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 list_artifacts żądanie do tego punktu końcowego i przekażemy filtr wskazujący, które artefakty chcemy otrzymać w odpowiedzi. Najpierw pobierzmy wszystkie artefakty w 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)
Wynikowa odpowiedź model_artifacts zawiera obiekt iterowalny dla każdego artefaktu modelu w projekcie oraz powiązane metadane każdego modelu.
Filtrowanie obiektów i wyświetlanie ich w ramce danych
Przydałaby się możliwość łatwiejszego wizualizowania zapytania o artefakt. Następnie pobierzmy wszystkie artefakty utworzone po 10 sierpnia 2021 r. w stanie LIVE. Po uruchomieniu tego żądania wyświetlimy wyniki w strukturze 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 obiekcie 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:
Możesz też filtrować artefakty na podstawie innych kryteriów niż te, które zostały tu użyte.
To już koniec tego modułu.
🎉 Gratulacje! 🎉
Dowiedziałeś się, 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 na tym zbiorze danych niestandardowy model Scikit-learn
- Tworzenie niestandardowych komponentów potoku, które generują artefakty i metadane
- Porównywanie uruchomień Vertex Pipelines w konsoli Cloud i programowo
- Śledzenie pochodzenia artefaktów wygenerowanych przez potok
- Wykonywanie zapytań dotyczących metadanych uruchomienia 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.
Zatrzymywanie lub usuwanie instancji 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ń:
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 Storage, w menu nawigacyjnym w konsoli Cloud otwórz Storage, wybierz zasobnik i kliknij Usuń:
