Esegui una pipeline con GPU

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

Per ulteriori informazioni sull'utilizzo di 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.

utilizza blocchi note 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 quota GPU

I dispositivi GPU sono soggetti alla quota disponibile del tuo progetto Google Cloud. Richiedi la quota 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.

Se specifichi l'opzione install-nvidia-driver, Dataflow installa i driver NVIDIA sui worker Dataflow utilizzando le estensioni cos-extensions fornita da Container-Optimized OS. Se specifichi install-nvidia-driver, accetti di accettare 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 del job Dataflow, nel Log dei passaggi di Dataflow della tua offerta di lavoro, cerca GPU driver.

Crea un'immagine container personalizzata

Per interagire con le GPU, potrebbe essere necessario un software NVIDIA aggiuntivo, come Librerie accelerate da GPU e il 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 fornire il valore un'immagine container utilizzando l'opzione pipeline sdk_container_image. Se utilizzi Apache Beam versione 2.29.0 o precedente, utilizza Opzione pipeline worker_harness_container_image. Per ulteriori informazioni, consulta la sezione Utilizzare i container personalizzati.

Per creare un'immagine container 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 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 Immagini Docker di TensorFlow, utilizza TensorFlow 2.5.0 o versioni successive. Versione precedente di TensorFlow Le immagini Docker installano il pacchetto tensorflow-gpu anziché tensorflow pacchetto. La distinzione non è importante dopo TensorFlow 2.1.0 ma diversi pacchetti downstream, come tfx, richiedono 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.

Installa una versione Python specifica

Se hai requisiti rigorosi per la versione Python, puoi creare la tua immagine da un'immagine base NVIDIA che dispone delle 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 di immagini dei container CUDA. Modifica il per installare la versione necessaria di Python 3 e pip. L'esempio utilizza TensorFlow. Di conseguenza, quando scegli un'immagine, le versioni CUDA e cuDNN in l'immagine di base soddisfi requisiti per la versione 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 Python usando il gestore di pacchetti del sistema operativo. In questo caso, installa il file Python da interprete 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" ]

Usa 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 la tua 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 contenuto come librerie condivise. Per rendere rilevabili le librerie dei driver, configurare 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

Configurare il tipo e il numero di GPU da collegare a Dataflow. worker, utilizza 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 GPU

Le considerazioni per l'esecuzione di un job Dataflow con le GPU includono le seguenti:

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

  • Valuta il numero di processi che utilizzano contemporaneamente la stessa GPU su una VM worker. Quindi, decidi se limitare la GPU a un singolo processo o lasciare la GPU viene usata da più processi.

    • 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 NVIDIA Multi-Processing Service (MPS).

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

Per eseguire un job Dataflow con GPU, utilizza il seguente comando. Per utilizzare adattamento 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

Verifica il job Dataflow

Per confermare 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 di Compute Engine associata al job.

Puoi anche trovare l'elenco di tutte le istanze in Compute Engine Google Cloud.

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

    Vai a Istanze VM

  2. Fai clic su Dettagli 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 il servizio worker_accelerator sia configurata correttamente e visibile in Dataflow l'interfaccia di monitoraggio in dataflow_service_options. L'ordine dei token in i metadati dell'acceleratore sono importanti.

Ad esempio, un'opzione pipeline dataflow_service_options nella L'interfaccia di monitoraggio di 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 sulle VM worker, segui questi passaggi:

  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.

Abilita il servizio di elaborazione multipla NVIDIA

Nelle pipeline Python in esecuzione su worker con più di una vCPU, puoi migliorare la contemporaneità per le operazioni GPU abilitando il servizio NVIDIA Multi-Process (MPS). Per ulteriori informazioni e per la procedura per utilizzare MPS, vedi Migliora le prestazioni su una GPU condivisa utilizzando NVIDIA MPS.

Utilizza le GPU con Dataflow Prime

Dataflow Prime consente di di richiedere acceleratori per un passaggio specifico 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, vedi Utilizza gli hint delle risorse.

Risolvi i problemi del tuo job Dataflow

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

Passaggi successivi