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


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:

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.

    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.

    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.

  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

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

  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?