Execute um pipeline com GPUs

Nota: as seguintes considerações aplicam-se a esta oferta do GA:

• As tarefas que usam GPUs incorrem em custos, conforme especificado na página de preços do Dataflow.
• Para usar GPUs, a sua tarefa do Dataflow tem de usar o Dataflow Runner v2.

Esta página explica como executar um pipeline do Apache Beam no Dataflow com GPUs. As tarefas que usam GPUs incorrem em encargos, conforme especificado na página de preços do Dataflow.

Para mais informações sobre a utilização de GPUs com o Dataflow, consulte o artigo Apoio técnico do Dataflow para GPUs. Para mais informações sobre o fluxo de trabalho do programador para criar pipelines com GPUs, consulte o artigo Acerca das GPUs com o Dataflow.

Use notebooks do Apache Beam

Se já tiver um pipeline que quer executar com GPUs no Dataflow, pode ignorar esta secção.

Os blocos de notas do Apache Beam oferecem uma forma conveniente de criar protótipos e desenvolver iterativamente o seu pipeline com GPUs sem configurar um ambiente de desenvolvimento. Para começar, leia o guia Desenvolver com blocos de notas do Apache Beam, inicie uma instância de blocos de notas do Apache Beam e siga o bloco de notas de exemplo Usar GPUs com o Apache Beam.

Aprovisione a quota de GPU

Os dispositivos de GPU estão sujeitos à disponibilidade de quotas do seu projeto da Google Cloud Platform. Peça quota de GPU na região à sua escolha.

Instale controladores da GPU

Para instalar controladores NVIDIA nos trabalhadores do Dataflow, anexe install-nvidia-driver à opção de serviço worker_accelerator.

Quando especifica a opção install-nvidia-driver, o Dataflow instala os controladores da NVIDIA nos trabalhadores do Dataflow através do utilitário cos-extensions fornecido pelo SO otimizado para contentores. Ao especificar install-nvidia-driver, aceita o contrato de licença da NVIDIA.

Os ficheiros binários e as bibliotecas fornecidos pelo instalador do controlador da NVIDIA são montados no contentor que executa o código do utilizador do pipeline em /usr/local/nvidia/.

A versão do controlador da GPU depende da versão do SO otimizado para contentores usada pelo Dataflow. Para encontrar a versão do controlador da GPU para uma determinada tarefa do Dataflow, nos registos de passos do Dataflow da sua tarefa, pesquise GPU driver.

Aviso: não instale controladores de GPU nas suas imagens de contentores personalizadas, porque esses controladores podem entrar em conflito com a versão do controlador usada pelo Dataflow.

Crie uma imagem de contentor personalizada

Para interagir com as GPUs, pode precisar de software NVIDIA adicional, como bibliotecas aceleradas por GPU e o CUDA Toolkit. Forneça estas bibliotecas no contentor Docker que executa o código do utilizador.

Para personalizar a imagem do contentor, forneça uma imagem que cumpra o contrato de imagem do contentor do SDK do Apache Beam e tenha as bibliotecas de GPU necessárias.

Para fornecer uma imagem de contentor personalizada, use o Dataflow Runner v2 e forneça a imagem de contentor através da opção de pipeline sdk_container_image. Se estiver a usar a versão 2.29.0 ou anterior do Apache Beam, use a opção de pipeline worker_harness_container_image. Para mais informações, consulte o artigo Use contentores personalizados.

Para criar uma imagem de contentor personalizada, use uma das duas abordagens seguintes:

• Use uma imagem existente configurada para utilização da GPU
• Use uma imagem de contentor do Apache Beam

Use uma imagem existente configurada para utilização da GPU

Pode criar uma imagem Docker que cumpra o contrato do contentor do SDK do Apache Beam a partir de uma imagem base existente pré-configurada para utilização da GPU. Por exemplo, as imagens do Docker do TensorFlow e as imagens do contentor da NVIDIA estão pré-configuradas para utilização da GPU.

Um Dockerfile de amostra que se baseia na imagem do Docker do TensorFlow com o Python 3.6 tem o seguinte aspeto:

ARG BASE=tensorflow/tensorflow:2.5.0-gpu
FROM $BASE

