Implementa una carga de trabajo de aprendizaje automático por lotes

Autopilot Estándar

---

En este instructivo, se muestra cómo usar Google Kubernetes Engine (GKE) para administrar las cargas de trabajo por lotes tolerantes a errores y mantener los costos bajos. Sigue este instructivo para aprender a usar Trabajos y Pods Spot con optimización de costos, y también a configurar una cola de trabajos de Redis en el clúster en GKE.

Segundo plano

Una carga de trabajo por lotes es un proceso comúnmente diseñado para tener un punto de inicio y de finalización. Te recomendamos considerar las cargas de trabajo por lotes en GKE si tu arquitectura implica la transferencia, el procesamiento y la salida de datos en lugar de usar datos sin procesar. Las áreas como el aprendizaje automático, la inteligencia artificial y la computación de alto rendimiento (HPC) tienen diferentes tipos de cargas de trabajo por lotes, como el entrenamiento de modelos sin conexión, la predicción por lotes, el análisis de datos, la simulación de sistemas físicos y el procesamiento de videos.

Cuando diseñas cargas de trabajo por lotes en contenedores, puedes aprovechar los siguientes beneficios de GKE:

• Un estándar abierto, una comunidad amplia y un servicio administrado.
• Rentabilidad a partir de la organización eficaz de la infraestructura y la carga de trabajo y recursos de procesamiento especializados.
• Aislamiento y portabilidad de la creación de contenedores, lo que permite el uso de la nube como capacidad de desbordamiento y, al mismo tiempo, mantener la seguridad de los datos.
• Disponibilidad de la capacidad de aumento de actividad, seguida de una rápida reducción vertical de la escala de los clústeres de GKE.

Objetivos

Este instructivo va dirigido a ingenieros de aprendizaje automático o científicos de datos que deseen aprender a ejecutar cargas de trabajo de aprendizaje automático por lotes en GKE, en la siguiente arquitectura rentable y escalable:

En este instructivo, se abarcan los siguientes pasos:

1. Crea un clúster de GKE Autopilot. Como alternativa, puedes usar un clúster de GKE Standard para este instructivo.
2. Crea un volumen de Filestore NFS.
3. Crear una cola de trabajos de Redis en el clúster
4. Transferir los conjuntos de datos al volumen de NFS y colocarlos en una cola para que los consuma la carga de trabajo.
5. Ejecutar una carga de trabajo de aprendizaje automático por lotes de muestra en el clúster de GKE.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• Compute Engine
• GKE Autopilot
• Filestore

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

---

Para seguir la guía paso a paso sobre esta tarea directamente en la consola de Google Cloud, haz clic en Guiarme:

GUIARME

---

Antes de comenzar

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

7. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

8. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Prepare el entorno

1. Clona el repositorio de muestra que se usa en este instructivo:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Crea un clúster de GKE Autopilot:

   gcloud container clusters create-auto batch-aiml \
       --region=us-central1
   

   Este paso puede tardar hasta 5 minutos en completarse.

Configura el almacenamiento de conjuntos de datos con un sistema de archivos de red (NFS)

La carga de trabajo de aprendizaje automático requiere una solución de almacenamiento para los conjuntos de datos y los archivos de salida. En esta sección, crearás una instancia de Filestore y proporcionarás acceso a la instancia mediante un PersistentVolume y un PersistentVolumeClaim.

Para obtener más información, consulta cómo diseñar una estrategia de almacenamiento óptima y cómo acceder a instancias de Filestore desde clústeres de GKE.

Crea una instancia de Filestore

1. Crea una instancia de Filestore

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Este comando especifica las siguientes opciones:

   • tier: el nivel de servicio para la instancia de Filestore. En este ejemplo, se usa el nivel básico. Para obtener más información sobre las otras opciones, consulta Niveles de servicio.

   • network=name: el nombre de la red de nube privada virtual (VPC) para la instancia de Filestore. El clúster de GKE debe estar en la misma red de VPC que la instancia de Filestore.

   • capacity: el tamaño deseado del volumen. Especifica el valor de almacenamiento en una de las unidades compatibles que se describen en Cantidades de recursos.

   Nota: Este paso puede tardar hasta 5 minutos en completarse.

2. Verifica que se haya implementado la instancia de Filestore:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

   El resultado es similar a este:

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Toma nota del valor del campo IP_ADDRESS para usarlo en la siguiente sección.

Crea un PersistentVolume

Una especificación de PersistentVolume de Kubernetes permite que el clúster de GKE se conecte a la instancia de Filestore.

1. Actualiza el archivo kubernetes-manifests/persistent-volume.yaml con la dirección IP de la instancia de Filestore:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Reemplaza IP_ADDRESS por la dirección IP que anotaste cuando creaste la instancia de Filestore en la sección anterior.

2. Implementa el PersistentVolume:

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

Crea una PersistentVolumeClaim

Un objeto PersistentVolumeClaim de Kubernetes permite que los trabajos y Pods de Kubernetes accedan a los recursos de almacenamiento de un PersistentVolume.

Implementa la PersistentVolumeClaim:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Consume la PersistentVolumeClaim

Con el PersistentVolume y la PersistentVolumeClaim configurados en el clúster de GKE, puedes configurar el servidor de Redis y los trabajos por lotes para consumir la PersistentVolumeClaim. Esto aparece como un volumen de almacenamiento activable.

Inspecciona los archivos kubernetes-manifests/redis-pod.yaml y kubernetes-manifests/workload.yaml. Las configuraciones del manifiesto son similares a lo siguiente:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

En el manifiesto se muestra lo siguiente:

• spec.volumes especifica la PersistentVolumeClaim que se consumirá.
• spec.containers.volumeMounts especifica la ruta del archivo local donde el Pod puede acceder al recurso compartido de Filestore.

