Esegui una pipeline con GPU

Questa pagina spiega come eseguire una pipeline Apache Beam su Dataflow con GPU. I job che utilizzano GPU comportano addebiti come specificato nella pagina dei prezzi di Dataflow.

Per ulteriori informazioni sull'utilizzo delle GPU con Dataflow, consulta Supporto di Dataflow per le GPU. Per maggiori informazioni sul flusso di lavoro dello sviluppatore per la creazione di pipeline con GPU, consulta Informazioni sulle GPU con Dataflow.

Utilizzare i notebook Apache Beam

Se hai già una pipeline che vuoi eseguire con le GPU su Dataflow, puoi saltare questa sezione.

I notebook Apache Beam offrono un modo pratico per creare prototipi e sviluppare in modo iterativo la pipeline con le GPU senza configurare un ambiente di sviluppo. Per iniziare, consulta la guida Sviluppo con i notebook Apache Beam, avvia un'istanza di notebook Apache Beam e segui il notebook di esempio Utilizzare le GPU con Apache Beam.

Provision della quota GPU

I dispositivi GPU sono soggetti alla disponibilità della quota del tuo progetto Google Cloud. Richiedi una quota di GPU nella regione che preferisci.

Installa i driver della GPU

Per installare i driver NVIDIA sui worker Dataflow, aggiungi install-nvidia-driver all'opzione di servizio worker_accelerator.

Quando specifichi l'opzione install-nvidia-driver, Dataflow installa i driver NVIDIA sui worker di Dataflow utilizzando l'utilità cos-extensions fornita da Container-Optimized OS. Se specifichi install-nvidia-driver, accetti il contratto di licenza NVIDIA.

I file binari e le librerie forniti dall'installatore del driver NVIDIA vengono montati nel contenutore che esegue il codice utente della pipeline in /usr/local/nvidia/.

La versione del driver GPU dipende dalla versione di Container-Optimized OS utilizzata da Dataflow. Per trovare la versione del driver GPU per un determinato job Dataflow, cerca GPU driver nei log dei passaggi di Dataflow del job.

Creare un'immagine container personalizzata

Per interagire con le GPU, potresti aver bisogno di software NVIDIA aggiuntivo, ad esempio librerie con accelerazione GPU e CUDA Toolkit. Fornisci queste librerie nel container Docker che esegue il codice utente.

Per personalizzare l'immagine del container, fornisci un'immagine che soddisfi il contratto dell'immagine del container dell'SDK Apache Beam e che disponga delle librerie GPU necessarie.

Per fornire un'immagine container personalizzata, utilizza Dataflow Runner v2 e fornisci l'immagine container utilizzando l'opzione della pipeline sdk_container_image. Se utilizzi la versione 2.29.0 o precedenti di Apache Beam, utilizza l'opzione della pipeline worker_harness_container_image. Per ulteriori informazioni, consulta la sezione Utilizzare i container personalizzati.

Per creare un'immagine del contenitore personalizzata, utilizza uno dei seguenti due approcci:

Utilizzare un'immagine esistente configurata per l'utilizzo della GPU

Puoi creare un'immagine Docker che soddisfi il contratto del container dell'SDK Apache Beam da un'immagine di base esistente preconfigurata per l'utilizzo della GPU. Ad esempio, le immagini Docker di TensorFlow e le immagini container NVIDIA sono preconfigurate per l'utilizzo della GPU.

Un Dockerfile di esempio che si basa sull'immagine Docker di TensorFlow con Python 3.6 è simile all'esempio seguente:

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 utilizzi immagini Docker di TensorFlow, utilizza TensorFlow 2.5.0 o versioni successive. Le immagini Docker di TensorFlow precedenti installano il pacchetto tensorflow-gpu anziché il pacchetto tensorflow. La distinzione non è importante dopo il rilascio di TensorFlow 2.1.0, ma diversi pacchetti a valle, come tfx, richiedono il pacchetto tensorflow.

