Exécuter un pipeline avec des GPU

Remarque : Les considérations suivantes s'appliquent à cette offre GA :

• Les tâches utilisant des GPU sont facturées comme indiqué sur la page des tarifs de Dataflow.
• Pour utiliser des GPU, votre tâche Dataflow doit utiliser Dataflow Runner v2.

Cette page explique comment exécuter un pipeline Apache Beam sur Dataflow avec des GPU. Les tâches utilisant des GPU sont facturées comme indiqué sur la page des tarifs de Dataflow.

Pour en savoir plus sur l'utilisation des GPU avec Dataflow, consultez la page Compatibilité de Dataflow avec les GPU. Pour en savoir plus sur le workflow de développement permettant de créer des pipelines à l'aide des GPU, consultez la page À propos des GPU avec Dataflow.

Utiliser des notebooks Apache Beam

Si vous disposez déjà d'un pipeline que vous souhaitez exécuter avec des GPU sur Dataflow, vous pouvez ignorer cette section.

Les notebooks Apache Beam sont un moyen pratique de créer des prototypes et de développer votre pipeline de manière itérative à l'aide de GPU, sans avoir besoin de configurer d'environnement de développement. Pour commencer, consultez le guide Développer avec des notebooks Apache Beam, lancez une instance de notebook Apache Beam, puis suivez les instructions de l'exemple de notebook Utiliser des GPU avec Apache Beam.

Provisionner le quota de GPU

Les appareils GPU sont soumis à la disponibilité de quota de votre projet Google Cloud. Demandez un quota de GPU dans la région de votre choix.

Installer des pilotes de GPU.

Pour installer des pilotes NVIDIA sur les nœuds de calcul Dataflow, ajoutez install-nvidia-driver à l'option de service worker_accelerator.

Lorsque vous spécifiez l'option install-nvidia-driver, Dataflow installe les pilotes NVIDIA sur les nœuds de calcul Dataflow à l'aide de l'utilitaire cos-extensions fourni par Container-Optimized OS. En spécifiant install-nvidia-driver, vous consentez à accepter le contrat de licence NVIDIA.

Les binaires et les bibliothèques fournis par le programme d'installation du pilote NVIDIA sont installés dans le conteneur exécutant le code utilisateur du pipeline à l'adresse /usr/local/nvidia/.

La version du pilote de GPU dépend de la version de Container-Optimized OS actuellement utilisée par Dataflow. Pour trouver la version du pilote de GPU pour une tâche Dataflow donnée, dans les journaux d'étape Dataflow de votre tâche, recherchez GPU driver.

Attention : N'installez pas de pilotes de GPU dans vos images de conteneurs personnalisées, car ces pilotes pourraient entrer en conflit avec la version du pilote utilisée par Dataflow.

Créer une image de conteneur personnalisée

Pour interagir avec les GPU, vous aurez peut-être besoin d'un logiciel NVIDIA supplémentaire, tel que des bibliothèques accélérées par GPU et le CUDA Toolkit. Fournissez ces bibliothèques dans le conteneur Docker exécutant le code utilisateur.

Pour personnaliser l'image de conteneur, fournissez une image conforme au contrat d'image de conteneur du SDK Apache Beam et disposant des bibliothèques de GPU nécessaires.

Pour fournir une image de conteneur personnalisé, utilisez Dataflow Runner v2 et fournissez l'image de conteneur à l'aide de l'option de pipeline sdk_container_image. Si vous utilisez Apache Beam version 2.29.0 ou antérieure, utilisez l'option de pipeline worker_harness_container_image. Pour en savoir plus, consultez la page Utiliser des conteneurs personnalisés.

Pour créer une image de conteneur personnalisée, utilisez l'une des deux approches suivantes :

• Utiliser une image existante configurée pour l'utilisation de GPU
• Utiliser une image de conteneur Apache Beam

Utiliser une image existante configurée pour l'utilisation de GPU

Vous pouvez créer une image Docker qui respecte le contrat de conteneur du SDK Apache Beam à partir d'une image de base existante préconfigurée pour l'utilisation de GPU. Par exemple, les images Docker TensorFlow et les images de conteneurs NVIDIA sont préconfigurées pour l'utilisation de GPU.

Voici un exemple de fichier Dockerfile créé à partir d'une image Docker TensorFlow avec Python 3.6 :

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

Lorsque vous utilisez des images Docker TensorFlow, utilisez TensorFlow 2.5.0 ou une version ultérieure. Les images Docker TensorFlow précédentes installent le package tensorflow-gpu au lieu du package tensorflow. La distinction n'est pas importante après la version 2.1.0 de TensorFlow, mais plusieurs packages en aval, tels que tfx, nécessitent le package tensorflow.

