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

En este tutorial se muestra cómo usar Google Kubernetes Engine (GKE) para gestionar cargas de trabajo por lotes tolerantes a fallos y, al mismo tiempo, mantener los costes bajos. Sigue este tutorial para aprender a usar trabajos y pods esporádicos optimizados para los costes, así como a configurar una cola de trabajos de Redis en un clúster de GKE.

Fondo

Una carga de trabajo por lotes es un proceso que suele tener un punto de inicio y un punto de finalización. Deberías plantearte usar cargas de trabajo por lotes en GKE si tu arquitectura implica ingerir, procesar y generar datos en lugar de usar datos sin procesar. En áreas como el aprendizaje automático, la inteligencia artificial y la computación de alto rendimiento (HPC), se utilizan diferentes tipos de cargas de trabajo por lotes, como el entrenamiento de modelos sin conexión, la predicción por lotes, las analíticas de datos, la simulación de sistemas físicos y el procesamiento de vídeo.

Si diseña cargas de trabajo por lotes en contenedores, puede aprovechar las siguientes ventajas de GKE:

• Un estándar abierto, una comunidad amplia y un servicio gestionado.
• Rentabilidad gracias a la orquestación eficaz de cargas de trabajo e infraestructuras, así como a recursos informáticos especializados.
• Aislamiento y portabilidad de la contenedorización, lo que permite usar la nube como capacidad de desbordamiento y, al mismo tiempo, mantener la seguridad de los datos.
• Disponibilidad de capacidad de ráfaga, seguida de una reducción rápida de los clústeres de GKE.

Preparar el entorno

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

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

2. Crea un clúster de Autopilot de GKE:

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

   Este paso puede tardar hasta 5 minutos.

Configurar 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.

Crear 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 de la instancia de Filestore. En este ejemplo se usa el nivel básico. Para obtener información sobre otras opciones, consulta Niveles de servicio.

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

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

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

2. Comprueba que la instancia de Filestore se ha implementado:

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

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

   El resultado debería ser similar al siguiente:

   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. Anota el valor del campo IP_ADDRESS para usarlo en la siguiente sección.

Crear 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
   

   Sustituye IP_ADDRESS por la dirección IP que has anotado al crear la instancia de Filestore en la sección anterior.

2. Despliega el PersistentVolume:

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

Crear un PersistentVolumeClaim

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

Despliega PersistentVolumeClaim:

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

Consumir PersistentVolumeClaim

Una vez que hayas configurado PersistentVolume y PersistentVolumeClaim en el clúster de GKE, podrás configurar el servidor Redis y los trabajos por lotes para que usen PersistentVolumeClaim. Se muestra como un volumen de almacenamiento montable.

Inspecciona los archivos kubernetes-manifests/redis-pod.yaml y kubernetes-manifests/workload.yaml. Las configuraciones del archivo de manifiesto son similares a las siguientes:

  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 este manifiesto:

• spec.volumes especifica el PersistentVolumeClaim que se va a consumir.
• spec.containers.volumeMounts especifica la ruta del archivo local donde el pod puede acceder al sistema de archivos compartido de Filestore.

Configurar una cola de trabajos de Redis

La carga de trabajo procesa los datos en lotes para entrenar de forma iterativa un modelo de detección de fraudes. Para gestionar los conjuntos de datos que se están procesando o que aún están en la cola, debes desplegar el servidor Redis en el clúster de GKE.

En este tutorial, iniciarás una sola instancia de Redis. Para desplegar Redis de forma escalable y redundante, consulta el artículo sobre cómo crear una aplicación web multinivel con Redis y PHP.

1. Despliega la especificación del servidor Redis.

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

2. Comprueba que el pod se está ejecutando:

   kubectl get pods
   

   El resultado debería ser similar al siguiente:

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

   El Pod puede tardar hasta dos minutos en empezar a funcionar.

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

   sh scripts/transfer-datasets.sh
   

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

4. Rellena la cola de Redis.

   sh scripts/queue-jobs.sh
   

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

5. Despliega el servicio para que el servidor Redis se pueda detectar en el clúster de GKE.

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

Ejecutar la carga de trabajo por lotes

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

En esta sección, usarás una imagen de contenedor de una carga de trabajo de ejemplo 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 archivo a conjuntos de datos) en la cola de Redis y los elimina de la cola cuando se completan.

2. Una clase de gestor de entrenamiento de modelos, FraudDetectionModelTrainer, carga un nuevo lote de datos y, opcionalmente, un estado guardado de un modelo de aprendizaje automático. El conjunto de datos se usa para perfeccionar el modelo (un proceso conocido como entrenamiento "warm-start").

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

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

Definir la tarea

El siguiente manifiesto describe el trabajo de Kubernetes para la imagen de carga de trabajo por lotes. Un controlador de trabajo de Kubernetes crea uno o varios pods y se asegura de que ejecuten correctamente una tarea específica.

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 (por ejemplo, clasificando lotes de imágenes, análisis de datos de larga duración, etc.), puedes aumentar el valor de parallelism para permitir que se ejecuten tantos pods como ese valor de forma simultánea hasta que se cumpla la condición de finalización. La especificación nodeSelector indica a GKE que use Pods de tipo Spot.

Desplegar la carga de trabajo

1. Desplegar el trabajo:

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

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

   watch kubectl get pods
   

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

   El resultado debería ser similar al siguiente:

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

3. Consulta los registros de la tarea workload:

   kubectl logs job/workload
   

   El resultado debería ser similar al siguiente:

   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 con tarjeta de crédito, marcadas como válidas o fraudulentas. El trabajo workload itera sobre estos archivos, descomprime los conjuntos de datos y los usa para entrenar el modelo de aprendizaje automático antes de eliminarlos de la cola de Redis. La carga de trabajo sigue procesando los datos en lotes hasta que se vacía la cola de Redis, antes de salir correctamente.

Explorar el volumen NFS

Durante su funcionamiento, la carga de trabajo crea archivos en el volumen NFS montado, al que pueden acceder otras tareas por lotes o aplicaciones online en todo el clúster.

1. Lista los archivos creados por la carga de trabajo:

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

   La salida debería ser la 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
   

   Se han creado puntos de control del modelo entrenado (nombres de archivo como model_cpt_XXX.pkl) y un informe del rendimiento del modelo (report.txt) en el directorio /mnt/fileserver/output del volumen NFS.

2. Consulta el informe de rendimiento del modelo:

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

   A continuación, se muestra 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 detallan la hora del entrenamiento, el conjunto de datos utilizado, la precisión obtenida y el nombre de archivo del punto de control del modelo asociado al entrenamiento.

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