Eseguire una pipeline con GPU

Nota: a questa offerta GA si applicano le seguenti considerazioni:

• I job che utilizzano GPU sono soggetti agli addebiti specificati nella pagina dei prezzi di Dataflow.
• Per utilizzare le GPU, il job Dataflow deve utilizzare Dataflow Runner v2.

Questa pagina spiega come eseguire una pipeline Apache Beam su Dataflow con GPU. I job che utilizzano GPU sono soggetti agli addebiti specificati nella pagina dei prezzi di Dataflow.

Per ulteriori informazioni sull'utilizzo delle GPU con Dataflow, consulta Supporto di Dataflow per GPU. Per saperne di più sul flusso di lavoro degli sviluppatori per la creazione di pipeline mediante GPU, consulta Informazioni sulle GPU con Dataflow.

Usa blocchi note Apache Beam

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

I blocchi note Apache Beam offrono un modo pratico per prototipare e sviluppare in modo iterativo la pipeline con GPU senza configurare un ambiente di sviluppo. Per iniziare, leggi la guida Developing with Apache Beam Notebooks, avvia un'istanza di blocchi note Apache Beam e segui il blocco note di esempio Utilizzare GPU con Apache Beam.

Esegui il provisioning della quota GPU

I dispositivi GPU sono soggetti alla disponibilità della quota del tuo progetto Google Cloud. Richiedi la quota GPU nell'area geografica che preferisci.

Installa i driver 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 nei worker 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 dal programma di installazione del driver NVIDIA sono montati nel container che esegue il codice utente della pipeline in /usr/local/nvidia/.

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

Attenzione: non installare i driver GPU nelle immagini container personalizzate, perché questi driver potrebbero essere in conflitto con la versione del driver utilizzata da Dataflow.

Crea un'immagine container personalizzata

Per interagire con le GPU, potrebbe essere necessario software NVIDIA aggiuntivi, ad esempio librerie con accelerazione GPU e CUDA Toolkit. Fornisci queste librerie nel codice utente in esecuzione nel container Docker.

Per personalizzare l'immagine container, fornisci un'immagine che soddisfi il contratto relativo all'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 Apache Beam 2.29.0 o versioni precedenti, utilizza l'opzione della pipeline worker_harness_container_image. Per maggiori informazioni, consulta Utilizzare i container personalizzati.

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

• Usa un'immagine esistente configurata per l'utilizzo della GPU
• Utilizza un'immagine container Apache Beam

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

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

Un Dockerfile di esempio che si basa su un'immagine Docker di TensorFlow con Python 3.6 è simile al seguente esempio:

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 le immagini Docker TensorFlow, utilizza TensorFlow 2.5.0 o versioni successive. Le immagini TensorFlow Docker 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 downstream, come tfx, richiedono il pacchetto tensorflow.

Le dimensioni dei container di grandi dimensioni rallentano il tempo di avvio dei worker. Questa variazione delle prestazioni può verificarsi quando utilizzi container come Deep Learning Containers.

Installa una versione Python specifica

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

L'esempio seguente mostra come selezionare un'immagine NVIDIA che non include l'interprete Python dal catalogo delle immagini container di CUDA. Modifica l'esempio per installare la versione necessaria di Python 3 e pip. In questo esempio viene utilizzato TensorFlow. Di conseguenza, quando scegli un'immagine, le versioni CUDA e cuDNN nell'immagine di base soddisfano i requisiti per la versione di TensorFlow.

Un Dockerfile di esempio ha il seguente aspetto:

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

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

Un Dockerfile di esempio ha il seguente aspetto:

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

Attenzione: ti consigliamo di installare tutti i pacchetti Python nelle immagini di container personalizzate utilizzando pip install e di non utilizzare conda install. L'installazione di pacchetti Python da repository pip e Conda potrebbe causare problemi di interoperabilità, in particolare per i pacchetti Python che includono codice compilato. Inoltre, Apache Beam non supporta completamente gli ambienti Conda. Per maggiori informazioni, consulta Utilizzo di Pip in un ambiente Conda.