Les conteneurs de grande taille ralentissent le démarrage du nœud de calcul. Cette modification des performances peut se produire lorsque vous utilisez des conteneurs tels que des conteneurs de deep learning.

Installer une version spécifique de Python

Si vous avez des exigences strictes concernant la version Python, vous pouvez créer votre image à partir d'une image de base NVIDIA dotée des bibliothèques GPU nécessaires, puis installer l'interpréteur Python.

L'exemple suivant montre comment sélectionner une image NVIDIA qui n'inclut pas l'interpréteur Python dans le catalogue d'images de conteneurs CUDA. Ajustez l'exemple pour installer les versions de Python 3 et pip que vous souhaitez. L'exemple utilise TensorFlow. Par conséquent, lorsque vous choisissez une image, les versions CUDA et cuDNN de l'image de base répondent aux exigences de la version de TensorFlow.

Voici un exemple de fichier Dockerfile :

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

Sur certaines distributions de système d'exploitation, il peut être difficile d'installer des versions spécifiques de Python à l'aide du gestionnaire de packages standard du système d'exploitation. Dans ce cas, installez l'interpréteur Python à l'aide d'outils tels que Miniconda ou pyenv.

Voici un exemple de fichier Dockerfile :

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

Attention : Nous vous recommandons d'installer tous les packages Python dans des images de conteneurs personnalisées à l'aide de pip install et de ne pas utiliser conda install. L'installation de packages Python à partir de dépôts pip et Conda peut poser des problèmes d'interopérabilité, en particulier pour les packages Python comprenant du code compilé. En outre, Apache Beam n'est pas entièrement compatible avec les environnements Conda. Pour en savoir plus, consultez la page Utiliser Pip dans un environnement Conda.

Utiliser une image de conteneur Apache Beam

Vous pouvez configurer une image de conteneur pour utiliser des GPU sans utiliser d'images préconfigurées. Cette approche n'est recommandée que lorsque les images préconfigurées ne sont pas adaptées à vos besoins. Pour configurer votre propre image de conteneur, vous devez sélectionner des bibliothèques compatibles et configurer leur environnement d'exécution.

Voici un exemple de fichier Dockerfile :

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

Les bibliothèques de pilotes dans le répertoire /usr/local/nvidia/lib64 doivent être visibles dans le conteneur en tant que bibliothèques partagées. Pour rendre les bibliothèques de pilotes visibles, configurez la variable d'environnement LD_LIBRARY_PATH.

Si vous utilisez TensorFlow, vous devez choisir une combinaison compatible avec les versions CUDA Toolkit et CuDNN. Pour en savoir plus, consultez les articles Configuration logicielle requise et Configurations de compilation testées.

Sélectionner le type et le nombre de GPU pour les nœuds de calcul Dataflow

Pour configurer le type et le nombre de GPU à associer aux nœuds de calcul Dataflow, utilisez l'option de service worker_accelerator. Sélectionnez le type et le nombre de GPU en fonction de votre cas d'utilisation et de la manière dont vous prévoyez d'utiliser les GPU dans votre pipeline.

Pour obtenir la liste des types de GPU compatibles avec Dataflow, consultez la page Compatibilité de Dataflow avec les GPU.

Exécuter votre tâche à l'aide de GPU

Les points à prendre en compte pour exécuter une tâche Dataflow à l'aide de GPU sont les suivants :

• Étant donné que les conteneurs de GPU sont généralement volumineux, procédez comme suit pour éviter de manquer d'espace disque :

  • Augmentez la taille du disque de démarrage par défaut à 50 gigaoctets ou plus.

• Déterminez le nombre de processus utilisant simultanément le même GPU sur une VM de nœud de calcul. Décidez ensuite si vous souhaitez limiter le GPU à un seul processus ou laisser plusieurs processus utiliser celui-ci.

  • Si un processus du SDK Apache Beam peut utiliser la majeure partie de la mémoire GPU disponible, par exemple en chargeant un modèle volumineux sur un GPU, vous pouvez configurer les nœuds de calcul pour qu'ils utilisent un seul processus en définissant l'option de pipeline --experiments=no_use_multiple_sdk_containers. Vous pouvez également utiliser des nœuds de calcul avec un processeur virtuel en utilisant un type de machine personnalisé, tel que n1-custom-1-NUMBER_OF_MB ou n1-custom-1-NUMBER_OF_MB-ext, pour une extension mémoire. Pour en savoir plus, consultez la section Utiliser un type de machine avec plus de mémoire par processeur virtuel.
  • Si le GPU est partagé par plusieurs processus, activez le traitement simultané sur un GPU partagé à l'aide du service multitraitement NVIDIA (MPS).

  Pour en savoir plus, consultez la section GPU et parallélisme des nœuds de calcul.

