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

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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:

Diagrama de arquitectura

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:

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

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:

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

    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.

  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.

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