1. Introduzione
| Kubeflow è un toolkit di machine learning per Kubernetes. Il progetto è dedicato a rendere i deployment dei flussi di lavoro di machine learning (ML) su Kubernetes semplici, portatili e scalabili. L'obiettivo è fornire un modo semplice per eseguire il deployment di sistemi open source all'avanguardia per il machine learning su diverse infrastrutture. |
| Un flusso di lavoro di machine learning può comportare molti passaggi con dipendenze reciproche, dalla preparazione e analisi dei dati all'addestramento, alla valutazione, al deployment e altro ancora. È difficile comporre e monitorare questi processi in modo ad hoc, ad esempio in un insieme di notebook o script, e aspetti come l'audit e la riproducibilità diventano sempre più problematici.Kubeflow Pipelines (KFP) aiuta a risolvere questi problemi fornendo un modo per implementare pipeline di machine learning robuste e ripetibili, oltre a monitoraggio, audit, monitoraggio delle versioni e riproducibilità. Cloud AI Pipelines semplifica la configurazione di un'installazione di KFP. |
Cosa creerai
In questo codelab creerai un'app web che riepiloga i problemi di GitHub utilizzando Kubeflow Pipelines per addestrare e pubblicare un modello. Si basa su un esempio nel repository Kubeflow Examples. Al termine, l'infrastruttura conterrà:
- Un cluster Google Kubernetes Engine (GKE) con Kubeflow Pipelines installato (tramite Cloud AI Pipelines).
- Una pipeline che addestra un modello Tensor2Tensor sulle GPU
- Un container di pubblicazione che fornisce previsioni dal modello addestrato
- Un'interfaccia utente che interpreta le previsioni per fornire riepiloghi per i problemi di GitHub
- Un notebook che crea una pipeline da zero utilizzando l'SDK Kubeflow Pipelines (KFP)
Cosa imparerai a fare
La pipeline che creerai addestra un modello Tensor2Tensor sui dati dei problemi di GitHub, imparando a prevedere i titoli dei problemi dai relativi corpi. Dopodiché esporta il modello addestrato ed esegue il deployment del modello esportato utilizzando TensorFlow Serving. Il passaggio finale della pipeline avvia un'app web, che interagisce con l'istanza TF-Serving per ottenere le previsioni del modello.
- Come installare Kubeflow Pipelines su un cluster GKE
- Come creare ed eseguire workflow ML utilizzando Kubeflow Pipelines
- Come definire ed eseguire pipeline da un notebook AI Platform
Che cosa ti serve
- Una conoscenza di base di Kubernetes è utile, ma non necessaria
- Un progetto Google Cloud attivo per il quale disponi delle autorizzazioni di proprietario
- (Facoltativo) Un account GitHub
- Accesso a Google Cloud Shell, disponibile nella console di Google Cloud Platform (GCP)
2. Configurazione
Cloud Shell
Visita la console GCP nel browser e accedi con le credenziali del progetto:
Se necessario, fai clic su "Seleziona un progetto" per lavorare con il progetto del codelab.
Poi fai clic sull'icona "Attiva Cloud Shell" in alto a destra della console per avviare Cloud Shell.
Quando avvii Cloud Shell, ti verrà comunicato il nome del progetto che è impostato per l'utilizzo. Verifica che questa impostazione sia corretta.
Per trovare l'ID progetto, visita il pannello Home della console GCP. Se lo schermo è vuoto, fai clic su "Sì" al prompt per creare una dashboard.
Poi, nel terminale Cloud Shell, esegui questi comandi, se necessario, per configurare gcloud in modo da utilizzare il progetto corretto:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Crea un bucket di archiviazione
Crea un bucket Cloud Storage per archiviare i file della pipeline. Dovrai utilizzare un ID univoco a livello globale, quindi è conveniente definire un nome del bucket che includa l'ID progetto. Crea il bucket utilizzando il comando gsutil mb (crea bucket):
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
In alternativa, puoi creare un bucket tramite la console GCP.
Facoltativo**: crea un token GitHub
Questo codelab chiama l'API GitHub per recuperare dati disponibili pubblicamente. Per evitare la limitazione della frequenza, soprattutto in occasione di eventi in cui viene inviato un numero elevato di richieste anonimizzate alle API GitHub, configura un token di accesso senza autorizzazioni. Serve solo per autorizzarti come persona fisica anziché come utente anonimo.
- Vai a https://github.com/settings/tokens e genera un nuovo token senza ambiti.
- Salvala in un luogo sicuro. Se lo perdi, dovrai eliminarlo e crearne uno nuovo.
Se salti questo passaggio, il lab funzionerà comunque, ma avrai opzioni più limitate per generare dati di input per testare il modello.
(Facoltativo) Blocca le dashboard utili
Nella console di GCP, blocca i dashboard Kubernetes Engine e Storage per un accesso più semplice.
Crea un'installazione di AI Platform Pipelines (Kubeflow Pipelines ospitato)
Segui le istruzioni riportate nelle sezioni "Prima di iniziare" e "Configura l'istanza" qui per configurare un'istanza GKE con KFP installato. Assicurati di selezionare la casella Consenti l'accesso alle seguenti API Cloud come indicato nella documentazione. In caso contrario, la pipeline di esempio non verrà eseguita correttamente. Lascia lo spazio dei nomi dell'installazione come default.
Devi scegliere una zona che supporti le Nvidia K80. Puoi utilizzare us-central1-a o us-central1-c come valori predefiniti.
Una volta completata l'installazione, annota il nome del cluster e la zona GKE elencati per l'installazione nella dashboard AI Pipelines e, per comodità, imposta le variabili di ambiente su questi valori.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Configurare kubectl per utilizzare le credenziali del nuovo cluster GKE
Dopo aver creato il cluster GKE, configura kubectl per utilizzare le credenziali del nuovo cluster eseguendo il comando seguente in Cloud Shell:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
In alternativa, fai clic sul nome del cluster nella dashboard AI Pipelines per visitare la relativa pagina GKE, poi fai clic su "Connetti" nella parte superiore della pagina. Nel popup, incolla il comando in Cloud Shell.
In questo modo viene configurato il contesto kubectl in modo da poter interagire con il cluster. Per verificare la configurazione, esegui questo comando:
kubectl get nodes -o wide
Dovresti visualizzare i nodi elencati con lo stato "Ready" e altre informazioni su età, versione, indirizzo IP esterno, immagine del sistema operativo, versione del kernel e runtime del container.
Configura il cluster per installare il driver Nvidia sui node pool abilitati per GPU
Successivamente, applicheremo un daemonset al cluster, che installerà il driver Nvidia su tutti i nodi del cluster abilitati per GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Quindi esegui il comando seguente, che concede ai componenti KFP l'autorizzazione per creare nuove risorse Kubernetes:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Crea un node pool GPU
Poi, configureremo un node pool GPU di dimensioni 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. Eseguire una pipeline dalla dashboard Pipeline
Apri la dashboard Pipelines
Nella console Cloud, visita il riquadro Pipeline se non l'hai già fatto. Poi fai clic su "APRI LA DASHBOARD PIPELINE" per la tua installazione e su Pipeline nella barra dei menu a sinistra. Se viene visualizzato un errore di caricamento, aggiorna la scheda. Dovresti visualizzare una nuova pagina simile a questa:
Descrizione della pipeline
La pipeline che eseguirai prevede diversi passaggi (per i dettagli, consulta l'appendice di questo codelab):
- Un checkpoint del modello esistente viene copiato nel bucket.
- Un modello Tensor2Tensor viene addestrato utilizzando dati preelaborati.
- L'addestramento inizia dal checkpoint del modello esistente copiato nel primo passaggio, quindi viene eseguito per qualche centinaio di passaggi in più. L'addestramento completo richiederebbe troppo tempo durante il codelab.
- Al termine dell'addestramento, il passaggio della pipeline esporta il modello in un formato adatto alla distribuzione da parte di TensorFlow Serving.
- Viene eseguito il deployment di un'istanza di TensorFlow Serving utilizzando questo modello.
- Viene avviata un'app web per interagire con il modello pubblicato per recuperare le previsioni.
Scaricare e compilare la pipeline
In questa sezione vedremo come compilare una definizione di pipeline. La prima cosa da fare è installare l'SDK KFP. Esegui il comando riportato di seguito in Cloud Shell:
pip3 install -U kfp
Per scaricare il file di definizione della pipeline, esegui questo comando da Cloud Shell:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Quindi, compila il file di definizione della pipeline eseguendolo in questo modo:
python3 gh_summ_hosted_kfp.py
Vedrai il file gh_summ_hosted_kfp.py.tar.gz visualizzato come risultato.
Carica la pipeline compilata
Nell'interfaccia utente web di Kubeflow Pipelines, fai clic su Carica pipeline e seleziona Importa per URL. Copia e incolla il seguente URL, che rimanda alla stessa pipeline che hai appena compilato. Il caricamento di un file da Cloud Shell richiede alcuni passaggi aggiuntivi, quindi stiamo prendendo una scorciatoia.
Assegna un nome alla pipeline (ad es. gh_summ).
Esegui la pipeline
Fai clic sulla pipeline caricata nell'elenco per visualizzare il grafico statico della pipeline, quindi fai clic su Crea esperimento per creare un nuovo esperimento utilizzando la pipeline. Un esperimento è un modo per raggruppare esecuzioni semanticamente correlate.
Assegna un nome all'esperimento (ad es. lo stesso nome della pipeline, gh_summ), quindi fai clic su Avanti per crearlo.
Verrà visualizzata una pagina in cui puoi inserire i parametri per una corsa e avviarla.
Per compilare i parametri, puoi eseguire i seguenti comandi in Cloud Shell.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Il nome dell'esecuzione verrà compilato automaticamente, ma puoi assegnargli un nome diverso, se vuoi.
Poi compila tre campi dei parametri:
project- (facoltativo)
github-token working-dir
Per working-dir, inserisci un percorso nel bucket GCS che hai creato. Includi il prefisso "gs://". Per il campo github-token, inserisci il token che hai generato facoltativamente in precedenza oppure lascia la stringa segnaposto così com'è se non hai generato un token.
Dopo aver compilato i campi, fai clic su Avvia, quindi fai clic sull'esecuzione elencata per visualizzarne i dettagli. Mentre è in esecuzione un determinato passaggio della pipeline, puoi farci clic sopra per visualizzare ulteriori informazioni, inclusi i log dei pod. Puoi anche visualizzare i log di un passaggio della pipeline tramite il link ai log di Cloud Logging (Stackdriver), anche se il nodo del cluster è stato eliminato.
Visualizza la definizione della pipeline
Mentre la pipeline è in esecuzione, ti consigliamo di dare un'occhiata più da vicino a come è strutturata e a cosa sta facendo. Per maggiori dettagli, consulta la sezione Appendice del codelab.
Visualizzare le informazioni sull'addestramento del modello in TensorBoard
Una volta completato il passaggio di addestramento, seleziona la scheda Visualizzazioni e fai clic sul pulsante blu Avvia TensorBoard, quindi, quando è pronto, fai clic su Apri TensorBoard.
Esplorare la dashboard Artefatti ed esecuzioni
Kubeflow Pipelines registra automaticamente i metadati relativi ai passaggi della pipeline durante l'esecuzione. Vengono registrate sia le informazioni sull'artefatto che sull'esecuzione. Fai clic su queste voci nella barra di navigazione a sinistra della dashboard per esplorare ulteriormente.
Per gli artefatti, puoi visualizzare sia un riquadro di panoramica sia un riquadro di Esplora derivazione.
Visualizza l'app web creata dalla pipeline ed esegui alcune previsioni
L'ultimo passaggio della pipeline esegue il deployment di un'app web, che fornisce una UI per interrogare il modello addestrato, fornito tramite TF Serving, per fare previsioni.
Al termine della pipeline, connettiti all'app web tramite port forwarding al relativo servizio (il port forwarding è necessario perché, per questo codelab, il servizio dell'app web non è configurato per avere un endpoint esterno).
Trova il nome del servizio eseguendo questo comando in Cloud Shell:
kubectl get services
Cerca nell'elenco un nome di servizio come ghsumm-*-webappsvc.
Poi, in Cloud Shell, esegui il port forwarding al servizio nel seguente modo, modificando il comando seguente per utilizzare il nome di webappsvc:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Una volta eseguito l'inoltro delle porte, fai clic sull'icona "Anteprima" sopra il riquadro Cloud Shell e, nel menu a discesa, fai clic su "Anteprima sulla porta 8080".
In una nuova scheda dovrebbe aprirsi una pagina simile a questa:
Fai clic sul pulsante Popola problema casuale per recuperare un blocco di testo. Fai clic su Genera titolo per chiamare il modello addestrato e visualizzare una previsione.
Se i parametri della pipeline includono un token GitHub valido, puoi provare in alternativa a inserire un URL GitHub nel secondo campo, quindi fare clic su "Genera titolo". Se non hai configurato un token GitHub valido, utilizza solo il campo "Popola problema casuale".
4. Eseguire una pipeline da un notebook AI Platform
Puoi anche definire ed eseguire in modo interattivo le pipeline Kubeflow da un blocco note Jupyter utilizzando l'SDK KFP. AI Platform Notebooks, che utilizzeremo per questo codelab, rende tutto molto semplice.
Crea un'istanza di blocco note
Creeremo un'istanza notebook da Cloud Shell utilizzando la relativa API. In alternativa, puoi creare un notebook tramite Cloud Console. Per maggiori informazioni, consulta la documentazione.
Imposta le seguenti variabili di ambiente in Cloud Shell:
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"
Poi, da Cloud Shell, esegui il comando per creare l'istanza del blocco note:
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
La prima volta che esegui questo comando, potrebbe esserti chiesto di abilitare l'API notebooks per il tuo progetto. In caso affermativo, rispondi "y".
Dopo qualche minuto, il server notebook sarà attivo e funzionante. Puoi visualizzare le tue istanze notebook elencate in Cloud Console.
Carica il notebook del codelab
Dopo aver creato l'istanza di blocco note, fai clic su questo link per caricare il blocco note Jupyter del codelab. Seleziona l'istanza notebook da utilizzare. Il notebook verrà aperto automaticamente.
Esegui il notebook
Segui le istruzioni nel notebook per il resto del lab. Tieni presente che nella sezione "Configurazione" del blocco note dovrai inserire i tuoi valori prima di eseguire il resto del blocco note.
Se utilizzi il tuo progetto, non dimenticare di tornare alla sezione "Pulizia" di questo lab.
5. Esegui la pulizia
Non è necessario eseguire questa operazione se utilizzi un account codelab temporaneo, ma potresti voler rimuovere l'installazione di Pipelines e Notebook se utilizzi il tuo progetto.
Disattiva il cluster GKE di Pipelines
Puoi eliminare il cluster Pipelines dalla console Google Cloud. Se vuoi riutilizzare il cluster GKE, puoi eliminare solo l'installazione di Pipelines.
Elimina l'istanza di AI Notebook
Se hai eseguito la parte "Notebook" del codelab, puoi ELIMINARE o ARRESTARE l'istanza del notebook dalla console Cloud.
(Facoltativo) Rimuovi il token GitHub
Vai a https://github.com/settings/tokens e rimuovi il token generato.
6. Appendici
Uno sguardo al codice
Definizione della pipeline
La pipeline utilizzata in questo codelab è definita qui.
Diamo un'occhiata a come viene definita, nonché a come vengono definiti i suoi componenti (passaggi). Esamineremo alcuni punti salienti, ma per ulteriori dettagli consulta la documentazione.
I passaggi della pipeline Kubeflow sono basati su container. Quando crei una pipeline, puoi utilizzare componenti predefiniti con immagini container già create o creare i tuoi componenti. Per questo codelab, ne abbiamo creato uno nostro.
Quattro dei passaggi della pipeline sono definiti da componenti riutilizzabili, a cui si accede tramite i relativi file di definizione dei componenti. In questo primo snippet di codice, accediamo a questi file di definizione dei componenti tramite il loro URL e utilizziamo queste definizioni per creare "ops" che utilizzeremo per creare un passaggio della pipeline.
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'
)
Di seguito è riportata una delle definizioni dei componenti, per l'operazione di addestramento, in formato YAML. Puoi notare che sono definiti gli input, gli output, l'immagine container e gli argomenti dell'entrypoint del container.
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
Puoi anche definire un passaggio della pipeline tramite il costruttore dsl.ContainerOp, come vedremo di seguito.
Di seguito è riportata la maggior parte della definizione della pipeline. Stiamo definendo gli input della pipeline (e i relativi valori predefiniti). Poi definiamo i passaggi della pipeline. Per la maggior parte utilizziamo le "operazioni" definite sopra, ma definiamo anche un passaggio "serve" inline tramite ContainerOp, specificando direttamente l'immagine container e gli argomenti del punto di ingresso.
Puoi notare che i passaggi train, log_model e serve accedono agli output dei passaggi precedenti come input. Puoi scoprire di più su come viene specificato qui.
@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)
Tieni presente che richiediamo l'esecuzione del passaggio "train" su un nodo del cluster che abbia almeno una GPU disponibile.
train.set_gpu_limit(1)
L'ultimo passaggio della pipeline, definito anche inline, è condizionale. Verrà eseguito al termine del passaggio "serve", solo se l'output del passaggio di addestramento launch_server è la stringa "true". Avvia l'app web di previsione, che abbiamo utilizzato per richiedere i riepiloghi dei problemi dal modello T2T addestrato.
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)
Definizioni delle immagini container dei componenti
La documentazione di Kubeflow Pipelines descrive alcune best practice per la creazione di componenti personalizzati. Nell'ambito di questa procedura, dovrai definire e creare un'immagine container. Puoi visualizzare i passaggi dei componenti della pipeline di questo codelab qui. Le definizioni di Dockerfile si trovano nelle sottodirectory containers, ad esempio qui.
Utilizza VM preemptible con GPU per l'addestramento
Le VM prerilasciabili sono istanze VM Compute Engine che durano un massimo di 24 ore e non offrono garanzie di disponibilità. Il prezzo delle VM prerilasciabili è inferiore a quello delle VM di Compute Engine standard.
Con Google Kubernetes Engine (GKE), è facile configurare un cluster o un pool di nodi che utilizza VM preemptive. Puoi configurare un node pool di questo tipo con GPU collegate alle istanze prerilasciabili. Questi nodi funzionano come i normali nodi abilitati alla GPU, ma le GPU rimangono attive solo per la durata dell'istanza.
Puoi configurare un node pool prerilasciabile abilitato per la GPU per il tuo cluster eseguendo un comando simile al seguente, modificando il comando con il nome e la zona del cluster e regolando il tipo e il conteggio dell'acceleratore in base ai tuoi requisiti. Puoi definire facoltativamente il node pool per la scalabilità automatica in base ai carichi di lavoro attuali.
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
Puoi anche configurare un pool di nodi tramite la console Cloud.
Definizione di una pipeline Kubeflow che utilizza i nodi GKE preemptible
Se esegui Kubeflow su GKE, ora è facile definire ed eseguire pipeline Kubeflow in cui uno o più passaggi (componenti) della pipeline vengono eseguiti su nodi preemptive, riducendo il costo di esecuzione di un job. Affinché l'utilizzo delle VM preemptible dia risultati corretti, i passaggi che identifichi come preemptible devono essere idempotenti (ovvero, se esegui un passaggio più volte, il risultato sarà lo stesso) oppure devono salvare il lavoro in modo che il passaggio possa riprendere da dove era stato interrotto.
Quando definisci una pipeline Kubeflow, puoi indicare che un determinato passaggio deve essere eseguito su un nodo preemptive modificando l'operazione nel seguente modo:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Per ulteriori dettagli, consulta la documentazione.
Presumibilmente, vorrai anche riprovare il passaggio un certo numero di volte se il nodo viene interrotto. Puoi farlo nel seguente modo: qui specifichiamo 5 tentativi.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Prova a modificare la pipeline Kubeflow che abbiamo utilizzato in questo codelab per eseguire il passaggio di addestramento su una VM prerilasciabile.
Modifica la seguente riga nella specifica della pipeline per utilizzare anche un nodepool preemptive (assicurati di averne creato uno come indicato sopra) e per riprovare 5 volte:
train.set_gpu_limit(1)
Poi, ricompila la pipeline, carica la nuova versione (assegnale un nuovo nome) ed esegui la nuova versione della pipeline.