Utilizza GPU con Dataproc serverless

Puoi collegare gli acceleratori GPU a Dataproc Serverless carichi di lavoro batch per ottenere i seguenti risultati:

• Accelera l'elaborazione di carichi di lavoro di analisi dei dati su larga scala.

• Accelera l'addestramento dei modelli su set di dati di grandi dimensioni utilizzando le librerie di machine learning GPU.

• Esegui analisi avanzate dei dati, ad esempio video o linguaggio naturale e l'elaborazione dei dati.

Tutti i runtime Spark serverless di Dataproc supportati aggiungi la libreria RAPIDS di Spark a ciascun nodo dei carichi di lavoro. Runtime Spark serverless versione 1.1 di Dataproc aggiunge anche la libreria XGBoost ai nodi dei carichi di lavoro. Queste librerie forniscono potenti strumenti di trasformazione dei dati e di machine learning che puoi utilizzare nei tuoi carichi di lavoro accelerati da GPU.

Vantaggi della GPU

Ecco alcuni dei vantaggi dell'utilizzo delle GPU con i carichi di lavoro Spark di Dataproc Serverless:

• Miglioramento delle prestazioni: l'accelerazione GPU può migliorare notevolmente le prestazioni dei carichi di lavoro Spark, in particolare per le attività che richiedono calcoli intensi, come il machine e il deep learning, l'elaborazione di grafici e analisi complesse.

• Addestramento dei modelli più rapido: per le attività di machine learning, l'attacco di GPU può ridurre drasticamente il tempo necessario per addestrare i modelli, consentendo ai data scientist e agli ingegneri di eseguire iterazioni ed esperimenti rapidamente.

• Scalabilità: i clienti possono aggiungere altri nodi GPU o GPU più potenti ai nodi per gestire esigenze di elaborazione sempre più complesse.

• Efficienza in termini di costi: sebbene le GPU richiedano un investimento iniziale, puoi ottenere costi molto contenuti di risparmio nel tempo grazie a tempi di elaborazione ridotti e a un utilizzo più efficiente delle risorse.

• Analisi dei dati avanzata: l'accelerazione GPU consente di eseguire analisi avanzate, come l'analisi di immagini e video e l'elaborazione del linguaggio naturale, su grandi set di dati.

• Prodotti migliorati: l'elaborazione più rapida consente di prendere decisioni più rapidamente e di creare applicazioni più reattive.

Limitazioni e considerazioni

• Puoi collegare NVIDIA A100 o GPU NVIDIA L4 per carichi di lavoro batch serverless Dataproc. Gli acceleratori A100 e L4 sono soggetti alla disponibilità regionale delle GPU di Compute Engine.

• La libreria XGBoost viene fornita solo a Dataproc Serverless Carichi di lavoro con accelerazione GPU quando si utilizza Dataproc Serverless Versione 1.x del runtime di Spark.

• Aumento dell'utilizzo di Dataproc serverless con accelerazione GPU da parte di XGBoost Quote di Compute Engine. Ad esempio, per eseguire un carico di lavoro batch serverless che utilizza una GPU NVIDIA L4, devi allocare la quota NVIDIA_L4_GPUS.

• I job abilitati per l'acceleratore non sono compatibili con constraints/compute.requireShieldedVm criterio dell'organizzazione. Se la tua organizzazione applica questo criterio, il relativo acceleratore abilitato i job non verranno eseguiti correttamente.

• Devi impostare il set di caratteri predefinito su UTF-8 quando utilizzi l'accelerazione GPU RAPIDS con i runtime Dataproc Serverless supportati precedenti alla versione 2.2. Consulta: Crea un carico di lavoro batch serverless con acceleratori GPU per ulteriori informazioni.

Prezzi

Consulta i prezzi di Dataproc Serverless per informazioni sui prezzi degli acceleratori.

Prima di iniziare

Prima di creare un carico di lavoro batch serverless con acceleratori GPU collegati, segui questi passaggi:

1. 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.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Enable the APIs

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Enable the APIs

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

12. In the Google Cloud console, go to the Cloud Storage Buckets page.

    Go to Buckets page

13. Click Create bucket.
14. 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.
15. Click Create.

Creare un carico di lavoro batch serverless con acceleratori GPU

Invia un carico di lavoro batch serverless Dataproc che utilizza GPU NVIDIA L4 per eseguire un'attività PySpark parallelizzata. Segui questi passaggi utilizzando gcloud CLI:

1. Fai clic su Espandi, quindi crea e salva il codice PySpark elencato in un test-py-spark-gpu.py file sul tuo computer locale utilizzando un editor di testo o di codice.

   Espandi Comprimi

   #!/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()
   )