Configura una cola de trabajos de Redis

La carga de trabajo procesa datos en lotes para entrenar de forma iterativa un modelo de detección de fraudes. Para administrar los conjuntos de datos que se procesan actualmente o que aún se encuentran en la cola, implementa el servidor de Redis en el clúster de GKE.

Para este instructivo, debes iniciar una sola instancia de Redis. Para implementar Redis de manera escalable y redundante, consulta Crea una aplicación web de varios niveles con Redis y PHP.

1. Implementa la especificación del servidor de Redis.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Verifica que el Pod se esté ejecutando.

   kubectl get pods
   

   El resultado es similar a este:

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   El Pod puede tardar hasta dos minutos en comenzar a ejecutarse.

3. Transfiere los archivos que contienen los conjuntos de datos de entrenamiento y de prueba al volumen de NFS.

   sh scripts/transfer-datasets.sh
   

   Esta secuencia de comandos copia los archivos del repositorio de código de muestra en el directorio /mnt/fileserver/datasets/ en el Pod redis-leader.

4. Propaga la cola de Redis.

   sh scripts/queue-jobs.sh
   

   Esta secuencia de comandos envía las rutas de acceso de los archivos para los conjuntos de datos de entrenamiento a una lista llamada datasets en la base de datos de Redis. La carga de trabajo usará esta cola para ubicar el siguiente conjunto de datos que se debe procesar.

5. Implementa el Service para que el servidor de Redis sea detectable dentro del clúster de GKE.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Ejecuta la carga de trabajo por lotes

En este punto, preparaste el clúster de GKE, la cola de trabajos de Redis y el recurso compartido. Ahora puedes ejecutar la carga de trabajo por lotes.

En esta sección, usas una imagen de contenedor de una carga de trabajo de muestra para entrenar un modelo de detección de fraudes con lotes de datos de transacciones financieras. El proceso de entrenamiento se puede resumir de la siguiente manera:

1. Un cliente de Redis reclama trabajos (rutas de acceso de archivos a conjuntos de datos) en la cola de Redis y los quita de la cola una vez que se completan.

2. Una clase de administrador de entrenamiento de modelos, FraudDetectionModelTrainer, carga un nuevo lote de datos y, de forma opcional, un estado guardado de un modelo de aprendizaje automático. El conjunto de datos se usa para definir mejor el modelo (un proceso conocido como entrenamiento de “inicio semicaliente”).

3. El nuevo estado del modelo y un informe de los detalles del lote y las puntuaciones de rendimiento se guardan en el volumen de NFS de Filestore, al que se puede acceder en el clúster de GKE mediante una PersistentVolumeClaim.

Para obtener más información, explora el código fuente.

Define el trabajo

En el siguiente manifiesto, se describe el trabajo de Kubernetes para la imagen de carga de trabajo por lotes.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Nota: Si configuras una carga de trabajo en la que los lotes se pueden ejecutar en paralelo (p. ej., clasificar lotes de imágenes, análisis de datos de larga duración, etcétera), puedes aumentar el valor de parallelism para permitir que esa cantidad de Pods ejecuten el trabajo de forma simultánea hasta que se cumpla la condición de finalización. La especificación nodeSelector le indica a GKE que use Pods Spot.

Implementa la carga de trabajo

1. Implementa el trabajo:

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Comprueba si el estado del Pod workload-XXX es Completed:

   watch kubectl get pods
   

   Este proceso podría tardar unos segundos. Para volver a la línea de comandos, presiona Ctrl+C.

   El resultado es similar a este:

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Verifica los registros del trabajo workload:

   kubectl logs job/workload
   

   El resultado es similar a este:

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   Los archivos .pkl son serializaciones de conjuntos de datos que contienen un lote de transacciones de tarjetas de crédito, marcadas como válidas o fraudulentas. El trabajo workload itera en estos archivos, descomprime los conjuntos de datos y los usa para entrenar el modelo de aprendizaje automático antes de quitarlos de la cola de Redis. La carga de trabajo continúa con el procesamiento de datos en lotes hasta que se vacía la cola de Redis antes de salir con éxito.

Explora el volumen de NFS

Durante su operación, la carga de trabajo crea archivos en el volumen de NFS activado, a los que pueden acceder en todo el clúster otros trabajos por lotes o aplicaciones en línea.

1. Enumera los archivos que creó la carga de trabajo:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   El resultado debería ser el siguiente:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Los puntos de control para el modelo entrenado (nombres de archivos como model_cpt_XXX.pkl) y un informe del rendimiento del modelo (report.txt) se crearon en el directorio /mnt/fileserver/output en el volumen de NFS.

2. Inspecciona el informe de rendimiento del modelo:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   El siguiente es un fragmento del resultado:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   El archivo contiene entradas que describen la hora de entrenamiento, el conjunto de datos usado, la exactitud obtenida y el nombre de archivo del punto de control del modelo asociado con el entrenamiento.

Para obtener más información sobre los volúmenes de NFS, consulta las Guías de Filestore.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Quita recursos individuales

Para quitar los recursos individuales creados para este instructivo, ejecuta los siguientes comandos.

1. Borra el clúster:

   gcloud container clusters delete batch-aiml \
       --region=us-central1
   

2. Elimina la instancia de Filestore:

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

1. En la consola de Google Cloud, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

• Consulta la documentación de GKE.

• Explora los volúmenes persistentes con más detalle.

• Obtén más información sobre los trabajos en GKE.

• Obtén más información sobre cómo usar las VMs Spot para ejecutar cargas de trabajo tolerantes a errores.

• Explora otros instructivos de Kubernetes Engine.

• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.