Cette page a été traduite par l'API Cloud Translation.

Utiliser des GPU avec Dataproc sans serveur

Vous pouvez associer des accélérateurs GPU à vos charges de travail par lot Dataproc sans serveur pour obtenir les résultats suivants:

Accélérez le traitement des charges de travail d'analyse de données à grande échelle.
Accélérez l'entraînement de modèle sur de grands ensembles de données à l'aide de bibliothèques de machine learning GPU.
Effectuer des analyses de données avancées, telles que le traitement vidéo ou du langage naturel

Tous les environnements d'exécution Spark Dataproc sans serveur compatibles ajoutent la bibliothèque Spark RAPIDS à chaque nœud de charge de travail. La version 1.1 de l'environnement d'exécution Spark de Dataproc sans serveur ajoute également la bibliothèque XGBoost aux nœuds de charge de travail. Ces bibliothèques fournissent des outils de transformation de données et de machine learning puissants que vous pouvez utiliser dans vos charges de travail accélérées par GPU.

Avantages des GPU

Voici quelques-uns des avantages de l'utilisation de GPU avec vos charges de travail Spark Dataproc sans serveur:

Amélioration des performances:l'accélération GPU peut considérablement améliorer les performances des charges de travail Spark, en particulier pour les tâches gourmandes en ressources de calcul, telles que le machine learning et le deep learning, le traitement de graphiques et l'analyse complexe.
Entraînement des modèles plus rapide:pour les tâches de machine learning, l'association de GPU peut réduire considérablement le temps nécessaire à l'entraînement des modèles, ce qui permet aux data scientists et aux ingénieurs d'itérer et de tester rapidement.
Évolutivité:les clients peuvent ajouter des nœuds GPU ou des GPU plus puissants aux nœuds pour répondre à des besoins de traitement de plus en plus complexes.
Économies de coûts:bien que les GPU nécessitent un investissement initial, vous pouvez réaliser des économies de coûts au fil du temps grâce à des temps de traitement réduits et à une utilisation plus efficace des ressources.
Analyse des données améliorée:l'accélération GPU vous permet d'effectuer des analyses avancées, telles que l'analyse d'images et de vidéos, ainsi que le traitement du langage naturel, sur de grands ensembles de données.
Amélioration des produits:un traitement plus rapide permet de prendre des décisions plus rapidement et d'obtenir des applications plus réactives.

Limites et points à noter

Vous pouvez associer des GPU NVIDIA A100 ou NVIDIA L4 aux charges de travail par lot sans serveur Dataproc. Les accélérateurs A100 et L4 sont soumis à la disponibilité régionale des GPU Compute Engine.
La bibliothèque XGBoost n'est fournie qu'aux charges de travail accélérées par GPU de Dataproc sans serveur lorsque vous utilisez la version d'exécution Spark 1.x de Dataproc sans serveur.
Les lots Dataproc sans serveur accélérés par GPU avec XGBoost utilisent des quotas Compute Engine plus élevés. Par exemple, pour exécuter une charge de travail par lot sans serveur qui utilise un GPU NVIDIA L4, vous devez allouer le quota NVIDIA_L4_GPUS.
Les tâches compatibles avec l'accélérateur ne sont pas compatibles avec la règle d'administration constraints/compute.requireShieldedVm. Si votre organisation applique cette règle, ses jobs compatibles avec l'accélérateur ne s'exécuteront pas correctement.
Vous devez définir le jeu de caractères par défaut sur UTF-8 lorsque vous utilisez l'accélération GPU RAPIDS avec les environnements d'exécution Dataproc sans serveur compatibles antérieurs à la version 2.2. Pour en savoir plus, consultez la section Créer une charge de travail par lot sans serveur avec des accélérateurs GPU.

Tarifs

Pour en savoir plus sur la tarification des accélérateurs, consultez la page Tarifs de Dataproc sans serveur.

Avant de commencer

Avant de créer une charge de travail par lot sans serveur avec des accélérateurs GPU associés, procédez comme suit:

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, go to the Cloud Storage Buckets page.
Go to Buckets page
Click Create bucket.
On the Create a bucket page, enter your bucket information. To go to the next step, click Continue.
- For Name your bucket, enter a name that meets the bucket naming requirements.
- For Choose where to store your data, do the following:
  - Select a Location type option.
  - Select a Location option.
