Como usar GPUs

Nesta página, explicamos como executar um job do Dataflow com GPUs. Jobs que usam GPUs geram cobranças durante o pré-lançamento, conforme especificado na página de preços do Dataflow.

Para informações mais detalhadas sobre o uso de GPUs com o Dataflow, leia Suporte do Dataflow para GPUs.

Como provisionar a cota da GPU

Os dispositivos da GPU estão sujeitos à disponibilidade de cota do projeto do Google Cloud. Solicite a cota de GPU na região de sua escolha.

Como instalar drivers de GPU

É necessário instruir o Dataflow a instalar drivers NVIDIA nos workers. Para isso, adicione install-nvidia-driver à opção worker_accelerator. Quando a opção install-nvidia-driver é especificada, o Dataflow instala drivers NVIDIA nos workers do Dataflow usando o utilitário cos-extensions fornecido pelo Container-Optimized OS. Ao especificar install-nvidia-driver, os usuários concordam em aceitar o contrato de licença da NVIDIA.

Binários e bibliotecas fornecidos pelo instalador de driver da NVIDIA são montados no contêiner que executa o código do usuário do pipeline em /usr/local/nvidia/.

Como configurar a imagem do contêiner

Para interagir com as GPUs, talvez seja necessário usar software NVIDIA adicional, como bibliotecas aceleradas por GPU e o Kit de ferramentas do CUDA (links em inglês). É necessário fornecer essas bibliotecas no contêiner do Docker que está executando o código do usuário.

É possível personalizar a imagem de contêiner fornecendo uma imagem que atenda ao contrato da imagem de contêiner do SDK do Apache Beam e tenha as bibliotecas necessárias ou construindo sobre as imagens publicadas com as versões do SDK do Apache Beam (em inglês).

Para fornecer uma imagem de contêiner personalizada, é necessário usar o Dataflow Runner v2 e fornecer a imagem do contêiner usando a opção worker_harness_container_image do pipeline.

Para mais informações, consulte Como usar contêineres personalizados.

Se você quiser criar protótipos de pipelines em GPUs como uma prova de conceito sem se preocupar com a configuração de um ambiente de desenvolvimento, consulte Como desenvolver com os notebooks do Apache Beam, inicie um notebook do Apache Beam e siga o exemplo descrito em Usar GPUs com Apache Beam (em inglês).

Criar uma imagem de contêiner personalizada a partir de uma imagem de base preexistente com o software da GPU

É possível criar uma imagem do Docker que atenda ao contrato de contêiner do SDK do Apache Beam a partir de uma imagem de base existente. Por exemplo, as imagens do Docker do TensorFlow (em inglês) e os contêineres de aprendizado profundo do AI Platform são pré-configurados para o uso da GPU.

Uma amostra do Dockerfile se parece com o seguinte:

# 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" ]

Verifique se a versão do Apache Beam e a versão menor do interpretador do Python na imagem correspondem às versões usadas para iniciar o pipeline. Para melhores resultados, use as versões mais recentes da imagem base que você escolher e o Apache Beam.

Criar uma imagem de contêiner personalizada a partir de uma imagem do SDK do Apache Beam

Para criar tendo como base imagens do Docker publicadas pelas versões do SDK do Apache Beam, é necessário instalar as bibliotecas de GPU necessárias nessas imagens.

Uma amostra do Dockerfile se parece com o seguinte:

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

As bibliotecas de driver em /usr/local/nvidia/lib64 precisam ser descobertas no contêiner como bibliotecas compartilhadas configurando a variável de ambiente LD_LIBRARY_PATH.

Para usar o TensorFlow, é preciso escolher uma combinação compatível de versões do CUDA Toolkit e do cuDNN. Para ver mais detalhes, leia Requisitos de software e Configurações do build testados (links em inglês).

Como selecionar o tipo e o número de GPUs para workers do Dataflow

O Dataflow permite configurar o tipo e o número de GPUs a serem anexadas aos workers do Dataflow usando o parâmetro worker_accelerator. Selecione o tipo e número de GPUs com base no seu caso de uso e como você planeja utilizar as GPUs no pipeline.

Os seguintes tipos de GPU são compatíveis com o Dataflow:

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

Para informações mais detalhadas sobre cada tipo de GPU, incluindo dados de desempenho, leia o gráfico de comparação de GPUs.

Como executar um job com GPUs

Para executar um job do Dataflow com GPUs, use o seguinte 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"

