1. Introduction
| Kubeflow est un kit d'outils de machine learning pour Kubernetes. Ce projet vise à simplifier le déploiement des processus de machine learning (ML) sur Kubernetes, et à les rendre portables et évolutifs. L'objectif est de proposer un outil permettant de déployer les meilleurs systèmes Open Source pour le ML sur des infrastructures diverses. |
| Un workflow de machine learning peut comporter de nombreuses étapes interdépendantes, de la préparation et de l'analyse des données à l'entraînement, à l'évaluation, au déploiement, etc. Il est difficile de composer et de suivre ces processus de manière ad hoc (par exemple, dans un ensemble de notebooks ou de scripts), et des aspects tels que l'audit et la reproductibilité deviennent de plus en plus problématiques.Kubeflow Pipelines (KFP) permet de résoudre ces problèmes en fournissant un moyen de déployer des pipelines de machine learning robustes et reproductibles, ainsi que des fonctionnalités de surveillance, d'audit, de gestion des versions et de reproductibilité. Cloud AI Pipelines facilite la configuration d'une installation KFP. |
Objectifs de l'atelier
Dans cet atelier de programmation, vous allez créer une application Web qui résume des problèmes GitHub à l'aide de Kubeflow Pipelines pour entraîner et diffuser un modèle. Il est basé sur un exemple du dépôt d'exemples Kubeflow. À la fin de cet atelier, votre infrastructure comprendra les éléments suivants :
- Un cluster Google Kubernetes Engine (GKE) avec Kubeflow Pipelines installé (via Cloud AI Pipelines).
- Pipeline qui entraîne un modèle Tensor2Tensor sur des GPU
- Un conteneur de diffusion fournissant des prédictions à partir du modèle entraîné
- Une UI qui interprète les prédictions pour fournir des résumés des problèmes GitHub
- Notebook qui crée un pipeline de A à Z à l'aide du SDK Kubeflow Pipelines (KFP)
Points abordés
Le pipeline que vous allez créer entraîne un modèle Tensor2Tensor sur les données des problèmes GitHub, en apprenant à prédire les titres des problèmes à partir de leur corps. Il exporte ensuite le modèle entraîné et le déploie à l'aide de Tensorflow Serving. La dernière étape du pipeline lance une application Web qui interagit avec l'instance TF-Serving pour obtenir des prédictions de modèle.
- Installer Kubeflow Pipelines sur un cluster GKE
- Créer et exécuter des workflows de ML à l'aide de Kubeflow Pipelines
- Définir et exécuter des pipelines à partir d'un notebook AI Platform
Prérequis
- Il est utile d'avoir des connaissances de base sur Kubernetes, mais ce n'est pas obligatoire.
- Un projet GCP actif pour lequel vous disposez des autorisations de propriétaire
- (Facultatif) Un compte GitHub
- Accès à Google Cloud Shell, disponible dans la console Google Cloud Platform (GCP)
2. Configuration
Cloud Shell
Accédez à la console GCP dans le navigateur et connectez-vous avec les identifiants de votre projet :
Si nécessaire, cliquez sur "Sélectionner un projet" pour travailler sur votre projet d'atelier de programmation.
Cliquez ensuite sur l'icône "Activer Cloud Shell" en haut à droite de la console pour démarrer un terminal Cloud Shell.
Lorsque vous démarrez Cloud Shell, le nom du projet qu'il est configuré pour utiliser s'affiche. Vérifiez que ce paramètre est correct.
Pour trouver l'ID de votre projet, accédez au panneau "Accueil" de la console GCP. Si l'écran est vide, cliquez sur "Oui" à l'invite pour créer un tableau de bord.
Ensuite, dans le terminal Cloud Shell, exécutez ces commandes si nécessaire pour configurer gcloud afin qu'il utilise le bon projet :
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Créer un bucket de stockage
Créez un bucket Cloud Storage pour stocker les fichiers du pipeline. Vous devrez utiliser un ID unique au niveau mondial. Il est donc pratique de définir un nom de bucket qui inclut votre ID de projet. Créez le bucket à l'aide de la commande gsutil mb (créer un bucket) :
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
Vous pouvez également créer un bucket dans la console GCP.
Facultatif : créez un jeton GitHub
Cet atelier de programmation appelle l'API GitHub pour récupérer des données accessibles au public. Pour éviter toute limitation du débit, en particulier lorsque vous enverrez un grand nombre de requêtes anonymes aux API GitHub, créez un jeton d'accès dépourvu d'autorisations. Vous disposerez ainsi d'une autorisation personnelle et ne serez plus considéré comme un utilisateur anonyme.
- Accédez à https://github.com/settings/tokens et générez un jeton sans aucun champ d'application.
- Enregistrez-le dans un endroit sûr. Si vous le perdez, vous devrez le supprimer et en créer un autre.
Si vous ignorez cette étape, l'atelier fonctionnera quand même. Vous aurez simplement un peu moins d'options pour générer des données d'entrée afin de tester votre modèle.
Facultatif : épingler des tableaux de bord utiles
Dans la console GCP, épinglez les tableaux de bord Kubernetes Engine et Storage pour y accéder plus facilement.
Créer une installation AI Platform Pipelines (Kubeflow Pipelines hébergé)
Suivez les instructions des sections "Avant de commencer" et "Configurer votre instance" ici pour configurer une instance GKE avec KFP installé. Veillez à cocher la case Autoriser l'accès aux API Cloud suivantes, comme indiqué dans la documentation. (Sinon, l'exemple de pipeline ne s'exécutera pas correctement.) Laissez l'espace de noms de l'installation sur default.
Vous devrez sélectionner une zone compatible avec les GPU Nvidia K80. Vous pouvez utiliser us-central1-a ou us-central1-c comme valeurs par défaut.
Notez le nom du cluster et la zone GKE listés pour votre installation dans le tableau de bord AI Pipelines une fois l'installation terminée, et définissez des variables d'environnement sur ces valeurs pour plus de commodité.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Configurer kubectl pour utiliser les identifiants de votre nouveau cluster GKE
Une fois le cluster GKE créé, configurez kubectl pour qu'il utilise les identifiants du nouveau cluster en exécutant la commande suivante dans Cloud Shell :
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
Vous pouvez également cliquer sur le nom du cluster dans le tableau de bord AI Pipelines pour accéder à sa page GKE, puis cliquer sur "Se connecter" en haut de la page. Dans le pop-up, collez la commande dans Cloud Shell.
Cela configure votre contexte kubectl afin que vous puissiez interagir avec votre cluster. Pour valider la configuration, exécutez la commande suivante :
kubectl get nodes -o wide
Vous devriez voir des nœuds listés avec l'état "Ready", ainsi que d'autres informations sur l'âge, la version, l'adresse IP externe, l'image OS, la version du noyau et le moteur de conteneur des nœuds.
Configurer le cluster pour installer le pilote Nvidia sur les pools de nœuds compatibles avec les GPU
Ensuite, nous appliquerons un daemonset au cluster, qui installera le pilote Nvidia sur tous les nœuds de cluster compatibles avec les GPU :
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Exécutez ensuite la commande suivante, qui autorise les composants KFP à créer des ressources Kubernetes :
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Créer un pool de nœuds GPU
Nous allons ensuite configurer un pool de nœuds GPU de taille 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. Exécuter un pipeline à partir du tableau de bord "Pipelines"
Ouvrir le tableau de bord Pipelines
Dans la console Cloud, accédez au panneau "Pipelines" si vous ne l'avez pas déjà fait. Cliquez ensuite sur OUVRIR LE TABLEAU DE BORD DES PIPELINES pour votre installation, puis sur Pipelines dans la barre de menu de gauche. Si une erreur de chargement s'affiche, actualisez l'onglet. Une nouvelle page semblable à celle-ci s'affiche :
Description du pipeline
Le pipeline que vous allez exécuter comporte plusieurs étapes (consultez l'annexe de cet atelier de programmation pour en savoir plus) :
- Un point de contrôle de modèle existant est copié dans votre bucket.
- Un modèle Tensor2Tensor est entraîné à l'aide de données prétraitées.
- L'entraînement commence à partir du point de contrôle du modèle existant copié lors de la première étape, puis s'entraîne pendant quelques centaines d'étapes supplémentaires. (L'entraînement complet prendrait trop de temps pendant l'atelier de programmation.)
- Une fois l'entraînement terminé, l'étape du pipeline exporte le modèle dans un format adapté à la diffusion par TensorFlow Serving.
- Une instance TensorFlow Serving est déployée à l'aide de ce modèle.
- Une application Web est lancée pour interagir avec le modèle diffusé et récupérer les prédictions.
Télécharger et compiler le pipeline
Dans cette section, nous allons voir comment compiler une définition de pipeline. La première chose à faire est d'installer le SDK KFP. Exécutez la commande suivante dans Cloud Shell :
pip3 install -U kfp
Pour télécharger le fichier de définition du pipeline, exécutez la commande suivante depuis Cloud Shell :
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Ensuite, compilez le fichier de définition du pipeline en l'exécutant comme suit :
python3 gh_summ_hosted_kfp.py
Le fichier gh_summ_hosted_kfp.py.tar.gz s'affiche dans les résultats.
Importer le pipeline compilé
Dans l'interface utilisateur Web de Kubeflow Pipelines, cliquez sur Upload pipeline (Importer le pipeline), puis sélectionnez Import by URL (Importer par URL). Copiez, puis collez l'URL suivante, qui pointe vers le même pipeline que vous venez de compiler. (L'importation d'un fichier depuis Cloud Shell nécessite quelques étapes supplémentaires. Nous allons donc prendre un raccourci.)
Donnez un nom au pipeline (par exemple, gh_summ).
Exécuter le pipeline
Cliquez sur le pipeline importé dans la liste (cela vous permet d'afficher le graphique statique du pipeline), puis cliquez sur Créer un test pour créer un test à l'aide du pipeline. Un test permet de regrouper des exécutions présentant des relations sémantiques.
Donnez un nom au test (par exemple, le même nom que le pipeline, gh_summ), puis cliquez sur Suivant pour le créer.
Une page s'affiche, vous permettant de saisir les paramètres d'une exécution et de la lancer.
Vous pouvez exécuter les commandes suivantes dans Cloud Shell pour vous aider à renseigner les paramètres.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Le nom de l'exécution est renseigné automatiquement, mais vous pouvez lui donner un autre nom si vous le souhaitez.
Renseignez ensuite trois champs de paramètres :
project- (facultatif)
github-token working-dir
Pour le répertoire de travail, saisissez un chemin d'accès sous le bucket GCS que vous avez créé. Incluez le préfixe "gs://". Dans le champ github-token, saisissez le jeton que vous avez éventuellement généré précédemment ou laissez la chaîne d'espace réservé telle quelle si vous n'avez pas généré de jeton.
Après avoir rempli les champs, cliquez sur Démarrer, puis sur l'exécution listée pour afficher ses détails. Lorsqu'une étape du pipeline est en cours d'exécution, vous pouvez cliquer dessus pour obtenir plus d'informations, y compris les journaux pod. (Vous pouvez également afficher les journaux d'une étape de pipeline en cliquant sur le lien vers ses journaux Cloud Logging (Stackdriver), même si le nœud du cluster a été arrêté.)
Afficher la définition du pipeline
Pendant l'exécution du pipeline, vous pouvez examiner de plus près sa structure et son fonctionnement. Pour en savoir plus, consultez la section Annexe de l'atelier de programmation.
Afficher les informations sur l'entraînement du modèle dans TensorBoard
Une fois l'étape d'entraînement terminée, sélectionnez l'onglet Visualisations, puis cliquez sur le bouton bleu Démarrer TensorBoard. Une fois que TensorBoard est prêt, cliquez sur Ouvrir TensorBoard.
Explorer le tableau de bord "Artefacts et exécutions"
Kubeflow Pipelines enregistre automatiquement les métadonnées sur les étapes du pipeline lors de son exécution. Les informations sur les artefacts et les exécutions sont enregistrées. Cliquez sur ces entrées dans la barre de navigation de gauche du tableau de bord pour en savoir plus.
Pour les artefacts, vous pouvez afficher un panneau "Vue d'ensemble" et un panneau "Explorateur de traçabilité".
Afficher l'application Web créée par le pipeline et effectuer des prédictions
La dernière étape du pipeline consiste à déployer une application Web qui fournit une interface utilisateur permettant d'interroger le modèle entraîné (diffusé via TF Serving) pour effectuer des prédictions.
Une fois le pipeline terminé, connectez-vous à l'application Web en transférant le port vers son service (nous transférons le port, car pour cet atelier de programmation, le service d'application Web n'est pas configuré pour disposer d'un point de terminaison externe).
Exécutez la commande suivante dans Cloud Shell pour trouver le nom du service :
kubectl get services
Recherchez un nom de service tel que ghsumm-*-webappsvc dans la liste.
Ensuite, dans Cloud Shell, transférez le port vers ce service comme suit, en modifiant la commande suivante pour utiliser le nom de votre webappsvc :
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Une fois le transfert de port en cours d'exécution, cliquez sur l'icône "Aperçu" au-dessus du volet Cloud Shell, puis sur "Aperçu sur le port 8080" dans le menu déroulant.
Une page semblable à celle-ci devrait s'ouvrir dans un nouvel onglet :
Cliquez sur le bouton Populate Random Issue (Compléter avec un problème aléatoire) pour récupérer un bloc de texte. Cliquez sur Generate Title (Générer un titre) pour appeler le modèle entraîné et afficher une prédiction.
Si les paramètres de votre pipeline incluent un jeton GitHub valide, vous pouvez également essayer de saisir une URL GitHub dans le deuxième champ, puis de cliquer sur "Générer un titre". Si vous n'avez pas configuré de jeton GitHub valide, utilisez uniquement le champ "Remplir un problème aléatoire".
4. Exécuter un pipeline à partir d'un notebook AI Platform
Vous pouvez également définir et exécuter des pipelines Kubeflow de manière interactive à partir d'un notebook Jupyter à l'aide du SDK KFP. AI Platform Notebooks, que nous utiliserons pour cet atelier de programmation, simplifie grandement cette tâche.
Créer une instance de notebook
Nous allons créer une instance de notebook à partir de Cloud Shell à l'aide de son API. (Vous pouvez également créer un notebook dans la console Cloud.) Pour en savoir plus, consultez la documentation.
Définissez les variables d'environnement suivantes dans 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"
Ensuite, dans Cloud Shell, exécutez la commande pour créer l'instance de notebook :
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
Lorsque vous exécutez cette commande pour la première fois, vous pouvez être invité à activer l'API notebooks pour votre projet. Si c'est le cas, répondez y.
Au bout de quelques minutes, votre serveur de notebooks sera opérationnel. Vous pouvez voir vos instances de notebooks listées dans la console Cloud.
Importer le notebook de l'atelier de programmation
Une fois l'instance de notebook créée, cliquez sur ce lien pour importer le notebook Jupyter de l'atelier de programmation. Sélectionnez l'instance de notebook à utiliser. Le notebook s'ouvre automatiquement.
Exécuter le notebook
Suivez les instructions du notebook pour le reste de l'atelier. Notez que dans la partie "Configuration" du notebook, vous devrez saisir vos propres valeurs avant d'exécuter le reste du notebook.
(Si vous utilisez votre propre projet, n'oubliez pas de revenir en arrière et de suivre la section "Nettoyage" de cet atelier.)
5. Effectuer un nettoyage
Vous n'avez pas besoin de le faire si vous utilisez un compte Codelab temporaire, mais vous pouvez désinstaller Pipelines et Notebook si vous utilisez votre propre projet.
Arrêter le cluster GKE de Pipelines
Vous pouvez supprimer le cluster Pipelines depuis la console Cloud. (Vous pouvez simplement supprimer l'installation de Pipelines si vous souhaitez réutiliser le cluster GKE.)
Supprimer l'instance de notebook AI
Si vous avez exécuté la partie "Notebook" de l'atelier de programmation, vous pouvez SUPPRIMER ou ARRÊTER l'instance de notebook depuis la console Cloud.
Facultatif : Supprimez le jeton GitHub.
Accédez à https://github.com/settings/tokens et supprimez le jeton généré.
6. Annexes
Examiner le code
Définir le pipeline
Le pipeline utilisé dans cet atelier de programmation est défini ici.
Examinons sa définition et celle de ses composants (étapes). Nous aborderons certains points importants, mais consultez la documentation pour en savoir plus.
Les étapes du pipeline Kubeflow sont basées sur des conteneurs. Lorsque vous créez un pipeline, vous pouvez utiliser des composants prédéfinis avec des images de conteneur déjà créées, ou créer vos propres composants. Pour cet atelier de programmation, nous avons créé le nôtre.
Quatre des étapes du pipeline sont définies à partir de composants réutilisables, accessibles via leurs fichiers de définition de composant. Dans ce premier extrait de code, nous accédons à ces fichiers de définition de composants via leur URL et nous utilisons ces définitions pour créer des "ops" que nous utiliserons pour créer une étape de 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'
)
Vous trouverez ci-dessous l'une des définitions de composant, pour l'opération d'entraînement, au format YAML. Vous pouvez constater que ses entrées, ses sorties, son image de conteneur et ses arguments de point d'entrée de conteneur sont définis.
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
Vous pouvez également définir une étape de pipeline via le constructeur dsl.ContainerOp, comme nous le verrons ci-dessous.
Vous trouverez ci-dessous l'essentiel de la définition du pipeline. Nous définissons les entrées du pipeline (et leurs valeurs par défaut). Nous définissons ensuite les étapes du pipeline. Pour la plupart, nous utilisons les "ops" définis ci-dessus, mais nous définissons également une étape "serve" en ligne via ContainerOp, en spécifiant directement l'image de conteneur et les arguments de point d'entrée.
Vous pouvez constater que les étapes train, log_model et serve accèdent aux sorties des étapes précédentes en tant qu'entrées. Pour en savoir plus sur la façon dont cela est spécifié, cliquez ici.
@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)
Notez que nous exigeons que l'étape "train" s'exécute sur un nœud du cluster disposant d'au moins un GPU.
train.set_gpu_limit(1)
La dernière étape du pipeline, également définie de manière intégrée, est conditionnelle. Il s'exécutera une fois l'étape serve terminée, uniquement si le résultat de l'étape d'entraînement launch_server est la chaîne "true". Il lance l'application Web de prédiction que nous avons utilisée pour demander des résumés de problèmes à partir du modèle T2T entraîné.
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)
Définitions des images de conteneur de composants
La documentation de Kubeflow Pipelines décrit certaines bonnes pratiques pour créer vos propres composants. Dans le cadre de ce processus, vous devrez définir et créer une image de conteneur. Vous pouvez consulter les étapes des composants du pipeline de cet atelier de programmation ici. Les définitions Dockerfile se trouvent dans les sous-répertoires containers, par exemple ici.
Utiliser des VM préemptives avec des GPU pour l'entraînement
Les VM préemptives sont des instances de VM Compute Engine qui durent jusqu'à 24 heures et n'offrent aucune garantie de disponibilité. Le prix des VM préemptives est inférieur à celui des VM Compute Engine standards.
Avec Google Kubernetes Engine (GKE), il est facile de configurer un cluster ou un pool de nœuds qui utilise des VM préemptives. Vous pouvez configurer un tel pool de nœuds avec des GPU associés aux instances préemptives. Ils fonctionnent de la même manière que les nœuds compatibles avec les GPU classiques, mais les GPU ne sont conservés que pendant la durée de vie de l'instance.
Vous pouvez configurer un pool de nœuds préemptifs compatibles avec les GPU pour votre cluster en exécutant une commande semblable à la suivante. Modifiez la commande suivante en indiquant le nom et la zone de votre cluster, puis ajustez le type et le nombre d'accélérateurs en fonction de vos besoins. Vous pouvez éventuellement définir le pool de nœuds pour qu'il s'adapte automatiquement en fonction des charges de travail actuelles.
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
Vous pouvez également configurer un pool de nœuds via la console Cloud.
Définir un pipeline Kubeflow qui utilise les nœuds GKE préemptifs
Si vous exécutez Kubeflow sur GKE, il est désormais facile de définir et d'exécuter des pipelines Kubeflow dans lesquels une ou plusieurs étapes de pipeline (composants) s'exécutent sur des nœuds préemptibles, ce qui réduit le coût d'exécution d'un job. Pour que l'utilisation de VM préemptives donne des résultats corrects, les étapes que vous identifiez comme préemptives doivent être idempotentes (c'est-à-dire que si vous exécutez une étape plusieurs fois, le résultat sera le même) ou doivent enregistrer le travail afin que l'étape puisse reprendre là où elle s'est arrêtée en cas d'interruption.
Lorsque vous définissez un pipeline Kubeflow, vous pouvez indiquer qu'une étape donnée doit s'exécuter sur un nœud préemptible en modifiant l'opération comme suit :
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Pour en savoir plus, consultez la documentation.
Vous souhaiterez probablement également réessayer l'étape un certain nombre de fois si le nœud est préempté. Pour ce faire, procédez comme suit (ici, nous spécifions cinq tentatives) :
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Essayez de modifier le pipeline Kubeflow que nous avons utilisé dans cet atelier de programmation pour exécuter l'étape d'entraînement sur une VM préemptive.
Modifiez la ligne suivante dans la spécification du pipeline pour utiliser en plus un pool de nœuds préemptifs (assurez-vous d'en avoir créé un comme indiqué ci-dessus) et pour réessayer cinq fois :
train.set_gpu_limit(1)
Recompilez ensuite le pipeline, importez la nouvelle version (donnez-lui un nouveau nom), puis exécutez-la.