- For Choose a default storage class for your data, select a storage class.
- For Choose how to control access to objects, select an Access control option.
- For Advanced settings (optional), specify an encryption method, a retention policy, or bucket labels.
Click Create.

Créer une charge de travail par lot sans serveur avec des accélérateurs de GPU

Envoyez une charge de travail par lot Dataproc sans serveur qui utilise des GPU NVIDIA L4 pour exécuter une tâche PySpark parallélisée. Suivez ces étapes à l'aide de la gcloud CLI:

Cliquez sur Développer, puis créez et enregistrez le code PySpark listé dans un fichier test-py-spark-gpu.py sur votre ordinateur local à l'aide d'un éditeur de texte ou de code.

#!/usr/bin/env python

"""S8s Accelerators Example."""

import subprocess
from typing import Any
from pyspark.sql import SparkSession
from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType
from pyspark.sql.types import StructField
from pyspark.sql.types import StructType

spark = SparkSession.builder.appName("joindemo").getOrCreate()


def get_num_gpus(_: Any) -> int:
  """Returns the number of GPUs."""
  p_nvidia_smi = subprocess.Popen(
      ["nvidia-smi", "-L"], stdin=None, stdout=subprocess.PIPE
  )
  p_wc = subprocess.Popen(
      ["wc", "-l"],
      stdin=p_nvidia_smi.stdout,
      stdout=subprocess.PIPE,
      stderr=subprocess.PIPE,
      universal_newlines=True,
  )
  [out, _] = p_wc.communicate()
  return int(out)


num_workers = 5
result = (
    spark.sparkContext.range(0, num_workers, 1, num_workers)
    .map(get_num_gpus)
    .collect()
)
num_gpus = sum(result)
print(f"Total accelerators: {num_gpus}")

# Run the join example
schema = StructType([StructField("value", IntegerType(), True)])
df = (
    spark.sparkContext.parallelize(range(1, 10000001), 6)
    .map(lambda x: (x,))
    .toDF(schema)
)
df2 = (
    spark.sparkContext.parallelize(range(1, 10000001), 6)
    .map(lambda x: (x,))
    .toDF(schema)
)
joined_df = (
    df.select(col("value").alias("a"))
    .join(df2.select(col("value").alias("b")), col("a") == col("b"))
    .explain()
)

Utilisez gcloud CLI sur votre ordinateur local pour envoyer la job par lot sans serveur Dataproc Serverless avec cinq nœuds de travail, chacun accéléré par des GPU L4:

gcloud dataproc batches submit pyspark test-py-spark-gpu.py \
    --project=PROJECT_ID \
    --region=REGION \
    --deps-bucket=BUCKET_NAME \
    --version=1.1 \
    --properties=spark.dataproc.executor.compute.tier=premium,spark.dataproc.executor.disk.tier=premium,spark.dataproc.executor.resource.accelerator.type=l4,spark.executor.instances=5,spark.dataproc.driverEnv.LANG=C.UTF-8,spark.executorEnv.LANG=C.UTF-8,spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager

Remarques :

PROJECT_ID : ID de votre projet Google Cloud.
REGION: région Compute Engine disponible pour exécuter la charge de travail.
BUCKET_NAME : nom du bucket Cloud Storage. Spark importe les dépendances de la charge de travail dans un dossier /dependencies de ce bucket avant d'exécuter la charge de travail par lot.
--version::toutes les exécutions sans serveur Dataproc compatibles ajoutent la bibliothèque RAPIDS à chaque nœud d'une charge de travail accélérée par GPU. Seule la version d'exécution 1.1 ajoute la bibliothèque XGBoost à chaque nœud d'une charge de travail accélérée par GPU.