Substitua:

  • PIPELINE: o arquivo de código-fonte do pipeline
  • PROJECT: o nome do projeto do Google Cloud.
  • BUCKET: o bucket do Cloud Storage.
  • REGION: um endpoint regional
  • WORKER_ZONE: uma zona do Compute Engine para iniciar instâncias de worker.
  • IMAGE: o caminho do Container Registry da imagem do Docker
  • GPU_TYPE: um tipo de GPU disponível
  • GPU_COUNT: número de GPUs a serem anexadas a cada VM de worker

As considerações para executar um job do Dataflow com GPUs incluem:

  • Para fornecer um contêiner personalizado ao job com GPUs, use o Dataflow Runner v2.
  • Selecione um WORKER_ZONE compatível com o GPU_TYPE.
  • O URI do contêiner IMAGE precisa incluir uma tag. Use :latest em vez de omitir a tag.

Se você usa o TensorFlow, considere selecionar um tipo de máquina com uma vCPU. Se o n1-standard-1 não fornecer memória suficiente, considere um tipo de máquina personalizado, como n1-custom-1-NUMBER_OF_MB ou n1-custom-1-NUMBER_OF_MB-ext, para memória estendida. Ao especificar esse tipo de máquina, NUMBER_OF_MB precisa ser um múltiplo de 256.

Como verificar o job do Dataflow

Para confirmar que o job usa VMs de worker com GPUs, siga estas etapas:

  1. Verifique se os workers do Dataflow para o job foram iniciados.
  2. Durante a execução de um job, encontre uma VM de worker associada a ele.
    1. Cole o ID do job no prompt Pesquisar produtos e recursos.
    2. Selecione a instância de VM do Compute Engine associada ao job.

Também é possível encontrar uma lista de todas as instâncias em execução no console do Compute Engine.

  1. No Console do Google Cloud, acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Clique em Detalhes da instância de VM.

  3. Verifique se a página de detalhes tem uma seção GPUs e se as GPUs estão anexadas.

Se o job não foi iniciado com GPUs, verifique se o experimento --worker_accelerator está configurado corretamente e visível na IU de monitoramento do Dataflow em experiments. A ordem dos tokens nos metadados do acelerador é importante.

Por exemplo, uma opção de pipeline "experimentos" na IU de monitoramento do Dataflow pode ter a seguinte aparência:

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

Solução de problemas do job do Dataflow

Caso você tenha problemas ao executar o job do Dataflow com GPUs, saiba mais sobre as etapas de solução de problemas que podem resolver seu problema.

Os workers não são iniciados

Se o job estiver travado e os workers do Dataflow não forem iniciados, verifique se você está usando um tipo de máquina compatível:

Se você encontrar os erros ZONE_RESOURCE_POOL_EXHAUSTED ou ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS, tente iniciar o pipeline em uma zona diferente ou com um tipo de acelerador diferente.

Nenhum uso da GPU

Se o pipeline for executado com sucesso, mas as GPUs não forem usadas, verifique se:

  • as bibliotecas da NVIDIA instaladas nos contêineres de worker correspondem aos requisitos do código do usuário do pipeline;
  • as bibliotecas NVIDIA instaladas são acessíveis como bibliotecas compartilhadas.

Se você estiver usando frameworks compatíveis com dispositivos de GPU, como o TensorFlow, verifique se esses frameworks podem acessar os dispositivos conectados. Por exemplo, se você usar o TensorFlow, é possível imprimir os dispositivos disponíveis com o seguinte:

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

Se os dispositivos não estiverem disponíveis, é possível que você esteja usando uma configuração de software incompatível. Por exemplo, se você estiver usando o TensorFlow, verifique se tem uma combinação compatível (em inglês) com as versões do TensorFlow, do cuDNN e do CUDA Toolkit.

Se você tiver dificuldade para identificar a falta de correspondência, comece a partir da configuração conhecida que funciona e repita. Para fazer isso, confira alguns tutoriais de amostra e imagens do Docker pré-configuradas para uso da GPU, como os encontrados em imagens do Docker do TensorFlow (em inglês) e Imagem do Deep Learning Containers.

Depurar com uma VM independente

É possível depurar o contêiner personalizado em uma VM autônoma com GPUs. Basta criar uma VM do Compute Engine que executa GPUs no Container-Optimized OS, instalar drivers e iniciar o contêiner. Para instruções detalhadas sobre essas etapas, leia Primeiros passos: como executar GPUs no Container-Optimized OS.

Os contêineres do SDK do Apache Beam usam o ponto de entrada /opt/apache/beam/boot. Para fins de depuração, é possível iniciar o contêiner manualmente com um ponto de entrada diferente, como mostrado no exemplo a seguir:

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

Substitua IMAGE pelo caminho do Container Registry da imagem do Docker.

Em seguida, verifique se as bibliotecas de GPU instaladas no contêiner podem acessar os dispositivos da GPU.

A seguir