Utilizza un'immagine container Apache Beam

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

Un Dockerfile di esempio ha il seguente aspetto:

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 contenitore come librerie condivise. Per rendere rilevabili le librerie driver, configura la variabile di ambiente LD_LIBRARY_PATH.

Se usi TensorFlow, devi scegliere una combinazione compatibile di CUDA Toolkit e versioni cuDNN. Per saperne di più, 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 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 container GPU sono in genere di grandi dimensioni, per evitare di esaurire lo spazio su disco:

  • Aumenta la dimensione del disco di avvio predefinita a 50 gigabyte o più.

• Considera quanti processi usano contemporaneamente la stessa GPU su una VM worker. Quindi, decidi se limitare la GPU a un singolo processo o 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, potrebbe essere utile 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 maggiori 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 NVIDIA Multi- Processing Service (MPS).

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

Attenzione: la versione di Apache Beam e la versione secondaria dell'interprete Python nell'ambiente di lancio della pipeline e nell'immagine container devono essere uguali. Verifica le versioni nel tuo ambiente locale. In alternativa, avvia la pipeline dal container creato dalla tua immagine o crea un modello flessibile che avvii la pipeline utilizzando la tua immagine personalizzata. Per saperne di più, consulta:

• Utilizzare container personalizzati in Dataflow
• Configura modelli flessibili

Per eseguire un job Dataflow con GPU, utilizza il comando seguente. Per utilizzare l'adattamento corretto, anziché l'opzione di servizio worker_accelerator, utilizza il suggerimento delle risorse accelerator.

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 tua pipeline
• PROJECT: nome del progetto Google Cloud
• BUCKET: il bucket Cloud Storage
• REGION: una regione Dataflow, ad esempio us-central1. Seleziona una "REGION" con zone che supportano GPU_TYPE. Dataflow assegna automaticamente i worker a una zona con GPU in questa regione.
• IMAGE: il percorso Artifact Registry per la tua immagine Docker
• DISK_SIZE_GB: dimensione 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

Verifica il job Dataflow

Per confermare che il job utilizzi VM worker con GPU:

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 di 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 istanza VM.

3. Verifica che nella pagina dei dettagli sia presente una sezione GPU e che le tue GPU siano collegate.

Se il job non è stato avviato con GPU, verifica che l'opzione del 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 della pipeline dataflow_service_options nell'interfaccia di monitoraggio di Dataflow potrebbe avere il seguente aspetto:

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

Visualizza utilizzo GPU

Per visualizzare l'utilizzo della GPU sulle VM worker, segui questi passaggi:

1. Nella console Google Cloud, vai a Monitoring 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 saperne di più, consulta Metrics Explorer.

Abilita il servizio di elaborazione multipla NVIDIA

Sulle pipeline Python in esecuzione su worker con più di una vCPU, puoi migliorare la contemporaneità delle operazioni GPU abilitando NVIDIA Multi-Process Service (MPS). Per ulteriori informazioni e per la procedura di utilizzo di MPS, consulta Migliorare le prestazioni su una GPU condivisa utilizzando NVIDIA MPS.

Utilizza GPU con Dataflow Prime

Dataflow Prime consente di richiedere acceleratori per un passaggio specifico della pipeline. Per utilizzare GPU con Dataflow Prime, non utilizzare l'opzione di pipeline --dataflow-service_options=worker_accelerator. Richiedi invece le GPU con il suggerimento per la risorsa accelerator. Per maggiori informazioni, consulta Utilizzare i suggerimenti sulle risorse.

Risolvi i problemi del job Dataflow

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

Passaggi successivi

• Scopri di più sul supporto delle GPU su Dataflow.
• Esegui la pipeline di inferenza del machine learning con il tipo di GPU NVIDIA L4.
• Esamina l'elaborazione delle immagini satellitari di Landsat con GPU.