--properties (voir Propriétés d'allocation de ressources Spark) :

spark.dataproc.driverEnv.LANG=C.UTF-8 et spark.executorEnv.LANG=C.UTF-8 (obligatoire avec les versions d'exécution antérieures à 2.2): ces propriétés définissent l'ensemble de caractères par défaut sur C.UTF-8.
spark.dataproc.executor.compute.tier=premium (obligatoire) : les charges de travail accélérées par GPU sont facturées à l'aide d'unités de calcul de données (DCU) premium. Consultez les tarifs de l'accélérateur Dataproc sans serveur.
spark.dataproc.executor.disk.tier=premium (obligatoire): les nœuds avec des accélérateurs A100-40, A100-80 ou L4 doivent utiliser le niveau de disque Premium.
spark.dataproc.executor.resource.accelerator.type=l4 (obligatoire): un seul type de GPU doit être spécifié. L'exemple de tâche sélectionne le GPU L4. Les types d'accélérateurs suivants peuvent être spécifiés avec les noms d'arguments suivants:

Type de GPU Nom de l'argument

A100 40 Go a100-40

A100 80 Go a100-80
spark.executor.instances=5 (obligatoire): doit être au moins égal à deux. Définissez-le sur cinq pour cet exemple.
spark.executor.cores (facultatif) : vous pouvez définir cette propriété pour spécifier le nombre de vCPU de cœur. Les valeurs valides pour les GPU L4 sont 4 (valeur par défaut), 8, 12, 16, 24, 48 ou 96. La seule valeur valide et par défaut pour les GPU A100 est 12. Les configurations avec des GPU L4 et des cœurs 24, 48 ou 96 comportent des GPU 2, 4 ou 8 associés à chaque exécuteur. Toutes les autres configurations sont associées à un GPU 1.
spark.dataproc.executor.disk.size (obligatoire): les GPU L4 ont une taille de disque fixe de 375 Go, sauf pour les configurations avec des cœurs 24, 48 ou 96, qui ont respectivement 750, 1,500 ou 3,000 Go. Si vous définissez cette propriété sur une valeur différente lorsque vous envoyez une charge de travail accélérée par L4, une erreur se produit. Si vous sélectionnez un GPU A100 40 ou A100 80, les tailles valides sont 375 g, 750 g, 1 500 g, 3 000 g, 6 000 g et 9 000 g.

Type de GPU	Nom de l'argument
A100 40 Go	`a100-40`
A100 80 Go	`a100-80`

spark.executor.memory (facultatif) et spark.executor.memoryOverhead (facultatif): vous pouvez définir l'une de ces propriétés, mais pas les deux. La quantité de mémoire disponible non consommée par la propriété définie est appliquée à la propriété non définie. Par défaut, spark.executor.memoryOverhead est défini sur 40% de la mémoire disponible pour les charges de travail par lot PySpark et sur 10% pour les autres charges de travail (voir la section Propriétés d'allocation de ressources Spark).

Le tableau suivant indique la quantité maximale de mémoire pouvant être définie pour différentes configurations de GPU A100 et L4. La valeur minimale pour l'une ou l'autre de ces propriétés est de 1024 Mo.

	A100 (40 Go)	A100 (80 Go)	L4 (4 cœurs)	L4 (8 cœurs)	L4 (12 cœurs)	L4 (16 cœurs)	L4 (24 cœurs)	L4 (48 cœurs)	L4 (96 cœurs)
Mémoire totale maximale (Mo)	78040	165080	13384	26768	40152	53536	113072	160608	321216

Propriétés Spark RAPIDS (facultatif): par défaut, Dataproc sans serveur définit les valeurs de propriété Spark RAPIDS suivantes:
- spark.plugins=com.nvidia.spark.SQLPlugin
- spark.executor.resource.gpu.amount=1
- spark.task.resource.gpu.amount=1/$spark_executor_cores
- spark.shuffle.manager=''. Par défaut, cette propriété n'est pas définie. Toutefois, NVIDIA recommande d'activer le gestionnaire de mélange RAPIDS lorsque vous utilisez des GPU pour améliorer les performances. Pour ce faire, définissez spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager lorsque vous envoyez une charge de travail.
Consultez la section Configuration de l'accélérateur RAPIDS pour Apache Spark pour définir les propriétés RAPIDS de Spark, et Configuration avancée de l'accélérateur RAPIDS pour Apache Spark pour définir les propriétés avancées de Spark.