# Check that the chosen base image provides the expected version of Python interpreter.
ARG PY_VERSION=3.6
RUN [[ $PY_VERSION == `python -c 'import sys; print("%s.%s" % sys.version_info[0:2])'` ]] \
   || { echo "Could not find Python interpreter or Python version is different from ${PY_VERSION}"; exit 1; }

RUN pip install --upgrade pip \
    && pip install --no-cache-dir apache-beam[gcp]==2.29.0 \
    # Verify that there are no conflicting dependencies.
    && pip check

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

# Apache Beam worker expects pip at /usr/local/bin/pip by default.
# Some images have pip in a different location. If necessary, make a symlink.
# This line can be omitted in Beam 2.30.0 and later versions.
RUN [[ `which pip` == "/usr/local/bin/pip" ]] || ln -s `which pip` /usr/local/bin/pip

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

Quando usar imagens de Docker do TensorFlow, use o TensorFlow 2.5.0 ou posterior. As imagens do Docker do TensorFlow anteriores instalam o pacote tensorflow-gpu em vez do pacote tensorflow. A distinção não é importante após o lançamento do TensorFlow 2.1.0, mas vários pacotes a jusante, como o tfx, requerem o pacote tensorflow.

Os tamanhos de contentores grandes tornam o tempo de arranque do trabalhador mais lento. Esta alteração no desempenho pode ocorrer quando usa contentores como os Deep Learning Containers.

Instale uma versão específica do Python

Se tiver requisitos rigorosos para a versão do Python, pode criar a sua imagem a partir de uma imagem base da NVIDIA que tenha as bibliotecas de GPU necessárias. Em seguida, instale o intérprete Python.

O exemplo seguinte demonstra como selecionar uma imagem NVIDIA que não inclua o intérprete Python do catálogo de imagens de contentores CUDA. Ajuste o exemplo para instalar a versão necessária do Python 3 e do pip. O exemplo usa o TensorFlow. Por conseguinte, quando escolhe uma imagem, as versões CUDA e cuDNN na imagem base satisfazem os requisitos da versão do TensorFlow.

Um Dockerfile de exemplo tem o seguinte aspeto:

# Select an NVIDIA base image with needed GPU stack from https://ngc.nvidia.com/catalog/containers/nvidia:cuda

FROM nvidia/cuda:11.0.3-cudnn8-runtime-ubuntu20.04

