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

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 VM Spot con optimización de costos, y también a configurar una cola de trabajos de Redis en el clúster en GKE.

Antecedentes

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. Crear un clúster de GKE con grupos de nodos de VM Standard y Spot.
2. Crear un volumen 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 instructivo, se usan los siguientes componentes facturables de Google Cloud:

• Compute Engine
• Google Kubernetes Engine
• 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.

Antes de comenzar

Configura tu proyecto

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. En Google Cloud Console, en la página del selector de proyectos, haz clic en Crear proyecto para comenzar a crear un proyecto de Google Cloud nuevo.

   Ir al selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

4. Habilita las API de Compute Engine, GKE, and Filestore.

   Habilita las API

5. En Google Cloud Console, en la página del selector de proyectos, haz clic en Crear proyecto para comenzar a crear un proyecto de Google Cloud nuevo.

   Ir al selector de proyectos

6. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

7. Habilita las API de Compute Engine, GKE, and Filestore.

   Habilita las API

Configure su entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell viene preinstalado con Docker y la CLI de gcloud y kubectl.

Sigue estos pasos para configurar tu entorno con Cloud Shell:

1. En Google Cloud Console, inicia una instancia de Cloud Shell.
   Abre Cloud Shell

2. Descarga el código fuente para esta app de ejemplo.

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

3. Actualiza el archivo scripts/variables.sh con la información del proyecto:

   sed -i "\
     s/<YOUR_PROJECT_ID>/PROJECT_ID/g; \
     s/<YOUR_REGION>/REGION/g; \
     s/<YOUR_ZONE>/ZONE/g" \
     scripts/variables.sh
   

   Reemplaza lo siguiente:

   • PROJECT_ID: el ID del proyecto de Google Cloud

   • REGION: la región de Compute Engine

   • ZONE: la zona de Compute Engine

4. Establece las variables de entorno necesarias y los valores predeterminados de gcloud.

   source scripts/variables.sh
   gcloud config set project ${PROJECT_ID}
   gcloud config set compute/region ${REGION}
   gcloud config set compute/zone ${ZONE}
   gcloud config set filestore/zone ${ZONE}
   

Cree un clúster de GKE

Crea un clúster de GKE con dos grupos de nodos en los que GKE aloja el volumen persistente y ejecuta la carga de trabajo con la cola de trabajos de Redis.

1. Crea un clúster de GKE Standard Este clúster inicializa un grupo de nodos con configuraciones predeterminadas.

   gcloud container clusters create ${CLUSTER_NAME} \
     --machine-type=e2-standard-2 --num-nodes=3
   

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

2. Verifica que el clúster de GKE esté en ejecución:

   gcloud container clusters list
   

   El valor de STATUS es RUNNING para el clúster batch-aiml.

3. Crea un segundo grupo de nodos en el clúster de GKE que se habilitará con VM Spot:

   gcloud beta container node-pools create batch-node-pool \
     --cluster=${CLUSTER_NAME} --spot
   

   Nota: Para garantizar la confiabilidad, una práctica recomendada es tener al menos un grupo de nodos en un clúster de GKE que se ejecute en VM Standard. Esta es la razón por la que se crea un grupo de nodos nuevo para las VM Spot, que son máquinas virtuales (VM) de Compute Engine que tienen precios más bajos que las VM bajo demanda. Si deseas obtener más información, consulta cómo usar las VM Spot para ejecutar cargas de trabajo tolerantes a errores.

   Implementarás la carga de trabajo por lotes en este grupo de nodos de VM Spot más adelante en el instructivo.

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 este instructivo, crearás una instancia de Filestore, a la que pueden acceder todos los nodos (operaciones de lectura y escritura) en un clúster de GKE a través de un volumen persistente (PV) y una reclamación de volúmenes persistentes (PVC).

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

Crea una instancia de Filestore

1. Crea una instancia de Filestore

   gcloud filestore instances create ${FILESTORE_ID} \
     --tier=BASIC_HDD \
     --file-share=name="NFSVol",capacity=1TB \
     --network=name="default"
   

   Donde:

   • tier es el nivel de servicio para la instancia de Filestore. En esta muestra se usa la oferta básica, pero puedes obtener información sobre las otras opciones en Niveles de servicio.

   • network=name es el nombre de la red de nube privada virtual (VPC) de Compute Engine a la que se conecta la instancia. El clúster de GKE debe estar en la misma red de VPC que la instancia de Filestore.

   • capacity es 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=${ZONE}
   

   El resultado es similar al siguiente, en el que el valor STATE es READY para la instancia batch-aiml-filestore:

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

3. Toma nota del valor IP_ADDRESS del resultado; se usará en la próxima sección.

Crea un volumen persistente

Una especificación de volumen persistente (PV) 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 con el valor que anotó cuando crea la instancia de Filestore.

2. Implementa la especificación de PV:

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

Crea una reclamación de volumen persistente

Una especificación de la reclamación de volumen persistente (PVC) de Kubernetes permite que los trabajos y Pods de Kubernetes accedan a los recursos de almacenamiento de un volumen persistente.

Implementa la especificación de PVC:

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

Consume la reclamación de volumen persistente

Una vez que el volumen persistente y la reclamación de volúmenes persistentes estén configurados en el clúster de GKE, puedes configurar el servidor de Redis y los trabajos por lotes para consumir la PVC. Esto aparecerá como un volumen de almacenamiento activable en la VM que ejecuta los recursos de Kubernetes.

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

Donde:

• spec.volumes especifica las reclamaciones de volúmenes persistentes que se consumirán.

• spec.containers.volumeMounts especifica la ruta del archivo local en la VM donde se puede acceder al recurso compartido de Filestore.

Configura una cola de trabajos de Redis

La carga de trabajo procesará datos en lotes para entrenar de forma iterativa el 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 simplificar, inicia una sola instancia de Redis en esta muestra. Para ver un ejemplo de implementación de Redis de manera escalable y redundante, consulta cómo crear un libro de visitas 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 esté en ejecución antes de continuar. En el resultado del siguiente comando, el STATUS para el Pod redis-leader debe ser Running.

   kubectl get pods
   

   El resultado es similar a este:

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

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, usarás 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 estado nuevo 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 a través de una reclamación de volumen persistente.

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

Define el trabajo

En el siguiente manifiesto, se describe la especificación del trabajo por lotes para la imagen de carga de trabajo. Este manifiesto usa el recurso de trabajo de Kubernetes.

batch/aiml-workloads/kubernetes-manifests/workload.yaml

Ver en GitHub

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 muchos Pods ejecuten el trabajo de forma simultánea hasta que se cumpla la condición de finalización. La especificación de nodeSelector indica el uso del grupo de nodos con VM Spot. Para obtener más información, consulta Ejecuta un trabajo en GKE.

Implementa la carga de trabajo

1. Aplica la especificación para el trabajo por lotes.

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

2. Comprueba si el estado del Pod workload-XXX está completo.

   watch kubectl get pods
   

   Este proceso puede 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, accesibles en todo el clúster para otros trabajos por lotes o aplicaciones en línea. Para explorar los archivos en el volumen NFS, sigue estos pasos:

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.

Para quitar los recursos individuales creados para este instructivo, sigue estos pasos:

sh scripts/cleanup.sh

¿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 VM Spot para ejecutar cargas de trabajo tolerantes a errores.

• Obtén más información sobre cómo configurar un entorno de MLOps en Google Cloud.

• Explora otros instructivos de Kubernetes Engine.

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