1. Omówienie
W tym laboratorium 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, a następnie trenuje i wdraża na nim niestandardowy model Scikit-learn.
- pisać niestandardowe komponenty potoku, które generują artefakty i metadane;
- Porównywanie przebiegów Vertex Pipelines w konsoli Cloud i programowo
- Śledzenie pochodzenia artefaktów wygenerowanych przez potok
- Wykonywanie zapytań dotyczących metadanych uruchomienia potoku
Łączny koszt wykonania tego ćwiczenia w Google Cloud wynosi około 2 USD.
2. Wprowadzenie do Vertex AI
Ten moduł wykorzystuje najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje rozwiązania ML w Google Cloud, zapewniając bezproblemowe środowisko programistyczne. Wcześniej modele wytrenowane za pomocą AutoML i modele niestandardowe były dostępne za pomocą oddzielnych usług. Nowa oferta łączy oba te interfejsy API 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 obejmuje też wiele produktów MLOps, takich jak Vertex Pipelines, ML Metadata, Model Monitoring, Feature Store i inne. Wszystkie oferty usług Vertex AI możesz zobaczyć na schemacie poniżej.
Ten moduł dotyczy Vertex Pipelines i metadanych Vertex ML.
Jeśli chcesz podzielić się opinią na temat Vertex AI, odwiedź stronę pomocy.
Dlaczego potoki ML są przydatne?
Zanim przejdziemy do szczegółów, wyjaśnijmy, dlaczego warto używać potoku. Wyobraź sobie, że tworzysz przepływ pracy systemu uczącego się, który obejmuje przetwarzanie danych, trenowanie modelu, dostrajanie hiperparametrów, ocenę i wdrażanie modelu. Każdy z tych kroków może mieć różne zależności, które mogą stać się niepraktyczne, jeśli będziesz traktować cały proces jako monolit. Gdy zaczniesz wdrażać proces uczenia maszynowego na większą skalę, możesz udostępnić przepływ pracy związanej z uczeniem maszynowym innym członkom zespołu, aby mogli go uruchomić i wnosić poprawki do kodu. Bez niezawodnego, powtarzalnego procesu może to być trudne. W przypadku rurociągów każdy krok w procesie uczenia maszynowego jest oddzielnym kontenerem. Dzięki temu możesz opracowywać kroki niezależnie od siebie i śledzić dane wejściowe i wyjściowe z każdego kroku w powtarzalny sposób. Możesz też planować lub aktywować uruchomienia potoku na podstawie innych zdarzeń w środowisku Cloud, takich jak uruchamianie uruchomienia potoku po udostępnieniu nowych danych do trenowania.
Podsumowanie: potoki pomagają automatyzować i odtwarzać przepływ pracy związany z systemami uczącymi się.
3. Konfigurowanie środowiska w chmurze
Aby uruchomić to ćwiczenie, musisz mieć projekt Google Cloud Platform z włączonym rozliczeniem. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
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 też uruchomić tę sekcję lokalnie na swoim komputerze, ale korzystanie z Cloud Shell daje wszystkim dostęp do powtarzalnego środowiska w spójnym środowisku. Po ukończeniu modułu możesz powtórzyć tę sekcję na swoim komputerze.
Aktywowanie Cloud Shell
W prawym górnym rogu konsoli Cloud Console kliknij przycisk poniżej, aby aktywować Cloud Shell:
Jeśli nigdy wcześniej nie korzystałeś(-aś) z Cloud Shell, zobaczysz ekran pośredni (poniżej zgięcia), który wyjaśnia, czym jest to środowisko. W takim przypadku kliknij Dalej (nie zobaczysz go już więcej). Oto jak wygląda ekran jednorazowy:
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia programistyczne. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie poprawia wydajność sieci i uwierzytelnianie. Większość, jeśli nie wszystkie, czynności w tym CodeLab możesz wykonać w przeglądarce lub na Chromebooku.
Po połączeniu z Cloud Shell powinieneś zobaczyć, że jesteś już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
Aby potwierdzić uwierzytelnianie, uruchom w Cloud Shell to polecenie:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
Aby sprawdzić, czy polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli nie, możesz ustawić je za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Wynik polecenia
Updated property [core/project].
Cloud Shell ma kilka zmiennych środowiskowych, w tym GOOGLE_CLOUD_PROJECT, która zawiera nazwę naszego bieżącego projektu Cloud. Będziemy go używać w różnych miejscach w tym module. Możesz go sprawdzić, uruchamiając polecenie:
echo $GOOGLE_CLOUD_PROJECT
Włącz interfejsy API
W kolejnych krokach dowiesz się, gdzie i po co są potrzebne te usługi. Na razie uruchom to polecenie, aby przyznać swojemu projektowi dostęp do usług Compute Engine, Container Registry i Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Powinien wyświetlić się komunikat o udanym przeprowadzeniu operacji podobny do tego:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Tworzenie zasobnika Cloud Storage
Aby uruchomić zadanie trenowania w Vertex AI, potrzebujemy zasobnika Cloud Storage do przechowywania zapisanych komponentów modelu. Zasobnik musi być regionalny. Tutaj używamy regionu us-central, ale możesz użyć innego (wystarczy go zastąpić w tym laboratorium). Jeśli masz już taki folder, możesz pominąć ten krok.
Aby utworzyć zasobnik, uruchom te polecenia w terminalu Cloud Shell:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Następnie przyznamy temu kontu usługi obliczeniowej dostęp do tego zasobnika. Dzięki temu usługa 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
Utwórz instancję Vertex AI Workbench
W konsoli Cloud w sekcji Vertex AI 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 procesorów graficznych:
Użyj domyślnych opcji i kliknij Utwórz.
Otwieranie notatnika
Po utworzeniu instancji kliknij Otwórz JupyterLab:
4. Konfiguracja Vertex Pipelines
Istnieje kilka dodatkowych bibliotek, które musimy zainstalować, aby używać Vertex Pipelines:
- Kubeflow Pipelines: pakiet SDK, którego użyjemy do tworzenia potoku. Vertex Pipelines obsługuje uruchomione potoki utworzone za pomocą zarówno Kubeflow Pipelines, jak i TFX.
- Vertex AI SDK: ten pakiet SDK optymalizuje działanie wywołań interfejsu Vertex AI API. Użyjemy go do uruchomienia potoku w Vertex AI.
Tworzenie notatnika w Pythonie i instalowanie bibliotek
Najpierw w menu Menu z aplikacjami w instancji notatnika utwórz notatnik, wybierając Python 3:
Aby zainstalować obie usługi, których użyjemy w tym laboratorium, najpierw ustaw flagę użytkownika w komórce notebooka:
USER_FLAG = "--user"
Następnie w notatniku wykonaj te czynności:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!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. Powinien on wynosić >1,8:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
Następnie sprawdź, czy wersja pakietu SDK Vertex AI jest większa niż 1.6.2:
!pip list | grep aiplatform
Ustaw identyfikator projektu i zasobnik
W tym laboratorium będziesz używać identyfikatora projektu Cloud i utworzonego wcześniej zasobnika. Następnie utworzymy dla nich zmienne.
Jeśli nie znasz identyfikatora projektu, możesz go uzyskać, wykonując te czynności:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
W przeciwnym razie ustaw je tutaj:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Następnie utwórz zmienną przechowującą nazwę zasobnika. Jeśli utworzysz go w tym module, wykonaj te czynności. W przeciwnym razie musisz ustawić je 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
Definiowanie stałych
Ostatnią rzeczą, którą musimy zrobić przed utworzeniem potoku, jest zdefiniowanie stałych zmiennych. PIPELINE_ROOT to ścieżka do Cloud Storage, na której będą zapisywane artefakty utworzone przez nasz potok. Tutaj używamy regionu us-central1, ale jeśli podczas tworzenia zasobnika został użyty inny region, zaktualizuj zmienną REGION w poniższym kodzie:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Po uruchomieniu powyższego kodu powinien zostać wydrukowany katalog główny potoku. To jest lokalizacja w Cloud Storage, w której będą zapisywane artefakty z Twojego potoku. Numer ten ma format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Tworzenie potoku 3-etapowego z komponentami niestandardowymi
W tym laboratorium skupiamy się na metadanych z wyników działania potoku. Aby to zrobić, musimy uruchomić potok w usłudze Vertex Pipelines, od której zaczniemy. Zdefiniujemy tutaj 3-etapowy potok z tymi komponentami niestandardowymi:
get_dataframe: pobiera dane z tabeli BigQuery i przekształca je w platformę DataFrame biblioteki Pandastrain_sklearn_model: użyj DataFrame w Pandas, aby trenować i eksportować 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 „Dry beans” z platformy UCI Machine Learning, który pochodzi z artykułu KOKLU, M. i OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques” [Wieloklasowa klasyfikacja fasoli przy użyciu technik rozpoznawania obrazów i uczenia maszynowego], „In Computers and Electronics in Agriculture”, 174, 105507. DOI.
Jest to zbiór danych tabelarycznych, którego użyjemy w naszej ścieżce do trenowania, oceny i wdrażania modelu Scikit-learn, który na podstawie cech klasyfikuje ziarna do jednej z 7 grup. Zacznijmy kodować.
Tworzenie komponentów na podstawie funkcji Pythona
Za pomocą pakietu SDK KFP możemy tworzyć komponenty oparte na funkcjach w Pythonie. Użyjemy go w przypadku 3 komponentów w tym potoku.
Pobieranie danych z BigQuery i konwertowanie ich na format 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 wykonywania potoku. Używasz go za każdym razem, gdy piszesz niestandardowy komponent. - 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, do którego ma zostać zapisany skompilowany komponent. Po uruchomieniu komórki plik powinien zostać zapisany w notatniku. Jeśli chcesz udostępnić ten komponent innej osobie, możesz wysłać wygenerowany plik yaml i poprosić o jego załadowanie:
# 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. Zostanie ono przekazane jako dane wejściowe do następnego komponentu.
Utwórz komponent do trenowania modelu Scikit-learn
W tym komponencie użyjemy wygenerowanego wcześniej pliku CSV do wytrenowania modelu drzewa decyzyjnego w Scikit-learn. Ten komponent eksportuje uzyskany model Scikit wraz z elementem Metrics, który zawiera dokładność modelu, framework 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")
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 dowiesz się, co oznacza zwracanie tych danych jako artefaktów.
Definiowanie i kompilowanie potoku
Po zdefiniowaniu tych 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 określmy sygnaturę czasową, której będziemy używać w przypadku identyfikatorów zadań w ścieżce:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Pamiętaj, że nasz potok wymaga jednego parametru podczas uruchamiania: bq_table, którego chcemy użyć do danych treningowych. Ten przebieg potoku będzie używać mniejszej wersji zbioru danych o 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 kolejną wersję 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 wykonanie potoku w przypadku obu uruchomień. Najlepiej zrobić to w 2 oddzielnych komórkach notebooka, aby można było zobaczyć wynik po każdym uruchomieniu.
run1.submit()
Następnie uruchom drugą próbę:
run2.submit()
Po wykonaniu tej komórki zobaczysz link do wyświetlenia poszczególnych przepływów danych w konsoli Vertex AI. Kliknij ten link, aby wyświetlić więcej informacji o 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 i pochodzeniu w ścieżce
Na wykresie ścieżki zobaczysz małe pola po każdym kroku. Są to elementy lub dane wyjściowe wygenerowane na podstawie 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. Jeśli na przykład klikniesz artefakt vertex_endpoint, zobaczysz identyfikator URI, pod którym w konsoli Vertex AI znajdziesz wdrożony punkt końcowy:
Element Metrics umożliwia przekazywanie danych niestandardowych powiązanych z konkretnym krokiem potoku. W komponencie sklearn_train naszego potoku danych zapisaliśmy dane o dokładności modelu, frameworku i rozmiarze zbioru danych. Kliknij artefakt danych, aby wyświetlić te szczegóły:
Każdy artefakt ma rodowód, który opisuje inne powiązane z nim artefakty. Ponownie kliknij artefakt vertex_endpoint w pipeline, a potem kliknij przycisk Wyświetl pochodzenie:
Otworzy się nowa karta, na której zobaczysz wszystkie artefakty powiązane z wybranym artefaktem. Twój wykres pokrewieństwa 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 informacji o pochodzeniu możesz też uzyskać programowo, co zobaczysz w późniejszej części tego ćwiczenia.
7. Porównywanie 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. Aby móc śledzić przebiegi, warto mieć możliwość ich porównywania na podstawie różnych danych. W tej sekcji omówimy 2 sposoby porównywania uruchomień.
Porównywanie uruchomień w interfejsie Pipelines
W konsoli Cloud przejdź do panelu potoków. Znajdziesz tu przegląd wszystkich uruchomionych procesów. Sprawdź ostatnie 2 wyniki, a potem u góry kliknij przycisk Porównaj:
Otworzy się strona, na której możemy porównać parametry wejściowe i dane dotyczące każdego wybranego przebiegu. W przypadku tych 2 wykonań 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 uruchomienia z różnych ścieżek.
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 przebiegu, możesz użyć metody aiplatform.get_pipeline_df(). W tym przypadku pobieramy metadane z 2 ostatnich uruchomień tego samego potoku i wczytujemy je do struktury DataFrame biblioteki Pandas. Parametr pipeline odnosi się tutaj do nazwy naszego potoku w definicji potoku:
df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df
Po wydrukowaniu DataFrame zobaczysz coś takiego:
Tutaj przeprowadziliśmy przetwarzanie tylko 2 razy, ale możesz sobie wyobrazić, ile wskaźników uzyskasz przy większej liczbie uruchomień. Następnie utworzymy niestandardową wizualizację za pomocą 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 uzyskiwania DataFrame wszystkich danych dotyczących potoku możesz też programowo wysyłać zapytania do 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 pobierz wszystkie elementy w projekcie, które są modelami. Aby to zrobić, uruchom w notatniku ten kod:
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 iteracyjny dla każdego artefaktu modelu w projekcie wraz z powiązanymi metadanymi każdego modelu.
Filtrowanie obiektów i wyświetlanie ich w DataFrame
Byłoby przydatne, gdybyśmy mogli łatwiej zwizualizować powstałe zapytanie dotyczące artefaktu. Następnie pobierz wszystkie elementy utworzone po 10 sierpnia 2021 r., które mają stan LIVE. Po wykonaniu tego zapytania wyświetlimy wyniki w ramach struktury 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 tego, co próbowałeś/próbowałaś tutaj, możesz też filtrować artefakty według 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, a następnie trenuje i wdraża na nim niestandardowy model Scikit-learn.
- pisać niestandardowe komponenty potoku, które generują artefakty i metadane;
- Porównywanie przebiegów 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 elementach Vertex znajdziesz w dokumentacji.
9. Czyszczenie
Aby uniknąć opłat, zalecamy usunięcie zasobów utworzonych w ramach tego laboratorium.
Zatrzymanie lub usunięcie instancji aplikacji Notebooks
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym laboratorium, zalecamy jego wyłączenie, gdy go nie używasz. W interfejsie Notebooków w konsoli Cloud Console wybierz notebook, a następnie wybierz Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, kliknij Usuń:
Usuwanie punktów końcowych Vertex AI
Aby usunąć wdrożony punkt końcowy, otwórz sekcję Punkty końcowe w konsoli Vertex AI i kliknij ikonę usuwania:
Usuwanie zasobnika Cloud Storage
Aby usunąć zasobnik Cloud Storage, w menu nawigacyjnym konsoli Cloud przejdź do usługi Storage, wybierz zasobnik i kliknij Usuń:
