Uso de GPU

En esta página, se explica cómo ejecutar un trabajo de Dataflow con GPU. Los trabajos que usan GPU generan cargos durante la vista previa, como se especifica en la página de precios de Dataflow.

Para obtener información más detallada sobre el uso de GPU con Dataflow, consulta la compatibilidad de Dataflow para GPU.

Aprovisiona la cuota de GPU

Los dispositivos de GPU están sujetos a la disponibilidad de cuota del proyecto de Google Cloud. Solicita la cuota de GPU en la región que elijas.

Instala controladores de GPU

Debes indicar a Dataflow que instale los controladores NVIDIA en los trabajadores. Para ello, agrega install-nvidia-driver a la opción worker_accelerator. Cuando se especifica la opción install-nvidia-driver, Dataflow instala controladores NVIDIA en los trabajadores de Dataflow con la utilidad cos-extensions proporcionada por Container-Optimized OS. Cuando se especifica install-nvidia-driver, los usuarios aceptan el contrato de licencia de NVIDIA.

Los objetos binarios y las bibliotecas que proporciona el instalador del controlador de NVIDIA se activan en el código de usuario de ejecución del contenedor que se ejecuta en /usr/local/nvidia/.

Configura tu imagen de contenedor

Para interactuar con las GPU, es posible que necesites software adicional de NVIDIA, como bibliotecas aceleradas por GPU y el kit de herramientas de CUDA. Debes proporcionar estas bibliotecas en el contenedor de Docker que ejecuta el código de usuario.

Puedes personalizar la imagen del contenedor si proporcionas una imagen que cumpla con el contrato de imagen de contenedor del SDK de Apache Beam y que tenga las bibliotecas necesarias o si compilas a partir de las imágenes publicadas con las actualizaciones del SDK de Apache Beam.

Para proporcionar una imagen de contenedor personalizada, debes usar Dataflow Runner v2 y proporcionar la imagen de contenedor con la opción de canalización worker_harness_container_image.

Para obtener más información, consulta Usa contenedores personalizados.

Si quieres prototipar canalizaciones en GPU como prueba de concepto sin preocuparte por configurar un entorno de desarrollo, consulta Desarrolla con notebooks de Apache Beam, inicia una instancia de notebooks de Apache Beam y sigue el ejemplo que aparece en Usa GPU con Apache Beam.

Compila una imagen de contenedor personalizada a partir de una imagen base preexistente con un software de GPU

Puedes compilar una imagen de Docker que cumpla con el contrato de contenedor del SDK de Apache Beam a partir de una imagen base existente. Por ejemplo, las imágenes de Docker de TensorFlow y los contenedores de aprendizaje profundo de AI Platform están preconfigurados para el uso de la GPU.

Un Dockerfile de muestra se ve de la siguiente manera:

# Use a GPU-enabled Tensorflow Docker image. The image has Python 3.6.
FROM tensorflow/tensorflow:2.4.0-gpu
RUN pip install --no-cache-dir apache-beam[gcp]==2.26.0

# Copy the Apache Beam worker dependencies from the Beam Python 3.6 SDK image.
COPY --from=apache/beam_python3.6_sdk:2.26.0 /opt/apache/beam /opt/apache/beam

# Set the entrypoint to Apache Beam SDK worker launcher.
ENTRYPOINT [ "/opt/apache/beam/boot" ]

Verifica que la versión de Apache Beam y la versión secundaria de intérprete de Python en tu imagen coincidan con las versiones que usas para iniciar la canalización. Para obtener mejores resultados, considera usar las últimas versiones de tu imagen base seleccionada y Apache Beam.

Compila una imagen de contenedor personalizada a partir de una imagen del SDK de Apache Beam

Para compilar a partir de las imágenes de Docker publicadas con las versiones del SDK de Apache Beam, debes instalar las bibliotecas de GPU necesarias en estas imágenes.

Un Dockerfile de muestra se ve de la siguiente manera:

FROM apache/beam_python3.7_sdk:2.24.0
ENV INSTALLER_DIR="/tmp/installer_dir"

# The base image has TensorFlow 2.2.0, which requires CUDA 10.1 and cuDNN 7.6.
# You can download cuDNN from NVIDIA website
# https://developer.nvidia.com/cudnn
COPY cudnn-10.1-linux-x64-v7.6.0.64.tgz $INSTALLER_DIR/cudnn.tgz
RUN \
    # Download CUDA toolkit.
    wget -q -O $INSTALLER_DIR/cuda.run https://developer.download.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.243_418.87.00_linux.run && \

    # Install CUDA toolkit. Print logs upon failure.
    sh $INSTALLER_DIR/cuda.run --toolkit --silent || (egrep '^\[ERROR\]' /var/log/cuda-installer.log && exit 1) && \
    # Install cuDNN.
    mkdir $INSTALLER_DIR/cudnn && \
    tar xvfz $INSTALLER_DIR/cudnn.tgz -C $INSTALLER_DIR/cudnn && \

    cp $INSTALLER_DIR/cudnn/cuda/include/cudnn*.h /usr/local/cuda/include && \
    cp $INSTALLER_DIR/cudnn/cuda/lib64/libcudnn* /usr/local/cuda/lib64 && \
    chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn* && \
    rm -rf $INSTALLER_DIR

# A volume with GPU drivers will be mounted at runtime at /usr/local/nvidia.
ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/nvidia/lib64:/usr/local/cuda/lib64

Las bibliotecas de controlador en /usr/local/nvidia/lib64 deben poder detectarse en el contenedor como bibliotecas compartidas mediante la configuración de la variable de entorno LD_LIBRARY_PATH.

Si usas TensorFlow, debes elegir una combinación compatible de las herramientas de CUDA y las versiones de cuDNN. Para obtener más información, consulta los Requisitos de software y las configuraciones de compilación probadas.

Selecciona el tipo y cantidad de GPU para los trabajadores de Dataflow

Dataflow te permite configurar el tipo y la cantidad de GPU que se conectarán a los trabajadores de Dataflow mediante el parámetro worker_accelerator. Puedes seleccionar el tipo y la cantidad de GPU en función de tu caso práctico y cómo planeas usar las GPU en tu canalización.

Los siguientes tipos de GPU son compatibles con Dataflow:

  • NVIDIA® Tesla® T4
  • NVIDIA® Tesla® P4
  • NVIDIA® Tesla® V100
  • NVIDIA® Tesla® P100
  • NVIDIA® Tesla® K80

Para obtener información más detallada sobre cada tipo de GPU, incluidos los datos de rendimiento, lee el Gráfico de comparación de GPU.

Ejecuta tu trabajo con GPU

Para ejecutar un trabajo de Dataflow con GPU, usa el siguiente comando:

Python

python PIPELINE \
  --runner "DataflowRunner" \
  --project "PROJECT" \
  --temp_location "gs://BUCKET/tmp" \
  --region "REGION" \
  --worker_zone "WORKER_ZONE" \
  --worker_harness_container_image "IMAGE" \
  --experiment "worker_accelerator=type:GPU_TYPE;count:GPU_COUNT;install-nvidia-driver" \
  --experiment "use_runner_v2"

Reemplaza lo siguiente:

  • PIPELINE: tu archivo de código fuente de canalización
  • PROJECT: el nombre del proyecto de Google Cloud
  • BUCKET: el bucket de Cloud Storage
  • REGION: un extremo regional
  • WORKER_ZONE: una zona de Compute Engine para iniciar instancias de trabajadores
  • IMAGE: la ruta de acceso de Container Registry para tu imagen de Docker
  • GPU_TYPE: un tipo de GPU disponible
  • GPU_COUNT: cantidad de GPU para conectar a cada VM de trabajador

Las consideraciones para ejecutar un trabajo de Dataflow con GPU incluyen las siguientes:

  • Para proporcionar un contenedor personalizado a tu trabajo con GPU, debes usar Dataflow Runner v2.
  • Selecciona una WORKER_ZONE que admita el GPU_TYPE.
  • El URI IMAGE del contenedor debe incluir una etiqueta. Puedes usar :latest en lugar de omitir la etiqueta.

Si usas TensorFlow, considera seleccionar un tipo de máquina con 1 CPU virtual. Si n1-standard-1 no proporciona suficiente memoria, puedes considerar un tipo de máquina personalizado, como n1-custom-1-NUMBER_OF_MB o n1-custom-1-NUMBER_OF_MB-ext para memoria extendida. Cuando se especifica este tipo de máquina, NUMBER_OF_MB debe ser un múltiplo de 256.

Verifica tu trabajo de Dataflow

Para confirmar que el trabajo use VM de trabajador con GPU, sigue estos pasos:

  1. Verifica que los trabajadores de Dataflow para el trabajo se hayan iniciado.
  2. Mientras se ejecuta un trabajo, busca una VM de trabajador asociada con el trabajo.
    1. Pega el ID de trabajo en el mensaje Buscar productos y recursos.
    2. Selecciona la instancia de VM de Compute Engine asociada con el trabajo.

También puedes encontrar una lista de todas las instancias en ejecución en la consola de Compute Engine.

  1. En Google Cloud Console, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Haz clic en Detalles de la instancia de VM.

  3. Verifica que la página de detalles tenga una sección GPU y que tus GPU estén conectadas.

Si tu trabajo no se inició con GPU, verifica que el experimento --worker_accelerator esté configurado correctamente y que se vea en la IU de supervisión de Dataflow en experiments. El orden de los tokens en los metadatos del acelerador es importante.

Por ejemplo, una opción de canalización de “experimentos” en la IU de supervisión de Dataflow podría tener el siguiente aspecto:

['use_runner_v2','worker_accelerator=type:nvidia-tesla-t4;count:1;install-nvidia-driver', ...]

Soluciona problemas de tu trabajo de Dataflow

Si tienes problemas para ejecutar tu trabajo de Dataflow con GPU, obtén información sobre los pasos para solucionar problemas que podrían resolver el problema.

Los trabajadores no inician

Si tu trabajo está atascado y no se inician los trabajadores de Dataflow, verifica que estés usando un tipo de máquina compatible:

Si encuentras los errores ZONE_RESOURCE_POOL_EXHAUSTED o ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS, intenta iniciar la canalización en una zona diferente o con un tipo de acelerador diferente.

No hay uso de GPU

Si tu canalización se ejecuta de forma correcta, pero no se usan las GPU, verifica lo siguiente:

  • Las bibliotecas de NVIDIA instaladas en los contenedores de trabajador coinciden con los requisitos del código de usuario de la canalización.
  • Se puede acceder a las bibliotecas de NVIDIA instaladas como bibliotecas compartidas.

Si usas marcos de trabajo que admiten dispositivos de GPU, como TensorFlow, asegúrate de que estos marcos de trabajo puedan acceder a los dispositivos conectados. Por ejemplo, si usas TensorFlow, puedes imprimir dispositivos disponibles con lo siguiente:

import logging
import tensorflow as tf
gpu_devices = tf.config.list_physical_devices("GPU")
logging.info("GPU devices: {}".format(gpu_devices))
if len(gpu_devices) == 0:
  logging.warning("No GPUs found, defaulting to CPU")

Si los dispositivos no están disponibles, puede que estés usando una configuración de software incompatible. Por ejemplo, si usas TensorFlow, verifica que tengas una combinación compatible de TensorFlow, la versión de cuDNN y la versión de CUDA Toolkit.

Si tienes problemas para identificar la falta de coincidencia, intenta comenzar desde la configuración conocida que funciona y repite el proceso. Puedes hacerlo mediante los instructivos de muestra y las imágenes de Docker preconfigurados para uso de GPU, como los que se encuentran en imágenes de Docker de TensorFlow y la imagen de contenedores de aprendizaje profundo.

Depura con una VM independiente

Puedes depurar tu contenedor personalizado en una VM independiente con GPU si creas una VM de Compute Engine que ejecute GPU en Container-Optimized OS, la instalación de controladores y el inicio de tu contenedor. Para obtener instrucciones detalladas sobre estos pasos, consulta Primeros pasos: Ejecuta GPU en Container-Optimized OS.

Los contenedores del SDK de Apache Beam usan el punto de entrada /opt/apache/beam/boot. Para fines de depuración, puedes iniciar tu contenedor de forma manual con un punto de entrada diferente, como se muestra en el siguiente ejemplo:

docker run --rm \
  -it \
  --entrypoint=/bin/bash \
  --volume /var/lib/nvidia/lib64:/usr/local/nvidia/lib64 \
  --volume /var/lib/nvidia/bin:/usr/local/nvidia/bin \
  --privileged \
  IMAGE

Reemplaza IMAGE con la ruta de acceso de Container Registry para tu imagen de Docker.

Luego, verifica que las bibliotecas de GPU instaladas en tu contenedor puedan acceder a los dispositivos de GPU.

¿Qué sigue?