Esegui una pipeline con GPU

Questa pagina spiega come eseguire una pipeline Apache Beam Dataflow con le GPU. I job che utilizzano GPU sono soggetti ad addebiti come specificato nel Dataflow pagina dei prezzi.

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

utilizza blocchi note Apache Beam

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

I blocchi note Apache Beam offrono un modo conveniente per realizzare prototipi in modo iterativo sviluppare la tua pipeline con GPU senza configurare un ambiente di sviluppo. A per iniziare, leggi Sviluppo con i blocchi note Apache Beam avvia un'istanza di blocchi note Apache Beam e segui il blocco note di esempio Utilizza GPU con Apache Beam.

Esegui il provisioning della 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 per GPU

Per installare i driver NVIDIA nell'ambiente Dataflow worker, aggiungi install-nvidia-driver al worker_accelerator opzione di servizio.

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.

Le librerie e le librerie fornite dal programma di installazione del driver NVIDIA sono montate il container che esegue il codice utente della pipeline in /usr/local/nvidia/.

La versione del driver GPU dipende dalla versione di Container-Optimized OS utilizzata e 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 container, fornisci un'immagine che soddisfi le Contratto dell'immagine container dell'SDK Apache Beam e che abbia la GPU necessaria librerie.

Per fornire un'immagine container personalizzata, utilizza Dataflow Runner v2 e fornire il valore 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, vedi Utilizzare i container personalizzati.

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

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

Puoi creare un'immagine Docker che soddisfi il container SDK Apache Beam di un'immagine di base esistente preconfigurata per l'utilizzo della GPU. Per un esempio, Immagini Docker di TensorFlow, e Immagini container NVIDIA sono preconfigurate per l'utilizzo delle 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 del rendimento che possono verificarsi quando usi container come Container di deep learning.

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 includi l'interprete Python della Catalogo delle immagini container CUDA. Regola 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 interprete 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" ]

Usa un'immagine container Apache Beam

Puoi configurare un'immagine container per l'utilizzo delle GPU senza utilizzare preconfigurate in formato Docker. Questo approccio è consigliato solo quando le immagini preconfigurate non funzionano per te. Per configurare la tua immagine container, devi selezionare un'immagine container compatibile librerie e configurare l'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 di archiviazione 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 delle versioni 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 caso d'uso e a come prevedi di utilizzare le GPU nel una pipeline o un blocco note personalizzato.

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 container GPU sono generalmente di grandi dimensioni, 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 solo processo dell'SDK Apache Beam può utilizzare la maggior parte delle GPU disponibili di memoria, ad esempio caricando un modello di grandi dimensioni su una GPU, potresti per configurare i worker in modo che utilizzino un singolo processo impostando l'opzione pipeline --experiments=no_use_multiple_sdk_containers. In alternativa, utilizza i worker con una vCPU utilizzando tipo di macchina personalizzata, come n1-custom-1-NUMBER_OF_MB o n1-custom-1-NUMBER_OF_MB-ext, per memoria estesa. Per ulteriori informazioni, vedi Utilizza 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, vedi GPU e parallelismo dei worker.

di Gemini Advanced.

Per eseguire un job Dataflow con le GPU, utilizza il comando seguente. Per usare l'adattamento giusto, invece di usare la opzione di servizio worker_accelerator, utilizza la Suggerimento per la risorsa 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 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 per il 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: dimensioni del disco di avvio per ogni VM worker, ad esempio 50
  • GPU_TYPE: uno disponibile Tipo di GPU, 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 abbia una sezione GPU e che le tue GPU siano in allegato.

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 essere simile al seguente:

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

Visualizza utilizzo GPU

Per visualizzare l'utilizzo delle 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 Esplora metriche.

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

Per saperne di più, 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 GPU con Dataflow Prime, non utilizzare --dataflow-service_options=worker_accelerator pipeline di dati. Richiedi invece le GPU con il suggerimento 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