1. Introduzione
| Kubeflow è un toolkit di machine learning per Kubernetes. Il progetto è dedicato a rendere i deployment di flussi di lavoro di machine learning (ML) su Kubernetes semplici, portabili e scalabili. L'obiettivo è fornire un modo semplice per eseguire il deployment dei migliori sistemi open source per il machine learning su diverse infrastrutture. |
| Un flusso di lavoro di machine learning può comprendere molti passaggi con dipendenze l'uno dall'altro, dalla preparazione e l'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 blocchi note o script, e cose come il controllo e la riproducibilità diventano sempre più problematici.Kubeflow Pipelines (KFP) aiuta a risolvere questi problemi fornendo un modo per eseguire il deployment di pipeline di machine learning solide e ripetibili insieme a monitoraggio, controllo, monitoraggio delle versioni e riproducibilità. Cloud AI Pipelines semplifica la configurazione di un'installazione KFP. |
Cosa creerai
In questo codelab, creerai un'app web che riassume i problemi di GitHub utilizzando le pipeline di Kubeflow per addestrare e pubblicare un modello. Si basa su un esempio nel repository di esempi di Kubeflow. Al termine, l'infrastruttura conterrà:
- Un cluster Google Kubernetes Engine (GKE) in cui è installato Kubeflow Pipelines (tramite Cloud AI Pipelines).
- Una pipeline che addestra un modello Tensor2Tensor sulle GPU
- Un container di pubblicazione che fornisce previsioni dal modello addestrato
- Una UI che interpreta le previsioni per fornire riassunti dei problemi di GitHub
- Un blocco note 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 GitHub, imparando a prevedere i titoli dei problemi dai corpi dei problemi. Esporta quindi 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 previsioni del modello.
- Installare Kubeflow Pipelines su un cluster GKE
- Come creare ed eseguire flussi di lavoro ML utilizzando Kubeflow Pipelines
- Come definire ed eseguire pipeline da un blocco note di 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 (Google Cloud)
2. Configurazione
Cloud Shell
Visita la console di Google Cloud nel browser e accedi con le tue credenziali di progetto:
Fai clic su "Seleziona un progetto" se necessario, così da poter lavorare con il progetto codelab.
Quindi, fai clic su "Attiva Cloud Shell". in alto a destra nella console per avviare Cloud Shell.
All'avvio di Cloud Shell, ti verrà comunicato il nome del progetto per cui è impostato. Verifica che questa impostazione sia corretta.
Per trovare l'ID progetto, vai al riquadro della home page della console Google Cloud. Se lo schermo è vuoto, fai clic su "Sì". al prompt per creare una dashboard.
Quindi, nel terminale Cloud Shell, esegui questi comandi se necessario per configurare gcloud in modo che utilizzi 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 l'archiviazione dei file della pipeline. Dovrai utilizzare un ID univoco globale, quindi è utile definire un nome di bucket che includa l'ID progetto. Crea il bucket utilizzando il comando gsutil mb (make 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 di Google Cloud.
Facoltativo**: crea un token GitHub**
Questo codelab chiama l'API GitHub per recuperare i dati disponibili pubblicamente. Per evitare una limitazione di frequenza, soprattutto in caso di eventi in cui viene inviato un numero elevato di richieste anonimizzate alle API GitHub, configura un token di accesso senza autorizzazioni. Ciò avviene semplicemente per autorizzarti come singolo utente e non come utente anonimo.
- Vai a https://github.com/settings/tokens e genera un nuovo token senza ambiti.
- Conservalo in un luogo sicuro. Se lo perdi, dovrai eliminarlo e crearne uno nuovo.
Se salti questo passaggio, il lab continuerà a funzionare: le tue opzioni di generazione dei dati di input per testare il modello saranno un po' più limitate.
(Facoltativo) Fissare dashboard utili
Nella console di Google Cloud, blocca le dashboard di Kubernetes Engine e Storage per un accesso più semplice.
Crea un'installazione di AI Platform Pipelines (Hosted Kubeflow Pipelines)
Segui le istruzioni nella sezione "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 di installazione impostato su default.
Dovrai scegliere una zona che supporti Nvidia k80s. Puoi utilizzare us-central1-a o us-central1-c come valore predefinito.
Al termine dell'installazione, prendi nota del nome del cluster e della zona GKE elencati per l'installazione nella dashboard di AI Pipelines e, per comodità, imposta le variabili di ambiente su questi valori.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Configura kubectl per utilizzare le credenziali del tuo nuovo cluster GKE
Dopo la creazione del cluster GKE, configura kubectl in modo che utilizzi le credenziali del nuovo cluster eseguendo questo comando 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 di AI Pipelines per visitare la relativa pagina GKE, poi fai clic su "Connetti" nella parte superiore della pagina. Dal popup, incolla il comando in Cloud Shell.
Questa operazione configura il contesto di kubectl in modo da poter interagire con il cluster. Per verificare la configurazione, esegui questo comando:
kubectl get nodes -o wide
Dovresti vedere 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 pool di nodi abilitati per GPU
Successivamente, applicheremo un daemonset al cluster, che installerà il driver Nvidia su qualsiasi nodo del cluster abilitato per GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Poi esegui questo comando, 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 pool di nodi GPU
Quindi, configureremo un pool di nodi GPU con una dimensione di 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 Pipeline
In Cloud Console, se non ti trovi già al riquadro Pipeline. Quindi fai clic su "APRI PANNELLO PIPELINES" per l'installazione e fai clic su Pipeline nella barra dei menu a sinistra. Se visualizzi un errore di caricamento, aggiorna la scheda. Dovresti vedere una nuova pagina come questa:
Descrizione pipeline
La pipeline che eseguirai prevede diversi passaggi (per maggiori dettagli, consulta l'appendice di questo codelab):
- Un checkpoint del modello esistente è stato copiato nel bucket.
- Un modello Tensor2Tensor viene addestrato utilizzando dati pre-elaborati.
- L'addestramento inizia dal checkpoint del modello esistente copiato nel primo passaggio, per poi procedere con altre centinaia di passaggi. (Ci vorrebbe troppo tempo per l'addestramento completo durante il codelab).
- Al termine dell'addestramento, il passaggio della pipeline esporta il modello in un formato adatto alla pubblicazione da parte della pubblicazione di TensorFlow.
- Viene eseguito il deployment di un'istanza di TensorFlow utilizzando questo modello.
- Viene avviata un'app web per interagire con il modello pubblicato al fine di recuperare le previsioni.
Scarica e compila la pipeline
In questa sezione vedremo come compilare una definizione di pipeline. Per prima cosa dobbiamo installare l'SDK KFP. Esegui il codice in basso 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 nel seguente modo:
python3 gh_summ_hosted_kfp.py
Visualizzerai il file gh_summ_hosted_kfp.py.tar.gz come risultato.
Carica la pipeline compilata
Nella UI web di Kubeflow Pipelines, fai clic su Carica pipeline e seleziona Importa tramite URL. Copia e incolla il seguente URL, che punta alla stessa pipeline che hai appena compilato. Si tratta di alcuni passaggi aggiuntivi per caricare un file da Cloud Shell, quindi stiamo seguendo una scorciatoia.
Assegna un nome alla pipeline (ad es. gh_summ).
Esegui la pipeline
Fai clic sulla pipeline caricata nell'elenco, in modo da visualizzare il grafico statico della pipeline, poi fai clic su Crea esperimento per creare un nuovo esperimento utilizzando la pipeline. Un esperimento è un modo per raggruppare le esecuzioni correlate semanticamente.
Assegna un nome all'esperimento (ad es. lo stesso nome della pipeline, gh_summ), poi fai clic su Avanti per creare l'esperimento.
Verrà visualizzata una pagina in cui puoi inserire i parametri per una corsa e iniziare.
Per compilare i parametri, ti consigliamo di eseguire i comandi riportati di seguito 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:
projectgithub-token(facoltativo)working-dir
Per la directory di lavoro, inserisci un percorso sotto il bucket GCS che hai creato. Includi "gs://" . Per il campo github-token, inserisci il token che hai generato facoltativamente in precedenza oppure lascia invariata la stringa segnaposto se non hai generato un token.
Dopo aver compilato i campi, fai clic su Avvia, quindi sull'esecuzione elencata per visualizzarne i dettagli. Mentre un determinato passaggio della pipeline è in esecuzione, puoi fare clic sul passaggio per avere maggiori informazioni, ad esempio la visualizzazione dei log dei pod. Puoi visualizzare i log per un passaggio della pipeline anche tramite il link ai relativi log di Cloud Logging (Stackdriver), anche se il nodo del cluster è stato eliminato.
Visualizza la definizione della pipeline
Mentre la pipeline è in esecuzione, potresti voler dare un'occhiata più da vicino a come è strutturata e a cosa sta facendo. Trovi maggiori dettagli nella sezione Appendice del codelab.
Visualizza le informazioni di addestramento del modello in TensorBoard
Una volta completato il passaggio di addestramento, seleziona la relativa scheda Visualizzazioni e fai clic sul pulsante blu Start TensorBoard, quindi, quando è pronto, fai clic su Open Tensorboard.
Esplora la dashboard Artefatti ed esecuzioni
Kubeflow Pipelines registra automaticamente i metadati relativi ai passaggi della pipeline mentre viene eseguita. Vengono registrate sia le informazioni relative ad Artifact sia Artifact. Fai clic su queste voci nella barra di navigazione sinistra del pannello per ulteriori informazioni.
Per gli artefatti, puoi visualizzare sia un riquadro Panoramica sia un riquadro Esplora derivazioni.
Apri l'app web creata dalla pipeline e fai alcune previsioni
L'ultimo passaggio della pipeline esegue il deployment di un'app web, che fornisce una UI per eseguire query sul modello addestrato, pubblicato tramite TF Serving, al fine di fare previsioni.
Al termine della pipeline, connettiti all'app web mediante il port forwarding al relativo servizio (stiamo eseguendo il port forwarding perché, per questo codelab, il servizio app web non è configurato per avere un endpoint esterno).
Per trovare il nome del servizio, esegui questo comando in Cloud Shell:
kubectl get services
Cerca un nome di servizio come questo: ghsumm-*-webappsvc nell'elenco.
Quindi, in Cloud Shell, esegui il port forwarding a quel servizio come segue, modificando il comando seguente in modo da utilizzare il nome della tua webappsvc:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Quando il port forwarding è in esecuzione, fai clic su "preview" sopra il riquadro Cloud Shell e, nel menu a discesa, fai clic su "Anteprima sulla porta 8080".
Dovresti visualizzare una pagina come questa in una nuova scheda:
Fai clic sul pulsante Compila 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 includevano un token GitHub valido, in alternativa puoi provare a inserire un URL GitHub nel secondo campo e fare clic su "Genera titolo". Se non hai configurato un token GitHub valido, utilizza solo il campo "Compila problema casuale" .
4. Esegui una pipeline da un blocco note di AI Platform
Puoi anche definire ed eseguire in modo interattivo Kubeflow Pipelines da un blocco note Jupyter utilizzando l'SDK KFP. AI Platform Notebooks, che utilizzeremo in questo codelab, rende tutto questo molto semplice.
Crea un'istanza di blocco note
Creeremo un'istanza di blocco note da Cloud Shell utilizzando la relativa API. In alternativa, puoi creare un blocco note tramite la console Cloud. Per ulteriori 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"
Quindi, 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
Quando esegui per la prima volta questo comando, ti potrebbe essere chiesto di abilitare l'API notebooks per il progetto. Rispondi "y" se sì.
Dopo qualche minuto il server del blocco note sarà operativo. Puoi vedere le tue istanze blocco note elencate nella console Cloud.
Carica il blocco note 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 di blocco note da utilizzare. Il blocco note verrà aperto automaticamente.
Esegui il blocco note
Segui le istruzioni nel blocco note per il resto del lab. Nella sezione "Configurazione" dovrai inserire i tuoi valori prima di eseguire il resto del blocco note.
Se stai utilizzando un tuo progetto, non dimenticare di tornare indietro ed eseguire la sezione "Pulizia" di questo lab.
5. Esegui la pulizia
Non è necessario farlo se utilizzi un account codelab temporaneo, ma ti consigliamo di rimuovere l'installazione delle pipeline e il blocco note se usi il tuo progetto.
Rimuovere il cluster GKE Pipeline
Puoi eliminare il cluster Pipeline dalla console Cloud. (Se vuoi riutilizzare il cluster GKE, puoi semplicemente eliminare l'installazione delle pipeline).
Elimina l'istanza blocco note IA
Se hai eseguito il "Blocco note" Parte del codelab, puoi ELIMINARE o INTERROMPI l'istanza del blocco note dalla console Cloud.
Facoltativo: rimuovi il token GitHub
Vai all'indirizzo https://github.com/settings/tokens e rimuovi il token generato.
6. Appendici
Un'occhiata al codice
Definizione della pipeline
La pipeline utilizzata in questo codelab è definita qui.
Diamo un'occhiata a come viene definito e ai relativi componenti (passaggi). Esamineremo alcuni dei punti salienti, ma consulta la documentazione per ulteriori dettagli.
I passaggi della pipeline di Kubeflow sono basati su container. Quando crei una pipeline, puoi utilizzare componenti predefiniti, con immagini container già create, oppure creare i tuoi componenti. Per questo codelab, abbiamo creato il nostro.
Quattro dei passaggi della pipeline sono definiti da componenti riutilizzabili, accessibili tramite i relativi file di definizione dei componenti. In questo primo snippet di codice, accediamo ai file di definizione dei componenti tramite il relativo URL e utilizziamo queste definizioni per creare "operazioni". 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 vedere che sono definiti gli input, gli output, l'immagine container e gli argomenti del punto di ingresso 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 vedrai di seguito.
Di seguito è riportata la maggior parte della definizione della pipeline. Stiamo definendo gli input della pipeline (e i relativi valori predefiniti). Quindi definiamo i passaggi della pipeline. Per la maggior parte utilizziamo le operazioni definita sopra, ma stiamo anche definendo un'opzione "service" in linea tramite ContainerOp, specificando direttamente l'immagine container e gli argomenti del punto di ingresso.
Puoi vedere 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 il "addestramento" da eseguire su un nodo nel cluster che ha almeno 1 GPU disponibile.
train.set_gpu_limit(1)
L'ultimo passaggio della pipeline, anche definito in linea, è condizionale. Verrà eseguita dopo "serve" viene completato, solo se l'output del passaggio launch_server del passaggio di addestramento è la stringa "true". Avvia l'"app web di previsione", che abbiamo utilizzato per richiedere 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 dell'immagine container del componente
La documentazione di Kubeflow Pipeline descrive alcune best practice per la creazione dei tuoi componenti. Nell'ambito di questo processo, dovrai definire e creare un'immagine container. Puoi vedere i passaggi dei componenti per la pipeline di questo codelab qui. Le definizioni del Dockerfile si trovano nelle sottodirectory containers, ad esempio qui.
Usa VM prerilasciabili con GPU per l'addestramento
Le VM prerilasciabili sono istanze di VM di Compute Engine che durano al massimo 24 ore e non offrono garanzie di disponibilità. I prezzi delle VM prerilasciabili sono inferiori a quelli delle VM standard di Compute Engine.
Con Google Kubernetes Engine (GKE), è facile configurare un cluster o un pool di nodi che utilizza VM prerilasciabili. Puoi configurare un pool di nodi di questo tipo con GPU collegate alle istanze prerilasciabili. Funzionano come i normali nodi abilitati per GPU, ma le GPU rimangono attive solo per tutta la durata dell'istanza.
Puoi configurare un pool di nodi prerilasciabile e abilitato per GPU per il tuo cluster eseguendo un comando simile al seguente, modificando il comando seguente con il nome e la zona del cluster e modificando il tipo e il numero di acceleratori in base ai tuoi requisiti. Facoltativamente, puoi definire il pool di nodi 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 prerilasciabili
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 prerilasciabili, riducendo il costo dell'esecuzione di un job. Per utilizzare le VM prerilasciabili per ottenere risultati corretti, i passaggi identificati come prerilasciabili devono essere idempotenti (in altre parole, se un passaggio viene eseguito più volte, il risultato sarà lo stesso) oppure il punto di controllo deve funzionare in modo che il passaggio possa riprendere da dove era stato interrotto se interrotto.
Quando definisci una pipeline Kubeflow, puoi indicare che un determinato passaggio deve essere eseguito su un nodo prerilasciabile modificando l'operazione in questo modo:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Per ulteriori dettagli, consulta la documentazione.
Se il nodo viene prerilasciato, è probabile che tu voglia anche ripetere il passaggio un certo numero di volte. Puoi farlo come segue: in questo caso abbiamo specificato 5 nuovi tentativi.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Prova a modificare la pipeline Kubeflow utilizzata in questo codelab per eseguire il passaggio di addestramento su una VM prerilasciabile.
Modifica la riga seguente nella specifica della pipeline per utilizzare anche un pool di nodi prerilasciabile (assicurati di averne creato uno come indicato sopra) in alto e riprova 5 volte:
train.set_gpu_limit(1)
Quindi, ricompila la pipeline, carica la nuova versione (assegnale un nuovo nome) ed esegui la nuova versione della pipeline.