Le dimensioni dei container di grandi dimensioni rallentano il tempo di avvio del worker. Questa variazione di prestazioni potrebbe verificarsi quando utilizzi contenitori come Deep Learning Containers.

Installare una versione specifica di Python

Se hai requisiti rigorosi per la versione di Python, puoi creare l'immagine da un'immagine di base NVIDIA con le librerie GPU necessarie. Poi, installa l'interprete Python.

L'esempio seguente mostra come selezionare un'immagine NVIDIA che non include l'interprete Python dal catalogo di immagini dei container CUDA. Modifica l'esempio per installare la versione necessaria di Python 3 e pip. L'esempio utilizza TensorFlow. Pertanto, quando scegli un'immagine, le versioni CUDA e cuDNN nell'immagine di base devono soddisfare i requisiti per la versione di TensorFlow.

Un Dockerfile di esempio è il seguente:

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

In alcune distribuzioni del sistema operativo, potrebbe essere difficile installare versioni specifiche di Python utilizzando il gestore dei pacchetti del sistema operativo. In questo caso, installa l'interprete pyenv con strumenti come Miniconda o pyenv.

Un Dockerfile di esempio è il seguente:

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

Utilizzare un'immagine container Apache Beam

Puoi configurare un'immagine container per l'utilizzo della GPU senza utilizzare immagini preconfigurate. Questo approccio è consigliato solo se le immagini preconfigurate non funzionano per te. Per configurare la tua immagine container, devi selezionare librerie compatibili e configurare il relativo ambiente di esecuzione.

Un Dockerfile di esempio è il seguente:

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

Le librerie dei driver in /usr/local/nvidia/lib64 devono essere rilevabili nel contenuto come librerie condivise. Per rendere rilevabili le librerie del driver, configura la variabile di ambiente LD_LIBRARY_PATH.

Se utilizzi TensorFlow, devi scegliere una combinazione compatibile di versioni di CUDA Toolkit e cuDNN. Per ulteriori informazioni, consulta Requisiti software e Configurazioni di build testate.

Seleziona il tipo e il numero di GPU per i worker Dataflow

Per configurare il tipo e il numero di GPU da collegare ai worker Dataflow, utilizza l'opzione di servizio worker_accelerator. Seleziona il tipo e il numero di GPU in base al tuo caso d'uso e a come prevedi di utilizzare le GPU nella pipeline.

Per un elenco dei tipi di GPU supportati con Dataflow, consulta Supporto di Dataflow per le GPU.

Esegui il job con le GPU

Le considerazioni per l'esecuzione di un job Dataflow con GPU includono quanto segue:

  • Poiché i contenitori GPU sono in genere di grandi dimensioni, per evitare di esaurire lo spazio su disco:

  • Considera quanti processi utilizzano contemporaneamente la stessa GPU su una VM worker. Poi, decidi se limitare la GPU a un singolo processo o se consentire a più processi di utilizzarla.

    • Se un processo dell'SDK Apache Beam può utilizzare la maggior parte della memoria GPU disponibile, ad esempio caricando un modello di grandi dimensioni su una GPU, ti consigliamo di configurare i worker in modo che utilizzino un singolo processo impostando l'opzione della pipeline--experiments=no_use_multiple_sdk_containers. In alternativa, utilizza i worker con una vCPU utilizzando un tipo di macchina personalizzata, come n1-custom-1-NUMBER_OF_MB o n1-custom-1-NUMBER_OF_MB-ext, per la memoria estesa. Per ulteriori informazioni, consulta Utilizzare un tipo di macchina con più memoria per vCPU.
    • Se la GPU è condivisa da più processi, abilita l'elaborazione simultanea su una GPU condivisa utilizzando il servizio NVIDIA Multi-Processing (MPS).

    Per informazioni di contesto, consulta GPU e parallelismo dei worker.