Attention : La version Apache Beam et la version mineure de l'interpréteur Python dans l'environnement de lancement du pipeline et dans votre image de conteneur doivent être identiques. Vérifiez les versions dans votre environnement local. Vous pouvez également démarrer le pipeline depuis le conteneur créé à partir de votre image ou créer un modèle Flex qui lance le pipeline à l'aide de votre image personnalisée. Pour en savoir plus, consultez les pages suivantes :

• Utiliser des conteneurs personnalisés dans Dataflow
• Configurer les modèles Flex

Pour exécuter une tâche Dataflow à l'aide de GPU, utilisez la commande suivante. Pour utiliser l'adaptation des ressources, au lieu d'utiliser l'option de service worker_accelerator, utilisez l'optimisation de ressource 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"

Remplacez l'élément suivant :

• PIPELINE : fichier de code source de votre pipeline
• PROJECT : nom du projet Google Cloud
• BUCKET : bucket Cloud Storage.
• REGION : région Dataflow, par exemple us-central1. Sélectionnez une "RÉGION" dont les zones sont compatibles avec le GPU_TYPE. Dataflow attribue automatiquement des nœuds de calcul à une zone avec des GPU dans cette région.
• IMAGE : chemin d'accès à Artifact Registry pour votre image Docker
• DISK_SIZE_GB : taille du disque de démarrage pour chaque VM de nœud de calcul, par exemple 50
• GPU_TYPE : type de GPU disponible, par exemple nvidia-tesla-t4
• GPU_COUNT : nombre de GPU à associer à chaque VM de nœud de calcul, par exemple 1

Vérifier la tâche Dataflow

Pour vérifier que la tâche utilise des VM de nœud de calcul à l'aide de GPU, procédez comme suit :

1. Vérifiez que les nœuds de calcul Dataflow pour la tâche ont démarré.
2. Lorsqu'une tâche est en cours d'exécution, recherchez une VM de nœud de calcul associée à la tâche.
   1. Dans l'invite Rechercher des produits et des ressources, collez l'ID de la tâche.
   2. Sélectionnez l'instance de VM Compute Engine associée à la tâche.

Vous pouvez également consulter la liste de toutes les instances en cours d'exécution dans la console Compute Engine.

1. Dans Google Cloud Console, accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Cliquez sur Informations sur l'instance de VM.

3. Vérifiez que la page des détails contient une section GPU et que vos GPU sont associés.

Si votre tâche n'a pas été lancée à l'aide de GPU, vérifiez que l'option de service worker_accelerator est correctement configurée et visible dans l'interface de surveillance Dataflow de dataflow_service_options. L'ordre des jetons dans les métadonnées de l'accélérateur est important.

Par exemple, une option de pipeline dataflow_service_options dans l'interface de surveillance Dataflow peut se présenter comme suit :

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

Afficher l'utilisation des GPU

Pour consulter l'utilisation des GPU sur les VM de nœud de calcul, procédez comme suit :

1. Dans Cloud Console, accédez à Monitoring ou cliquez sur le bouton suivant :

   Accéder à Monitoring

2. Dans le volet de navigation "Surveillance", cliquez sur Explorateur de métriques.

3. Pour Type de ressource, spécifiez Dataflow Job. Pour la métrique, spécifiez GPU utilization ou GPU memory utilization, en fonction de la métrique que vous souhaitez surveiller.

Pour plus d'informations, voir Explorateur de métriques.

Activer le service de multitraitement NVIDIA

Sur les pipelines Python qui s'exécutent sur des nœuds de calcul avec plusieurs processeurs virtuels, vous pouvez améliorer la simultanéité pour les opérations GPU en activant le service multiprocessus NVIDIA (MPS). Pour plus d'informations et d'étapes pour utiliser MPS, consultez la page Améliorer les performances sur un GPU partagé à l'aide de NVIDIA MPS.

Utiliser des GPU avec Dataflow Prime

Dataflow Prime vous permet de demander des accélérateurs pour une étape spécifique de votre pipeline. Pour utiliser des GPU avec Dataflow Prime, n'utilisez pas l'option de pipeline --dataflow-service_options=worker_accelerator. À la place, demandez les GPU avec l'optimisation de ressource accelerator. Pour en savoir plus, consultez la section Utiliser les optimisations de ressources.

Résoudre les problèmes liés à la tâche Dataflow

Si vous rencontrez des problèmes lors de l'exécution de votre tâche Dataflow à l'aide de GPU, consultez la page Résoudre les problèmes liés à la tâche GPU Dataflow.

Étapes suivantes

• Apprenez-en plus sur la compatibilité GPU sur Dataflow.
• Exécutez votre pipeline d'inférence de machine learning avec le type de GPU NVIDIA L4.
• Utilisez le traitement d'images satellite Landsat à l'aide de GPU.