2. Utilizza gcloud CLI sulla tua macchina locale per inviare Job batch serverless serverless Dataproc con cinque worker, con ciascun worker accelerata con le 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
   

Note:

• PROJECT_ID: l'ID del tuo progetto Google Cloud.
• REGION: una regione di Compute Engine disponibile per per eseguire il carico di lavoro.
• BUCKET_NAME: il nome del bucket Cloud Storage. Caricamenti Spark delle dipendenze del carico di lavoro in una cartella /dependencies in questo bucket prima che esegue il carico di lavoro batch.
• --version: Tutti i runtime serverless di Dataproc supportati aggiungi il metodo RAPIDS per ciascun nodo di un carico di lavoro con accelerazione GPU. Al momento, solo la versione di runtime 1.1 aggiunge la libreria XGBoost a ogni nodo di un carico di lavoro con accelerazione GPU.

• --properties (vedi Proprietà di allocazione delle risorse Spark):

  • spark.dataproc.driverEnv.LANG=C.UTF-8 e spark.executorEnv.LANG=C.UTF-8 (obbligatoria con le versioni del runtime precedenti al giorno 2.2): queste proprietà sono impostate il set di caratteri predefinito su C.UTF-8.

  • spark.dataproc.executor.compute.tier=premium (obbligatorio): I carichi di lavoro con accelerazione GPU vengono fatturati utilizzando le unità di calcolo dei dati premium (DCU). Consulta i prezzi degli acceleratori di Dataproc Serverless.

  • spark.dataproc.executor.disk.tier=premium (obbligatorio): i nodi con acceleratori A100-40, A100-80 o L4 devono utilizzare il livello di disco Premium.

  • spark.dataproc.executor.resource.accelerator.type=l4 (obbligatorio): solo occorre specificare un tipo di GPU. Il job di esempio seleziona la GPU L4. I seguenti tipi di acceleratore possono essere specificati con i seguenti nomi di argomenti:

    Tipo di GPU	Nome argomento
    A100 40 GB	a100-40
    A100 80GB	a100-80

  • spark.executor.instances=5 (obbligatorio): deve essere almeno due. Imposta su cinque per questo esempio.

  • spark.executor.cores (facoltativo): Puoi impostare questa proprietà per specificare il numero di vCPU core. I valori validi per le GPU L4 sono 4, il valore predefinito, oppure 8, 12 o 16. L'unico valore valido e predefinito per le GPU A100 è 12.

  • spark.dataproc.executor.disk.size (obbligatorio): le GPU L4 richiedono dimensioni di 375 GB. Se imposti un valore diverso per la proprietà al momento dell'invio con accelerazione L4, si verifica un errore. Se selezioni una GPU A100 40 o A100 80, le dimensioni valide sono 375 g, 750 g, 1500 g, 3000 g, 6000 g e 9000 g.

  • spark.executor.memory (facoltativo) e (Facoltativo) spark.executor.memoryOverhead: puoi impostare una di queste opzioni ma non entrambe. La quantità di memoria disponibile non utilizzato dalla proprietà impostata viene applicata alla proprietà non impostata. Per impostazione predefinita, spark.executor.memoryOverhead è impostato sul 40% della memoria disponibile per i carichi di lavoro batch di PySpark e sul 10% per gli altri carichi di lavoro (vedi Proprietà di allocazione delle risorse Spark).

    La tabella seguente mostra la quantità massima di memoria che può essere impostata configurazioni GPU A100 e L4 diverse. Il valore minimo per è 1024 MB.

    	A100 (40 GB)	A100 (80 GB)	L4 (4 core)	L4 (8 core)	L4 (12 core)	L4 (16 core)
    Memoria totale massima (MB)	78040	165080	13384	26768	40152	53536

  • Proprietà Spark RAPIDS (facoltativo): per impostazione predefinita, Dataproc Serverless imposta i seguenti valori delle proprietà Spark RAPIDS:

    • spark.plugins=com.nvidia.spark.SQLPlugin
    • spark.executor.resource.gpu.amount=1
    • spark.task.resource.gpu.amount=1/$spark_executor_cores
    • spark.shuffle.manager=". Per impostazione predefinita, questa proprietà non è impostata. Tuttavia, NVIDIA consiglia di attivare Gestione shuffling RAPIDS quando utilizzi le GPU per migliorare le prestazioni. Per farlo, imposta spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager quando invii un carico di lavoro.

    Consulta la sezione Configurazione di RAPIDS Accelerator per Apache Spark per impostare le proprietà RAPIDS di Spark e Configurazione avanzata di RAPIDS Accelerator per Apache Spark per impostare le proprietà avanzate di Spark.