1. Introducción
| Kubeflow es un kit de herramientas de aprendizaje automático para Kubernetes. El objetivo del proyecto es que las implementaciones de flujos de trabajo de aprendizaje automático (AA) en Kubernetes sean simples, portátiles y escalables. El objetivo es ofrecer una forma directa de implementar sistemas de código abierto de primer nivel para el AA en infraestructuras diversas. |
| Un flujo de trabajo de aprendizaje automático puede implicar muchos pasos con dependencias entre sí, desde la preparación y el análisis de datos hasta el entrenamiento, la evaluación, la implementación y mucho más. Es difícil componer y rastrear estos procesos de manera ad hoc (por ejemplo, en un conjunto de notebooks o secuencias de comandos), y cuestiones como la auditoría y la reproducibilidad se vuelven cada vez más problemáticas.Kubeflow Pipelines (KFP) ayuda a resolver estos problemas, ya que proporciona una forma de implementar canalizaciones de aprendizaje automático sólidas y repetibles junto con la supervisión, la auditoría, el seguimiento de versiones y la reproducibilidad. Cloud AI Pipelines facilita la configuración de una instalación de KFP. |
Qué compilarás
En este codelab, compilarás una app web que resuma los problemas de GitHub con Kubeflow Pipelines para entrenar y entregar un modelo. Se basa en un ejemplo del repositorio de ejemplos de Kubeflow. Cuando termine, su infraestructura contendrá lo siguiente:
- Un clúster de Google Kubernetes Engine (GKE) con Kubeflow Pipelines instalado (a través de Cloud AI Pipelines)
- Una canalización que entrena un modelo Tensor2Tensor en GPU
- Un contenedor de entrega que brinda predicciones del modelo entrenado
- Una IU que interpreta las predicciones para resumir los problemas de GitHub
- Un notebook que crea una canalización desde cero con el SDK de Kubeflow Pipelines (KFP)
Qué aprenderás
La canalización que compilarás entrena un modelo Tensor2Tensor en los datos de problemas de GitHub y aprende a predecir los títulos de los problemas a partir de los cuerpos de estos. Luego, exporta el modelo entrenado y, luego, implementa el modelo exportado con TensorFlow Serving. El último paso de la canalización inicia una app web, que interactúa con la instancia de TF-Serving para obtener predicciones del modelo.
- Cómo instalar Kubeflow Pipelines en un clúster de GKE
- Cómo crear y ejecutar flujos de trabajo de AA con Kubeflow Pipelines
- Cómo definir y ejecutar canalizaciones desde un notebook de AI Platform
Requisitos
- Será útil tener conocimientos básicos de Kubernetes, pero no es necesario
- Un proyecto de GCP activo para el que tengas permisos de propietario
- Una cuenta de GitHub (opcional)
- Acceso a Google Cloud Shell, disponible en Google Cloud Platform (GCP) Console
2. Configuración
Cloud Shell
Visita GCP Console en el navegador y accede con las credenciales de tu proyecto:
Haz clic en “Seleccionar un proyecto”. si es necesario, de modo que estés trabajando con tu proyecto de codelab.
Luego, haz clic en “Activar Cloud Shell” en la esquina superior derecha de la consola para iniciar Cloud Shell.
Cuando inicies Cloud Shell, te dirá el nombre del proyecto que está configurado para usar. Comprueba que este parámetro de configuración sea correcto.
Para encontrar el ID de tu proyecto, visita el panel principal de GCP Console. Si la pantalla está vacía, haz clic en "Sí". en el mensaje para crear un panel.
Luego, en la terminal de Cloud Shell, ejecuta estos comandos si es necesario para configurar gcloud con el objetivo de usar el proyecto correcto:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Crea un bucket de almacenamiento
Crear un bucket de Cloud Storage para almacenar archivos de canalización Deberás usar un ID único a nivel global, por lo que es conveniente definir un nombre de bucket que incluya tu ID del proyecto. Crea el bucket con el comando gsutil mb (make bucket):
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
Como alternativa, puedes crear un bucket a través de GCP Console.
Opcional**: Crea un token de GitHub**
En este codelab, se llama a la API de GitHub para recuperar datos disponibles de forma pública. Para evitar el límite de frecuencia, especialmente en eventos en los que se envía una gran cantidad de solicitudes anonimizadas a las APIs de GitHub, configura un token de acceso sin permisos. El objetivo es simplemente autorizarlo como un individuo, en lugar de como un usuario anónimo.
- Ve a https://github.com/settings/tokens y genera un token nuevo sin alcances.
- Guárdalo en un lugar seguro. Si la pierdes, tendrás que borrar y crear una nueva.
Si omites este paso, el lab seguirá funcionando, pero tus opciones de generación de datos de entrada serán un poco más limitadas para probar tu modelo.
Opcional: Fija paneles útiles
En GCP Console, fija los paneles de Kubernetes Engine y Storage para acceder con más facilidad.
Crea una instalación de AI Platform Pipelines (Kubeflow Pipelines alojada).
Sigue las instrucciones de la sección "Antes de comenzar" y “Configura tu instancia” aquí para configurar una instancia de GKE con KFP instalada. Asegúrate de marcar la casilla Permitir el acceso a las siguientes APIs de Cloud como se indica en la documentación. De lo contrario, la canalización de ejemplo no se ejecutará correctamente. Deja el espacio de nombres de la instalación como default.
Deberás elegir una zona que admita Nvidia K80. Puedes usar us-central1-a o us-central1-c como valores predeterminados.
Observa el nombre del clúster y la zona de GKE enumerados para tu instalación en el panel de AI Pipelines una vez que se complete la instalación y, para tu comodidad, establece las variables de entorno en estos valores.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Configura kubectl para que use las credenciales de tu clúster de GKE nuevo
Después de crear el clúster de GKE, configura kubectl para usar las credenciales del clúster nuevo ejecutando el siguiente comando en Cloud Shell:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
Como alternativa, haz clic en el nombre del clúster en el panel de AI Pipelines para visitar la página de GKE y, luego, haz clic en “Conectar” en la parte superior de la página. En la ventana emergente, pega el comando en Cloud Shell.
Esto configura tu contexto de kubectl para que puedas interactuar con el clúster. Para verificar la configuración, ejecuta el siguiente comando:
kubectl get nodes -o wide
Deberías ver los nodos con el estado "Ready" y más información sobre la antigüedad del nodo, la versión, la dirección IP externa, la imagen de SO, la versión de kernel y el entorno de ejecución del contenedor.
Configura el clúster para instalar el controlador de Nvidia en grupos de nodos habilitados para GPU
A continuación, aplicaremos un daemonset al clúster, que instalará el controlador de Nvidia en cualquier nodo de clúster habilitado para GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Luego, ejecuta el siguiente comando, que otorga permiso a los componentes de KFP para crear nuevos recursos de Kubernetes:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Crea un grupo de nodos de GPU
Luego, configuraremos un grupo de nodos de GPU con un tamaño de 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. Ejecuta una canalización desde el panel Canalizaciones
Abrir el panel Canalizaciones
En la consola de Cloud, visita el panel Pipelines si aún no te encuentras allí. Luego, haz clic en "ABRIR PANEL DE CANALIZACIONES". Para tu instalación, haz clic en Canalizaciones en la barra de menú de la izquierda. Si recibes un error de carga, actualiza la pestaña. Deberías ver una página nueva como esta:
Descripción de la canalización
La canalización que ejecutarás tiene varios pasos (consulta el apéndice de este codelab para obtener más detalles):
- Se copia un punto de control del modelo existente en el bucket.
- Un modelo Tensor2Tensor se entrena con datos procesados previamente.
- El entrenamiento comienza a partir del punto de control del modelo existente copiado en el primer paso y, luego, se entrena durante unos cientos de pasos más. (Llevaría demasiado tiempo entrenarlo por completo durante el codelab).
- Cuando finaliza el entrenamiento, el paso de canalización exporta el modelo en un formato adecuado para la deriva mediante TensorFlow serving.
- Se implementa una instancia de TensorFlow Serving con ese modelo.
- Se inicia una app web para interactuar con el modelo entregado y recuperar predicciones.
Descarga y compila la canalización
En esta sección, veremos cómo compilar una definición de canalización. Lo primero que debemos hacer es instalar el SDK de KFP. En Cloud Shell, ejecuta lo siguiente:
pip3 install -U kfp
Para descargar el archivo de definición de la canalización, ejecuta este comando desde Cloud Shell:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Luego, compila el archivo de definición de la canalización; para ello, ejecútalo de la siguiente manera:
python3 gh_summ_hosted_kfp.py
Verás que aparece el archivo gh_summ_hosted_kfp.py.tar.gz como resultado.
Sube la canalización compilada
En la IU web de Kubeflow Pipelines, haz clic en Subir canalización y selecciona Importar por URL. Copia y pega la siguiente URL, que dirige a la misma canalización que acabas de compilar. (Hay que seguir algunos pasos adicionales para subir un archivo desde Cloud Shell, por lo que usaremos un atajo).
Asígnale un nombre a la canalización (p.ej., gh_summ).
Ejecuta la canalización
Haz clic en la canalización subida en la lista (esto te permite ver el grafo estático de la canalización) y, luego, haz clic en Crear experimento para crear un Experimento nuevo con la canalización. Un experimento es una forma de agrupar ejecuciones relacionadas de manera semántica.
Asígnale un nombre al experimento (p.ej., el mismo nombre que la canalización, gh_summ) y, luego, haz clic en Next para crearlo.
Se abrirá una página en la que podrás ingresar los parámetros de una ejecución y, luego, iniciarla.
Recomendamos que ejecutes los siguientes comandos en Cloud Shell para completar los parámetros.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
El nombre de la ejecución se completará automáticamente, pero puedes asignarle otro si lo deseas.
Luego, completa tres campos de parámetros:
project- (opcional)
github-token working-dir
En el directorio de trabajo, ingresa alguna ruta de acceso en el bucket de GCS que creaste. Incluye "gs://" . En el campo github-token, ingresa el token que generaste anteriormente opcionalmente, o bien deja la string del marcador de posición como está si no hubieras generado un token.
Después de completar los campos, haz clic en Iniciar y, luego, en la ejecución que se muestra en la lista para ver los detalles. Mientras se ejecuta un paso de canalización determinado, puedes hacer clic en él para obtener más información, incluida la visualización de sus registros del pod. También puedes ver los registros de un paso de canalización mediante el vínculo a sus registros de Cloud Logging (Stackdriver), incluso si se eliminó el nodo del clúster.
Consulta la definición de la canalización
Mientras se ejecuta la canalización, es posible que desees analizar con más detalle cómo se crea y qué hace. Encontrarás más detalles en la sección Apéndice del codelab.
Consulta la información de entrenamiento de modelos en TensorBoard
Cuando se complete el paso de entrenamiento, selecciona la pestaña Visualizations (Visualizations) y haz clic en el botón azul Start TensorBoard. Cuando esté listo, haz clic en Open TensorBoard.
Explora el panel Artifacts and Executions
Kubeflow Pipelines registra automáticamente los metadatos sobre los pasos de la canalización a medida que se ejecuta. Se registra la información de Artifact y Execution. Haz clic en estas entradas en la barra de navegación izquierda del panel para explorar más a fondo.
En el caso de los artefactos, puedes ver un panel de descripción general y un panel del explorador de linaje.
Abre la app web que creó la canalización y haz algunas predicciones
El último paso de la canalización implementa una aplicación web, que proporciona una IU para consultar el modelo entrenado, entregado a través de TF Serving, para hacer predicciones.
Una vez que se complete la canalización, conéctate a la app web mediante la redirección de puertos a su servicio (redirección de puertos porque, en este codelab, el servicio de apps web no está configurado para tener un extremo externo).
Busca el nombre del servicio ejecutando este comando en Cloud Shell:
kubectl get services
En la lista, busca un nombre de servicio como este: ghsumm-*-webappsvc.
Luego, en Cloud Shell, redireccióna puertos a ese servicio de la siguiente manera y cambia el siguiente comando para usar el nombre de tu webappsvc:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Cuando se esté ejecutando la redirección de puertos, haz clic en que se encuentra sobre el panel de Cloud Shell y, en el menú desplegable, haz clic en “Vista previa en el puerto 8080”.
Deberías ver una página como esta en una pestaña nueva:
Haz clic en el botón Propagar problema aleatorio para recuperar un bloque de texto. Haz clic en Generar título para llamar al modelo entrenado y mostrar una predicción.
Si los parámetros de tu canalización incluían un token de GitHub válido, también puedes intentar ingresar una URL de GitHub en el segundo campo y luego hacer clic en "Generate Title". Si no configuraste un token de GitHub válido, usa solo el problema “Propagar problema aleatorio”. .
4. Ejecuta una canalización desde un notebook de AI Platform
También puedes definir y ejecutar de manera interactiva Kubeflow Pipelines desde un notebook de Jupyter con el SDK de KFP. AI Platform Notebooks, que usaremos en este codelab, hace que esto sea muy sencillo.
Crea una instancia de notebook
Crearemos una instancia de notebook desde Cloud Shell con su API. (Como alternativa, puedes crear un notebook a través de la consola de Cloud. Consulta la documentación para obtener más información.
Configura las siguientes variables de entorno en 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"
Luego, en Cloud Shell, ejecuta el comando para crear la instancia 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
Cuando ejecutes este comando por primera vez, es posible que se te solicite habilitar la API de notebooks para tu proyecto. Responder "y" si es así.
Después de unos minutos, el servidor de tu notebook estará listo para funcionar. Puedes ver tus instancias de notebook enumeradas en la consola de Cloud.
Sube el notebook del codelab
Después de crear la instancia de notebook, haz clic en este vínculo para subir el notebook de Jupyter del codelab. Selecciona la instancia de notebook que quieres usar. El notebook se abrirá automáticamente.
Ejecuta el notebook
Sigue las instrucciones en el notebook durante el resto del lab. Ten en cuenta que, en la sección "Configuración", deberás ingresar tus propios valores antes de ejecutar el resto.
Si usas tu propio proyecto, no olvides volver y realizar la sección “Limpieza” de este lab.
5. Limpia
No es necesario que lo hagas si usas una cuenta de codelab temporal, pero te recomendamos que desactives la instalación de Pipelines y el notebook si usas tu propio proyecto.
Elimina el clúster de GKE de Pipelines
Puedes borrar el clúster de canalizaciones desde la consola de Cloud. Puedes borrar la instalación de canalizaciones si quieres volver a usar el clúster de GKE.
Borra la instancia de notebook de IA
Si ejecutaste el "Notebook" como parte del codelab, puedes BORRAR o DETENER la instancia de notebook desde la consola de Cloud.
Opcional: Quita el token de GitHub
Ve a https://github.com/settings/tokens y quita el token generado.
6. Apéndices
Información sobre el código
Define la canalización
La canalización que se usa en este codelab se define aquí.
Veamos cómo se definen, así como cómo se definen sus componentes (pasos). Abordaremos algunos aspectos destacados, pero puedes consultar la documentación para obtener más detalles.
Los pasos de Kubeflow Pipelines se basan en contenedores. Cuando compilas una canalización, puedes usar componentes compilados previamente, con imágenes de contenedor ya compiladas, o compilar tus propios componentes. En este codelab, creamos uno propio.
Cuatro de los pasos de la canalización se definen a partir de componentes reutilizables, a los que se accede a través de sus archivos de definición de componente. En este primer fragmento de código, accedemos a estos archivos de definición de componentes a través de su URL y usamos estas definiciones para crear "ops" que usaremos para crear un paso de canalización.
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'
)
A continuación, se muestra una de las definiciones de los componentes para la operación de entrenamiento, en formato YAML. Puedes ver que sus entradas, salidas, imagen de contenedor y argumentos de punto de entrada del contenedor están definidos.
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
También puedes definir un paso de canalización mediante el constructor dsl.ContainerOp, como veremos a continuación.
A continuación, se muestra la mayor parte de la definición de canalización. Estamos definiendo las entradas de la canalización (y sus valores predeterminados). Luego, definimos los pasos de la canalización. En la mayoría de los casos, usamos el operador definimos anteriormente, pero también definiremos Para ello, especifica la imagen del contenedor y los argumentos del punto de entrada directamente a través de ContainerOp.
Puedes ver que los pasos train, log_model y serve acceden a los resultados de los pasos anteriores como entradas. Puedes leer más sobre cómo se especifica esto aquí.
@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)
Ten en cuenta que necesitamos el atributo “train” para ejecutarlo en un nodo del clúster que tenga al menos 1 GPU disponible.
train.set_gpu_limit(1)
El último paso de la canalización, también definido intercalado, es condicional. Se ejecutará después de "serve" el paso es finalizado, solo si el resultado del paso de entrenamiento launch_server es la cadena “verdadero”. Inicia la "app web de predicción", que usamos para solicitar resúmenes de problemas del modelo T2T entrenado.
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)
Las definiciones de la imagen del contenedor del componente
En la documentación de Kubeflow Pipelines, se describen algunas prácticas recomendadas para compilar tus propios componentes. Como parte de este proceso, deberás definir y compilar una imagen de contenedor. Puedes ver los pasos de los componentes de la canalización de este codelab aquí. Las definiciones de Dockerfile se encuentran en los subdirectorios containers, p.ej., aquí.
Usa VMs interrumpibles con GPU para el entrenamiento
Las VMs interrumpibles son instancias de VM de Compute Engine que duran un máximo de 24 horas y no ofrecen garantías de disponibilidad. El precio de las VMs interrumpibles es más bajo que el de las VMs estándar de Compute Engine.
Con Google Kubernetes Engine (GKE), es fácil configurar un clúster o un grupo de nodos que use VMs interrumpibles. Puedes configurar un grupo de nodos de este tipo con GPU adjuntas a las instancias interrumpibles. Estos funcionan de la misma manera que los nodos normales habilitados para GPU, pero las GPU persisten solo durante la vida útil de la instancia.
Puedes configurar un grupo de nodos interrumpibles habilitado para GPU para tu clúster ejecutando un comando similar al siguiente, editando el siguiente comando con el nombre y la zona del clúster, y ajustando el tipo y el recuento del acelerador según tus requisitos. De manera opcional, puedes definir el grupo de nodos para que realice un ajuste de escala automático en función de las cargas de trabajo actuales.
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
También puedes configurar un grupo de nodos a través de la consola de Cloud.
Definir una canalización de Kubeflow que usa los nodos de GKE interrumpibles
Si ejecutas Kubeflow en GKE, ahora es fácil definir y ejecutar Kubeflow Pipelines en el que uno o más pasos de la canalización (componentes) se ejecutan en nodos interrumpibles, lo que reduce el costo de ejecutar un trabajo. Para que las VMs interrumpibles proporcionen los resultados correctos, los pasos que identifiques como interrumpibles deben ser idempotentes (es decir, si ejecutas un paso varias veces, obtendrás el mismo resultado) o un punto de control debería funcionar para que el paso pueda retomarse desde donde se interrumpió.
Cuando defines una canalización de Kubeflow Pipelines, puedes indicar que un paso determinado se debe ejecutar en un nodo interrumpible modificando la op de la siguiente manera:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Para obtener más información, consulta la documentación.
Se supone que también deberás reintentar el paso algunas veces si se interrumpe el nodo. Puedes hacerlo de la siguiente manera: especificamos 5 reintentos.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Intenta editar la canalización de Kubeflow que usamos en este codelab para ejecutar el paso de entrenamiento en una VM interrumpible.
Cambia la siguiente línea en la especificación de la canalización para usar de forma adicional un grupo de nodos interrumpibles (asegúrate de haber creado uno como se indica más arriba) y volver a intentarlo 5 veces:
train.set_gpu_limit(1)
A continuación, vuelve a compilar la canalización, sube la versión nueva (asígnale un nombre nuevo) y ejecuta la versión nueva de la canalización.