RUN \
    # Add Deadsnakes repository that has a variety of Python packages for Ubuntu.
    # See: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys F23C5A6CF475977595C89F51BA6932366A755776 \
    && echo "deb http://ppa.launchpad.net/deadsnakes/ppa/ubuntu focal main" >> /etc/apt/sources.list.d/custom.list \
    && echo "deb-src http://ppa.launchpad.net/deadsnakes/ppa/ubuntu focal main" >> /etc/apt/sources.list.d/custom.list \
    && apt-get update \
    && apt-get install -y curl \
        python3.8 \
        # With python3.8 package, distutils need to be installed separately.
        python3-distutils \
    && rm -rf /var/lib/apt/lists/* \
    && update-alternatives --install /usr/bin/python python /usr/bin/python3.8 10 \
    && curl https://bootstrap.pypa.io/get-pip.py | python \
    && pip install --upgrade pip \
    # Install Apache Beam and Python packages that will interact with GPUs.
    && pip install --no-cache-dir apache-beam[gcp]==2.29.0 tensorflow==2.4.0 \
    # Verify that there are no conflicting dependencies.
    && pip check

# Copy the Apache Beam worker dependencies from the Beam Python 3.8 SDK image.
COPY --from=apache/beam_python3.8_sdk:2.29.0 /opt/apache/beam /opt/apache/beam

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

Em algumas distribuições do SO, pode ser difícil instalar versões específicas do Python através do gestor de pacotes do SO. Neste caso, instale o intérprete Python com ferramentas como o Miniconda ou o pyenv.

Um Dockerfile de exemplo tem o seguinte aspeto:

FROM nvidia/cuda:11.0.3-cudnn8-runtime-ubuntu20.04

# The Python version of the Dockerfile must match the Python version you use
# to launch the Dataflow job.

ARG PYTHON_VERSION=3.8

# Update PATH so we find our new Conda and Python installations.
ENV PATH=/opt/python/bin:/opt/conda/bin:$PATH

RUN apt-get update \
    && apt-get install -y wget \
    && rm -rf /var/lib/apt/lists/* \
    # The NVIDIA image doesn't come with Python pre-installed.
    # We use Miniconda to install the Python version of our choice.
    && wget -q https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
    && bash Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda \
    && rm Miniconda3-latest-Linux-x86_64.sh \
    # Create a new Python environment with needed version, and install pip.
    && conda create -y -p /opt/python python=$PYTHON_VERSION pip \
    # Remove unused Conda packages, install necessary Python packages via pip
    # to avoid mixing packages from pip and Conda.
    && conda clean -y --all --force-pkgs-dirs \
    && pip install --upgrade pip \
    # Install Apache Beam and Python packages that will interact with GPUs.
    && pip install --no-cache-dir apache-beam[gcp]==2.29.0 tensorflow==2.4.0 \
    # Verify that there are no conflicting dependencies.
    && pip check \
    # Apache Beam worker expects pip at /usr/local/bin/pip by default.
    # You can omit this line when using Beam 2.30.0 and later versions.
    && ln -s $(which pip) /usr/local/bin/pip

# Copy the Apache Beam worker dependencies from the Apache Beam SDK for Python 3.8 image.
COPY --from=apache/beam_python3.8_sdk:2.29.0 /opt/apache/beam /opt/apache/beam

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

Aviso: recomendamos que instale todos os pacotes Python em imagens de contentores personalizadas com pip install e não use conda install. A instalação de pacotes Python de repositórios pip e Conda pode causar problemas de interoperabilidade, especialmente para pacotes Python que incluem código compilado. Além disso, o Apache Beam não suporta totalmente os ambientes Conda. Para mais informações, consulte o artigo Usar o Pip num ambiente Conda.

Use uma imagem de contentor do Apache Beam

Pode configurar uma imagem de contentor para utilização da GPU sem usar imagens pré-configuradas. Esta abordagem só é recomendada quando as imagens pré-configuradas não funcionam para si. Para configurar a sua própria imagem de contentor, tem de selecionar bibliotecas compatíveis e configurar o respetivo ambiente de execução.

Um Dockerfile de exemplo tem o seguinte aspeto:

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 controladores em /usr/local/nvidia/lib64 têm de ser detetáveis no contentor como bibliotecas partilhadas. Para tornar as bibliotecas de controladores detetáveis, configure a variável de ambiente LD_LIBRARY_PATH.

Se usar o TensorFlow, tem de escolher uma combinação compatível das versões do CUDA Toolkit e do cuDNN. Para mais informações, leia os artigos Requisitos de software e Configurações de compilação testadas.

Selecione o tipo e o número de GPUs para os trabalhadores do Dataflow

Para configurar o tipo e o número de GPUs a associar aos trabalhadores do Dataflow, use a opção de serviço worker_accelerator. Selecione o tipo e o número de GPUs com base no seu exemplo de utilização e na forma como planeia usar as GPUs no seu pipeline.

Para ver uma lista dos tipos de GPU suportados com o Dataflow, consulte o artigo Suporte do Dataflow para GPUs.

Execute o seu trabalho com GPUs

As considerações para executar uma tarefa do Dataflow com GPUs incluem o seguinte:

• Uma vez que os contentores de GPU são normalmente grandes, para evitar ficar sem espaço no disco, faça o seguinte:

  • Aumente o tamanho do disco de arranque predefinido para 50 gigabytes ou mais.

• Considere quantos processos usam em simultâneo a mesma GPU numa VM de trabalho. Em seguida, decida se quer limitar a GPU a um único processo ou permitir que vários processos usem a GPU.

  • Se um processo do SDK Apache Beam puder usar a maior parte da memória da GPU disponível, por exemplo, carregando um modelo grande numa GPU, pode querer configurar os trabalhadores para usar um único processo definindo a opção de pipeline --experiments=no_use_multiple_sdk_containers. Em alternativa, use trabalhadores com um vCPU através de um tipo de máquina personalizado, como n1-custom-1-NUMBER_OF_MB ou n1-custom-1-NUMBER_OF_MB-ext, para memória expandida. Para mais informações, consulte o artigo Use um tipo de máquina com mais memória por vCPU.
  • Se a GPU for partilhada por vários processos, ative o processamento simultâneo numa GPU partilhada através do NVIDIA Multi-Processing Service (MPS).

  Para ver informações gerais, consulte o artigo GPUs e paralelismo de trabalhadores.

Aviso: a versão do Apache Beam e a versão secundária do intérprete Python no ambiente de lançamento do pipeline e na imagem do contentor têm de ser iguais. Valide as versões no seu ambiente local. Em alternativa, inicie o pipeline a partir do contentor criado a partir da sua imagem ou crie um modelo flexível que inicie o pipeline com a sua imagem personalizada. Para mais informações, consulte:

• Use contentores personalizados no Dataflow
• Configure modelos flexíveis

Para executar uma tarefa do Dataflow com GPUs, use o seguinte comando. Para usar o ajuste certo, em vez de usar a worker_accelerator opção de serviço, use a accelerator sugestão de recurso.

Python

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

Substitua o seguinte:

• PIPELINE: o ficheiro de código-fonte do pipeline
• PROJECT: o Google Cloud nome do projeto
• BUCKET: o contentor do Cloud Storage
• REGION: uma região do Dataflow, por exemplo, us-central1. Selecione uma `REGION` que tenha zonas que suportem o GPU_TYPE. O Dataflow atribui automaticamente trabalhadores a uma zona com GPUs nesta região.
• IMAGE: o caminho do Artifact Registry para a sua imagem de Docker
• DISK_SIZE_GB: tamanho do disco de arranque para cada VM de trabalho, por exemplo, 50
• GPU_TYPE: um tipo de GPU disponível, por exemplo, nvidia-tesla-t4.
• GPU_COUNT: número de GPUs a associar a cada VM de trabalho, por exemplo, 1

Valide a tarefa do Dataflow

Para confirmar que a tarefa usa VMs de trabalho com GPUs, siga estes passos:

1. Verifique se os trabalhadores do Dataflow para a tarefa foram iniciados.
2. Enquanto uma tarefa está em execução, encontre uma VM de trabalho associada à tarefa.
   1. No comando Pesquisar produtos e recursos, cole o ID da tarefa.
   2. Selecione a instância de VM do Compute Engine associada à tarefa.

Também pode encontrar uma lista de todas as instâncias em execução na consola do Compute Engine.

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceder às instâncias de VM

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

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

Se a tarefa não foi iniciada com GPUs, verifique se a opção de serviço worker_accelerator está configurada corretamente e visível na interface de monitorização do Dataflow em dataflow_service_options. A ordem dos tokens nos metadados do acelerador é importante.

Por exemplo, uma opção de pipeline dataflow_service_options na interface de monitorização do Dataflow pode ter o seguinte aspeto:

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

Veja a utilização da GPU

Para ver a utilização da GPU nas VMs de trabalho, siga estes passos:

1. Na Google Cloud consola, aceda a Monitorização ou use o seguinte botão:

   Aceder a Monitorização

2. No painel de navegação Monitorização, clique em Explorador de métricas.

3. Para Tipo de recurso, especifique Dataflow Job. Para a métrica, especifique GPU utilization ou GPU memory utilization, consoante a métrica que quer monitorizar.

Para mais informações, consulte o Explorador de métricas.

Ative o serviço de multiprocessamento da NVIDIA

Em pipelines Python executados em trabalhadores com mais do que uma vCPU, pode melhorar a simultaneidade das operações de GPU ativando o serviço multiprocessos da NVIDIA (MPS). Para mais informações e passos para usar o MPS, consulte o artigo Melhore o desempenho numa GPU partilhada usando o MPS da NVIDIA.

Use GPUs com o Dataflow Prime

O Dataflow Prime permite-lhe pedir aceleradores para um passo específico do seu pipeline. Para usar GPUs com o Dataflow Prime, não use a opção de pipeline --dataflow-service_options=worker_accelerator. Em alternativa, peça as GPUs com a sugestão de recurso accelerator. Para mais informações, consulte o artigo Use sugestões de recursos.

Resolva problemas com a tarefa do Dataflow

Se tiver problemas ao executar a tarefa do Dataflow com GPUs, consulte o artigo Resolva problemas da tarefa de GPU do Dataflow.

O que se segue?

• Saiba mais sobre a compatibilidade com a GPU no Dataflow.
• Execute o seu pipeline de inferência de aprendizagem automática com o tipo de GPU NVIDIA L4.
• Trabalhe com o artigo Processar imagens de satélite Landsat com GPUs.