1. Wprowadzenie
| Kubeflow to zestaw narzędzi systemów uczących się dla Kubernetes. Celem projektu jest przygotowanie wdrożeń przepływów pracy systemów uczących się w Kubernetes, które są proste, przenośne i skalowalne. Celem jest zapewnienie prostego sposobu wdrażania najlepszych w swojej klasie systemów open source na potrzeby systemów uczących się w różnych infrastrukturach. |
| Przepływ pracy związany z systemami uczącymi się może obejmować wiele etapów uzależnionych od siebie nawzajem – od przygotowania i analizy danych przez trenowanie, ocenę, wdrożenie i nie tylko. Trudno jest skompilować i śledzić te procesy doraźnie – na przykład w zestawie notatników lub skryptów – a kontrola i odtwarzanie stają się coraz bardziej pracochłonne.Kubeflow Pipelines (KFP) pomaga rozwiązywać te problemy dzięki możliwości wdrażania niezawodnych i powtarzalnych potoków systemów uczących się wraz z monitorowaniem, kontrolą, śledzeniem i odtwarzaniem wersji. Potoki Cloud AI ułatwiają skonfigurowanie instalacji KFP. |
Co utworzysz
W ramach tego ćwiczenia w Codelabs utworzysz aplikację internetową, która podsumowuje problemy z GitHubem, za pomocą Kubeflow Pipelines do trenowania i udostępniania modelu. Opiera się on na przykładzie z repozytorium Kubeflow Przykłady. Po ukończeniu instalacji infrastruktura będzie zawierać:
- klaster Google Kubernetes Engine (GKE) z zainstalowaną aplikacją Kubeflow Pipelines (za pomocą Cloud AI Pipelines).
- Potok, który trenuje model Tensor2Tensor w GPU
- Kontener obsługujący, który udostępnia prognozy z wytrenowanego modelu
- Interfejs użytkownika, który interpretuje prognozy i udostępnia podsumowania problemów z GitHub.
- Notatnik, który tworzy potok od zera za pomocą pakietu SDK Kubeflow Pipelines (KFP).
Czego się nauczysz
Potok, który utworzysz, trenuje model Tensor2Tensor na danych o problemach z GitHuba, ucząc się przewidywać tytuły problemów na podstawie treści problemów. Następnie wytrenowany model eksportuje i wdraża wyeksportowany model przy użyciu obsługi Tensorflow. Ostatni krok potoku uruchamia aplikację internetową, która wchodzi w interakcję z instancją obsługi plików TF, aby uzyskiwać prognozy modelu.
- Jak zainstalować Kubeflow Pipelines w klastrze GKE
- Jak tworzyć i uruchamiać przepływy pracy ML za pomocą Kubeflow Pipelines
- Jak definiować i uruchamiać potoki za pomocą notatnika platformy AI
Czego potrzebujesz
- Podstawowa wiedza na temat Kubernetes może być pomocna, ale nie jest konieczna
- aktywny projekt GCP, w którym masz uprawnienia właściciela.
- (Opcjonalnie) konto GitHub.
- Dostęp do Google Cloud Shell w konsoli Google Cloud Platform (GCP)
2. Konfiguracja
Cloud Shell
Otwórz konsolę GCP w przeglądarce i zaloguj się przy użyciu danych logowania do projektu:
Kliknij „Wybierz projekt”. w razie potrzeby.
Następnie kliknij „Aktywuj Cloud Shell”. w prawym górnym rogu konsoli, aby uruchomić Cloud Shell.
Gdy uruchomisz Cloud Shell, wyświetli się nazwa projektu, do którego jest ustawiona. Sprawdź, czy to ustawienie jest poprawne.
Aby znaleźć identyfikator projektu, otwórz panel główny konsoli GCP. Jeśli ekran jest pusty, kliknij „Tak”. w oknie, aby utworzyć panel.
Następnie w razie potrzeby uruchom w terminalu Cloud Shell te polecenia, aby skonfigurować gcloud do korzystania z właściwego projektu:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Tworzenie zasobnika na dane
utworzyć zasobnik Cloud Storage do przechowywania plików potoku, Musisz użyć unikalnego identyfikatora globalnie, który jest wygodny do zdefiniowania nazwy zasobnika, która zawiera identyfikator projektu. Utwórz zasobnik za pomocą polecenia gsutil mb (utwórz zasobnik):
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
Możesz też utworzyć zasobnik za pomocą konsoli GCP.
Opcjonalnie**: utwórz token GitHub**
To ćwiczenie w Codelabs wywołuje interfejs GitHub API, aby pobrać publicznie dostępne dane. Aby zapobiec ograniczeniom szybkości, zwłaszcza w przypadku zdarzeń, w których do interfejsów API GitHub jest wysyłana duża liczba zanonimizowanych żądań, skonfiguruj token dostępu bez uprawnień. Ma to na celu wyłącznie upoważnienie Cię jako użytkownika indywidualnego, a nie anonimowego.
- Otwórz stronę https://github.com/settings/tokens i wygeneruj nowy token bez zakresów.
- Zapisz w bezpiecznym miejscu. Jeśli go utracisz, musisz go usunąć i utworzyć nowy.
Jeśli pominiesz ten krok, moduł będzie nadal działać, a opcje generowania danych wejściowych na potrzeby testowania modelu będą ograniczone.
Opcjonalnie: przypnij przydatne panele
W konsoli GCP przypnij panele Kubernetes Engine i Miejsce na dane, aby mieć do nich łatwiejszy dostęp.
Tworzenie instalacji AI Platform Pipelines (hostowane potoki Kubeflow)
Postępuj zgodnie z instrukcjami w części „Zanim zaczniesz” i „Skonfiguruj instancję” tutaj, aby dowiedzieć się, jak skonfigurować instancję GKE z zainstalowanym KFP. Pamiętaj, aby zaznaczyć pole Zezwalaj na dostęp do poniższych interfejsów Cloud APIs zgodnie z dokumentacją. Jeśli tego nie zrobisz, przykładowy potok nie zadziała. W przestrzeni nazw instalacji pozostaw wartość default.
Musisz wybrać strefę, która obsługuje karty Nvidia K80s. Możesz użyć wartości domyślnych us-central1-a lub us-central1-c.
Po zakończeniu instalacji zapisz nazwę klastra i strefę GKE podane dla instalacji w panelu AI Pipelines. Dla wygody ustaw zmienne środowiskowe na te wartości.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Skonfiguruj kubectl, aby korzystać z danych logowania do nowego klastra GKE
Po utworzeniu klastra GKE skonfiguruj w kubectl Cloud Shell dane logowania do nowego klastra, uruchamiając w Cloud Shell to polecenie:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
Możesz też kliknąć nazwę klastra w panelu AI Pipelines, aby otworzyć jego stronę GKE, a następnie kliknąć „Połącz” u góry strony. W wyskakującym okienku wklej polecenie w Cloud Shell.
Spowoduje to skonfigurowanie kontekstu kubectl, co umożliwi interakcję z klastrem. Aby sprawdzić konfigurację, uruchom to polecenie:
kubectl get nodes -o wide
Zobaczysz listę węzłów ze stanem „Ready” oraz innymi informacjami o wieku i wersji węzła, zewnętrznym adresie IP, obrazie systemu operacyjnego, wersji jądra i środowisku wykonawczym kontenera.
Konfigurowanie klastra do instalowania sterownika Nvidia w pulach węzłów z włączoną obsługą GPU
Następnie zastosujemy do klastra zestaw demonów, który zainstaluje sterownik Nvidia we wszystkich węzłach klastra z włączoną obsługą GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Następnie uruchom to polecenie, które przyzna komponentom KFP uprawnienia do tworzenia nowych zasobów Kubernetes:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Tworzenie puli węzłów GPU
Następnie skonfigurujemy pulę węzłów GPU o rozmiarze 1:
gcloud container node-pools create gpu-pool \
--cluster=${CLUSTER_NAME} \
--zone ${ZONE} \
--num-nodes=1 \
--machine-type n1-highmem-8 \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=1
3. Uruchamianie potoku z panelu Pipelines
Otwórz panel Pipelines
W konsoli Cloud otwórz panel Potoki, jeśli jeszcze go tam nie ma. Następnie kliknij OTWÓRZ PULPIT POTOKU. odpowiednią instalację i kliknij Pipelines na pasku menu po lewej stronie. Jeśli pojawi się błąd ładowania, odśwież kartę. Powinna wyświetlić się nowa strona podobna do tej:
Opis potoku
Potok, który uruchomisz, składa się z kilku kroków (szczegóły znajdziesz w załączniku do tego ćwiczenia z programowania):
- Do zasobnika skopiowano istniejący punkt kontrolny modelu.
- Model Tensor2Tensor jest trenowany z użyciem wstępnie przetworzonych danych.
- Trenowanie rozpoczyna się od punktu kontrolnego istniejącego modelu skopiowanego w pierwszym kroku, a potem trenuje przez jeszcze kilkaset kroków. Pełne wytrenowanie tej funkcji w ramach ćwiczeń z programowania zajęło zbyt dużo czasu.
- Po zakończeniu trenowania krok potoku eksportuje model w formie odpowiedniej do udostępniania przez TensorFlow.
- Za pomocą tego modelu wdrożona jest instancja TensorFlow-Serving.
- Uruchomiono aplikację internetową do interakcji z obsługiwanym modelem w celu pobierania prognoz.
Pobieranie i kompilowanie potoku
W tej sekcji dowiesz się, jak skompilować definicję potoku. Najpierw musimy zainstalować pakiet KFP SDK. Uruchom w Cloud Shell to polecenie:
pip3 install -U kfp
Aby pobrać plik definicji potoku, uruchom w Cloud Shell to polecenie:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Następnie skompiluj plik definicji potoku, uruchamiając go w ten sposób:
python3 gh_summ_hosted_kfp.py
W wynikach wyświetli się plik gh_summ_hosted_kfp.py.tar.gz.
Przesyłanie skompilowanego potoku
W interfejsie internetowym Kubeflow Pipelines kliknij Prześlij potok i wybierz Importuj według adresu URL. Skopiuj i wklej poniższy adres URL, który wskazuje ten sam potok, który właśnie został skompilowany. (przesłanie pliku z Cloud Shell wymaga wykonania kilku dodatkowych czynności, dlatego zdecydowaliśmy się na skrót).
Nadaj potokowi nazwę (np. gh_summ).
Uruchamianie potoku
Kliknij na liście przesłany potok, aby wyświetlić wykres statyczny potoku, a następnie kliknij Utwórz eksperyment, aby utworzyć za jego pomocą nowy eksperyment. Eksperyment to sposób na zgrupowanie uruchomień powiązanych semantycznie.
Nadaj eksperymentowi nazwę (np. taką samą jak potok, gh_summ), a potem kliknij Dalej, aby go utworzyć.
Wyświetli się strona, na której możesz podać parametry uruchomienia i je rozpocząć.
Aby uzupełnić parametry, możesz uruchomić w Cloud Shell te polecenia.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Nazwa uruchomienia zostanie uzupełniona automatycznie, ale jeśli chcesz, możesz ją nazwać.
Następnie wypełnij trzy pola parametrów:
project- (opcjonalnie)
github-token working-dir
Jako katalog roboczy wpisz ścieżkę w utworzonym zasobniku GCS. Dodaj „gs://” . W polu github-token wpisz token, który został opcjonalnie wygenerowany wcześniej, lub pozostaw ciąg zastępczy bez zmian, jeśli token nie został wygenerowany.
Po wypełnieniu pól kliknij Start, a następnie wybierz uruchomienie, aby wyświetlić jego szczegóły. Podczas wykonywania określonego kroku potoku możesz go kliknąć, aby uzyskać więcej informacji na jego temat, w tym wyświetlić logi poda. Logi dla kroku potoku możesz też wyświetlać, korzystając z linku do logów Cloud Logging (Stackdriver), nawet jeśli węzeł klastra został zniszczony.
Wyświetlanie definicji potoku
Podczas pracy możesz przyjrzeć się bliższemu temu, jak jest on zbudowany i jak działa. Więcej informacji znajdziesz w sekcji Dodatek do ćwiczeń z programowania.
Wyświetlanie informacji o trenowaniu modelu w TensorBoard
Po zakończeniu kroku trenowania wybierz kartę Wizualizacje i kliknij niebieski przycisk Uruchom TensorBoard. Gdy wszystko będzie gotowe, kliknij Otwórz TensorBoard.
Korzystanie z panelu Artefakty i wykonania
Kubeflow Pipelines automatycznie loguje metadane kroków potoku podczas wykonywania potoku. Rejestrowane są informacje o Artifact i Artifact. Kliknij je na lewym pasku nawigacyjnym panelu, aby dowiedzieć się więcej.
W przypadku artefaktów możesz wyświetlać zarówno panel Przegląd, jak i panel Eksplorator historii danych.
Otwórz aplikację internetową utworzoną przez potok i wykonaj prognozy
Ostatnim etapem potoku jest wdrożenie aplikacji internetowej zawierającej interfejs użytkownika do wysyłania prognoz do wytrenowanego modelu udostępnianego przez udostępnianie TF.
Gdy potok się zakończy, połącz się z aplikacją internetową przez przekierowywanie portów do jej usługi (przekierowujemy porty, ponieważ w tym ćwiczeniu z programowania usługa aplikacji internetowej nie jest skonfigurowana pod kątem zewnętrznego punktu końcowego).
Znajdź nazwę usługi, uruchamiając w Cloud Shell to polecenie:
kubectl get services
Poszukaj na liście nazwy usługi podobnej do tej: ghsumm-*-webappsvc.
Następnie w Cloud Shell zastosuj przekierowanie portów do tej usługi w ten sposób, zmieniając to polecenie w taki sposób, aby używało nazwy Twojej webappsvc:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Po uruchomieniu przekierowania portów kliknij „Podgląd” nad panelem Cloud Shell i w menu kliknij „Podejrzyj na porcie 8080”.
W nowej karcie powinna wyświetlić się strona podobna do tej:
Kliknij przycisk Repulation Random Issue (Wypełnij losowy problem), aby pobrać blok tekstu. Kliknij Wygeneruj wersję, aby wywołać wytrenowany model i wyświetlić prognozę.
Jeśli parametry potoku zawierają prawidłowy token GitHub, możesz wpisać adres URL GitHuba w drugim polu, a potem kliknąć „Wygeneruj tytuł”. Jeśli prawidłowy token GitHub nie został skonfigurowany, użyj tylko opcji „Population Random Issue” (Wypełnij losowy problem). .
4. Uruchamianie potoku z notatnika AI Platform
Możesz też interaktywnie definiować i uruchamiać Kubeflow Pipelines z poziomu notatnika Jupyter przy użyciu pakietu SDK KFP. Notatniki w AI Platform, których użyjemy w tym ćwiczeniu z programowania, to bardzo proste.
utworzyć instancję notatnika.
Utworzymy instancję notatek w Cloud Shell za pomocą jej interfejsu API. Notatnik możesz też utworzyć w konsoli Google Cloud. Więcej informacji znajdziesz w dokumentacji.
Ustaw w Cloud Shell te zmienne środowiskowe:
export INSTANCE_NAME="kfp-ghsumm" export VM_IMAGE_PROJECT="deeplearning-platform-release" export VM_IMAGE_FAMILY="tf2-2-3-cpu" export MACHINE_TYPE="n1-standard-4" export LOCATION="us-central1-c"
Następnie w Cloud Shell uruchom polecenie, aby utworzyć instancję notatnika:
gcloud beta notebooks instances create $INSTANCE_NAME \ --vm-image-project=$VM_IMAGE_PROJECT \ --vm-image-family=$VM_IMAGE_FAMILY \ --machine-type=$MACHINE_TYPE --location=$LOCATION
Gdy po raz pierwszy uruchomisz to polecenie, może pojawić się prośba o włączenie w projekcie interfejsu notebooks API. Odpowiedz „y” jeśli tak.
Po kilku minutach serwer notatników zostanie uruchomiony. Instancje notatników możesz zobaczyć na liście w konsoli Cloud.
Prześlij notatnik ćwiczeń z programowania
Po utworzeniu instancji notatnika kliknij ten link, aby przesłać notatnik Jupyter dotyczący ćwiczeń w Codelabs. Wybierz instancję notatek, której chcesz użyć. Notatnik zostanie automatycznie otwarty.
Uruchom notatnik
Do końca tego modułu postępuj zgodnie z instrukcjami w notatniku. Pamiętaj, że w sekcji „Konfiguracja” musisz wpisać własne wartości, zanim uruchomisz resztę notatnika.
Jeśli korzystasz z własnego projektu, nie zapomnij wrócić do sekcji „Wyczyść” w tym module.
5. Czyszczenie danych
Nie musisz tego robić, jeśli używasz tymczasowego konta ćwiczeń z programowania, ale być może chcesz wyłączyć instalację Pipelines i notatnik, jeśli korzystasz z własnego projektu.
Usuwanie klastra GKE Pipelines
Klaster Potoki możesz usunąć z konsoli Cloud. Jeśli chcesz ponownie używać klastra GKE, możesz też usunąć samą instalację Pipelines.
Usuwanie instancji notatnika AI
Jeśli uruchomiono notatnik w ramach ćwiczenia w Codelabs, możesz USUŃ lub ZATRZYMAĆ instancję notatek z poziomu konsoli Google Cloud.
Opcjonalnie: usuń token GitHub
Wejdź na https://github.com/settings/tokens i usuń wygenerowany token.
6. Dodatki
Rzut oka na kod
Definiowanie potoku
Potok używany w tym ćwiczeniu z programowania jest zdefiniowany tutaj.
Przyjrzyjmy się definicjom terminu oraz jego składowym (etapom). Omówimy niektóre najważniejsze funkcje, jednak więcej szczegółów znajdziesz w dokumentacji.
Etapy w Kubeflow Pipeline są oparte na kontenerach. Podczas tworzenia potoku możesz użyć gotowych komponentów z gotowymi obrazami kontenerów lub utworzyć własne komponenty. Do tego ćwiczenia w Codelabs stworzyliśmy własne materiały.
Cztery kroki potoku są zdefiniowane za pomocą komponentów wielokrotnego użytku, do których można uzyskać dostęp za pomocą plików definicji komponentów. W tym pierwszym fragmencie kodu uzyskujemy dostęp do plików definicji komponentów poprzez ich adresy URL i używamy tych definicji do tworzenia „operacji” Użyjemy go do utworzenia kroku potoku.
import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp
...
copydata_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
)
train_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
)
Poniżej znajduje się jedna z definicji komponentów operacji treningowych w formacie yaml. Widać, że jego dane wejściowe, wyjściowe, obraz kontenera i argumenty punktu wejścia kontenera są zdefiniowane.
name: Train T2T model
description: |
A Kubeflow Pipeline component to train a Tensor2Tensor
model
metadata:
labels:
add-pod-env: 'true'
inputs:
- name: train_steps
description: '...'
type: Integer
default: 2019300
- name: data_dir
description: '...'
type: GCSPath
- name: model_dir
description: '...'
type: GCSPath
- name: action
description: '...'
type: String
- name: deploy_webapp
description: '...'
type: String
outputs:
- name: launch_server
description: '...'
type: String
- name: train_output_path
description: '...'
type: GCSPath
- name: MLPipeline UI metadata
type: UI metadata
implementation:
container:
image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
args: [
--data-dir, {inputValue: data_dir},
--action, {inputValue: action},
--model-dir, {inputValue: model_dir},
--train-steps, {inputValue: train_steps},
--deploy-webapp, {inputValue: deploy_webapp},
--train-output-path, {outputPath: train_output_path}
]
env:
KFP_POD_NAME: "{{pod.name}}"
fileOutputs:
launch_server: /tmp/output
MLPipeline UI metadata: /mlpipeline-ui-metadata.json
Krok potoku można też zdefiniować za pomocą konstruktora dsl.ContainerOp, jak pokazano poniżej.
Poniżej znajduje się większość definicji potoku. Definiujemy dane wejściowe potoku (i ich wartości domyślne). Następnie określamy kroki potoku. Zwykle używamy parametru zdefiniowanych powyżej, ale także definiujemy „obsługę” krok wbudowany w ContainerOp, bezpośrednio określając obraz kontenera i argumenty punktu wejścia.
Widać, że kroki train, log_model i serve uzyskują jako dane wejściowe dostęp do danych wyjściowych z poprzednich kroków. Więcej informacji na ten temat znajdziesz tutaj.
@dsl.pipeline(
name='Github issue summarization',
description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ( #pylint: disable=unused-argument
train_steps: 'Integer' = 2019300,
project: str = 'YOUR_PROJECT_HERE',
github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
deploy_webapp: str = 'true',
data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
):
copydata = copydata_op(
data_dir=data_dir,
checkpoint_dir=checkpoint_dir,
model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
action=COPY_ACTION,
)
train = train_op(
data_dir=data_dir,
model_dir=copydata.outputs['copy_output_path'],
action=TRAIN_ACTION, train_steps=train_steps,
deploy_webapp=deploy_webapp
)
serve = dsl.ContainerOp(
name='serve',
image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--model_path", train.outputs['train_output_path']
]
)
train.set_gpu_limit(1)
Pamiętaj, że aplikacja wymaga „pociągu”, do uruchomienia w węźle klastra, który ma co najmniej 1 dostępny procesor graficzny.
train.set_gpu_limit(1)
Ostatni krok potoku – także zdefiniowany w tekście – jest warunkowy. Zostanie uruchomiony po „serve” tylko wtedy, gdy dane wyjściowe kroku trenowania launch_server zawierają ciąg „true” (prawda). Uruchomiono „aplikację internetową do prognozowania”, która służyła nam do wysyłania podsumowań problemów za pomocą wytrenowanego modelu T2T.
with dsl.Condition(train.outputs['launch_server'] == 'true'):
webapp = dsl.ContainerOp(
name='webapp',
image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--github_token", github_token]
)
webapp.after(serve)
Definicje obrazów kontenera komponentu
Dokumentacja Kubeflow Pipeline zawiera sprawdzone metody tworzenia własnych komponentów. W ramach tego procesu musisz zdefiniować i utworzyć obraz kontenera. Kroki komponentu dotyczące potoku tego ćwiczenia w Codelabs znajdziesz tutaj. Definicje Dockerfile znajdują się w podkatalogach containers, np. tutaj.
Używanie maszyn wirtualnych z możliwością wywłaszczania do trenowania
Maszyny wirtualne z możliwością wywłaszczania to instancje maszyn wirtualnych Compute Engine, które działają maksymalnie przez 24 godziny i nie gwarantują dostępności. Ceny maszyn wirtualnych z możliwością wywłaszczania są niższe niż ceny standardowych maszyn wirtualnych Compute Engine.
Google Kubernetes Engine (GKE) ułatwia skonfigurowanie klastra lub puli węzłów, które wykorzystuje maszyny wirtualne z możliwością wywłaszczania. Możesz skonfigurować taką pulę węzłów z jednostkami graficznymi podłączonymi do instancji z możliwością wywłaszczania. Działają one tak samo jak zwykłe węzły z włączoną obsługą GPU, ale procesory graficzne pozostają niezmienione przez cały okres istnienia instancji.
Aby skonfigurować dla klastra z możliwością wywłaszczania pulę węzłów z włączoną obsługą procesorów graficznych, uruchom polecenie podobne do poniższego, zmień poniższe polecenie z nazwą klastra i strefą, a następnie dostosuj typ i liczbę akceleratorów zgodnie z wymaganiami. Opcjonalnie możesz zdefiniować pulę węzłów do autoskalowania na podstawie bieżących zadań.
gcloud container node-pools create preemptible-gpu-pool \
--cluster=<your-cluster-name> \
--zone <your-cluster-zone> \
--enable-autoscaling --max-nodes=4 --min-nodes=0 \
--machine-type n1-highmem-8 \
--preemptible \
--node-taints=preemptible=true:NoSchedule \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=4
Pulę węzłów możesz też skonfigurować za pomocą konsoli Cloud.
Definiowanie potoku Kubeflow, który korzysta z węzłów GKE z możliwością wywłaszczania
Jeśli korzystasz z Kubeflow w GKE, możesz teraz łatwo zdefiniować i uruchomić Kubeflow Pipelines, w których co najmniej 1 krok potoku (komponent) będzie uruchomiony w węzłach z możliwością wywłaszczania, co pozwala ograniczyć koszt uruchomienia zadania. Aby korzystanie z maszyn wirtualnych z możliwością wywłaszczania zapewniało prawidłowe wyniki, kroki oznaczone jako z możliwością wywłaszczania powinny być idempotentne (to znaczy, jeśli powtórzysz krok kilka razy, da to ten sam wynik), albo punkt kontrolny powinien działać tak, aby można było wznowić krok w miejscu, w którym został przerwany.
Podczas definiowania potoku Kubeflow możesz wskazać, że dany krok powinien zostać uruchomiony w węźle z możliwością wywłaszczania:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Więcej informacji znajdziesz w dokumentacji.
Prawdopodobnie będziesz też chcieć ponawiać ten krok kilka razy, jeśli węzeł będzie wywłaszczony. Możesz to zrobić w następujący sposób – w tym miejscu określamy 5 ponownych prób.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Spróbuj zmodyfikować potok Kubeflow, którego użyliśmy w tym ćwiczeniu z programowania, aby uruchomić krok trenowania na maszynie wirtualnej z możliwością wywłaszczania.
Zmień ten wiersz w specyfikacji potoku, aby dodatkowo używać puli węzłów z możliwością wywłaszczania (sprawdź, czy została utworzona w sposób opisany powyżej) i spróbuj ponownie 5 razy:
train.set_gpu_limit(1)
Następnie ponownie skompiluj potok, prześlij nową wersję (nadaj mu nową nazwę), a potem uruchom nową wersję potoku.