Per eseguire un job Dataflow con GPU, utilizza il seguente comando. Per utilizzare corretto, anziché l'worker_acceleratoropzione di servizio, utilizza il acceleratorsuggerimento per le risorse.

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"

Sostituisci quanto segue:

  • PIPELINE: il file del codice sorgente della pipeline
  • PROJECT: il nome del progetto Google Cloud
  • BUCKET: il bucket Cloud Storage
  • REGION: una regione Dataflow, ad esempio us-central1. Seleziona una "REGIONE" con zone che supportano GPU_TYPE. Dataflow assegna automaticamente i worker a una zona con GPU in questa regione.
  • IMAGE: il percorso di Artifact Registry per l'immagine Docker
  • DISK_SIZE_GB: dimensioni del disco di avvio per ogni VM worker, ad esempio 50
  • GPU_TYPE: un tipo di GPU disponibile, ad esempio nvidia-tesla-t4.
  • GPU_COUNT: numero di GPU da collegare a ogni VM worker, ad esempio 1

Verificare il job Dataflow

Per verificare che il job utilizzi VM worker con GPU, segui questi passaggi:

  1. Verifica che i worker Dataflow per il job siano stati avviati.
  2. Mentre un job è in esecuzione, trova una VM worker associata al job.
    1. Nel prompt Cerca prodotti e risorse, incolla l'ID job.
    2. Seleziona l'istanza VM Compute Engine associata al job.

Puoi anche trovare l'elenco di tutte le istanze in esecuzione nella console di Compute Engine.

  1. Nella console Google Cloud, vai alla pagina Istanze VM.

    Vai a Istanze VM

  2. Fai clic su Dettagli dell'istanza VM.

  3. Verifica che la pagina dei dettagli contenga una sezione GPU e che le GPU siano collegate.

Se il job non è stato avviato con le GPU, verifica che l'opzione di servizio worker_accelerator sia configurata correttamente e visibile nell'interfaccia di monitoraggio di Dataflow in dataflow_service_options. L'ordine dei token nei metadati dell'acceleratore è importante.

Ad esempio, un'opzione di pipeline dataflow_service_options nell'interfaccia di monitoraggio Dataflow potrebbe avere il seguente aspetto:

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

Visualizza l'utilizzo della GPU

Per visualizzare l'utilizzo della GPU nelle VM di lavoro:

  1. Nella console Google Cloud, vai a Monitoraggio o utilizza il pulsante seguente:

    Vai a Monitoring

  2. Nel riquadro di navigazione di Monitoring, fai clic su Metrics Explorer.

  3. In Tipo di risorsa, specifica Dataflow Job. Per la metrica, specifica GPU utilization o GPU memory utilization, a seconda della metrica che vuoi monitorare.

Per ulteriori informazioni, consulta Esplora metriche.

Attiva il servizio NVIDIA Multi-Processing

Nelle pipeline Python che vengono eseguite su worker con più di una vCPU, puoi migliorare la concorrenza per le operazioni GPU attivando il servizio NVIDIA Multi-Process (MPS). Per ulteriori informazioni e la procedura per utilizzare MPS, consulta Migliorare le prestazioni su una GPU condivisa utilizzando NVIDIA MPS.

Utilizzare le GPU con Dataflow Prime

Dataflow Prime ti consente di richiedere acceleratori per un determinato passaggio della pipeline. Per utilizzare le GPU con Dataflow Prime, non utilizzare l'opzione della pipeline --dataflow-service_options=worker_accelerator. Richiedi invece le GPU con l'indicazione della risorsa accelerator. Per ulteriori informazioni, consulta la pagina Utilizzare gli indizi sulle risorse.

Risolvere i problemi relativi al job Dataflow

Se riscontri problemi durante l'esecuzione del job Dataflow con le GPU, consulta Risolvere i problemi del job Dataflow GPU.

Passaggi successivi