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 offrono una potente trasformazione dei dati di machine learning utilizzabili nei carichi di lavoro con accelerazione GPU.

Vantaggi della GPU

Ecco alcuni dei vantaggi dell'utilizzo di GPU con Dataproc Serverless Carichi di lavoro Spark:

• Miglioramento delle prestazioni: l'accelerazione della GPU può aumentare significativamente Prestazioni dei carichi di lavoro Spark, in particolare per attività ad alta intensità di calcolo, come machine learning e deep learning, elaborazione di grafici e analisi complesse.

• Addestramento dei modelli più rapido: per le attività di machine learning, il collegamento di GPU può ridurre drasticamente il tempo necessario per l'addestramento dei modelli, consentendo ai data scientist e tecnici di eseguire iterazioni e sperimentare rapidamente.

• Scalabilità: i clienti possono aggiungere più nodi GPU o GPU più potenti ai nodi per a 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 un processo decisionale più rapido e 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 a Disponibilità a livello di regione 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 runtime Dataproc serverless supportati prima della 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, procedi nel seguente modo:

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Dataproc, Compute Engine, and Cloud Storage.

   Abilita le API

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. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

9. Abilita le API Dataproc, Compute Engine, and Cloud Storage.

   Abilita le API

10. Install the Google Cloud CLI.

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

    gcloud init

12. Nella console Google Cloud, vai alla pagina Bucket di Cloud Storage.

    Vai alla pagina Bucket

13. Fai clic su Crea bucket.
14. Nella pagina Crea un bucket, inserisci le informazioni del bucket. Per andare al passaggio successivo, fai clic su Continua.
    • In Assegna un nome al bucket, inserisci un nome che soddisfi i requisiti di denominazione dei bucket.
    • Per Scegli dove archiviare i tuoi dati, segui questi passaggi:
      • Seleziona un'opzione Tipo di località.
      • Seleziona un'opzione Località.
    • In Scegli una classe di archiviazione predefinita per i dati, seleziona una classe di archiviazione.
    • Per Scegli come controllare l'accesso agli oggetti, seleziona un'opzione Controllo dell'accesso.
    • In Impostazioni avanzate (facoltative), specifica un metodo di crittografia, un criterio di conservazione o le etichette dei bucket.
15. Fai clic su Crea.

Crea 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 me, quindi crea e salva il codice PySpark elencato in un test-py-spark-gpu.py sulla tua macchina locale utilizzando un editor di testo o di codice.

   Espandi Comprimimi

   #!/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 tuo 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 1.1 del runtime aggiunge XGBoost per ciascun nodo di un carico di lavoro con accelerazione GPU.

• --properties (vedi Proprietà di allocazione delle risorse di 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). Visualizza Dataproc serverless Prezzi dell'acceleratore.

  • spark.dataproc.executor.disk.tier=premium (obbligatorio): nodi con A100-40, A100-80 o L4 per gli acceleratori devono usare il livello 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. La i seguenti tipi di acceleratori possono essere specificati con l'argomento seguente nomi:

    Tipo di GPU	Nome argomento
    A100 40GB	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 la versione 375 GB. Se imposti un valore diverso per la proprietà al momento dell'invio con accelerazione L4, si verifica un errore. Se selezioni un GPU A100 40 o A100 80, le dimensioni valide sono 375g, 750g, 1500g, 3000g, 6000g, 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, l'app spark.executor.memoryOverhead è impostata sul 40% della memoria disponibile per per i carichi di lavoro batch PySpark e il 10% per gli altri carichi di lavoro (vedi Proprietà di allocazione delle risorse di 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. A questo scopo, imposta spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager quando invii un carico di lavoro.

    Consulta RAPIDS Accelerator for Apache Spark Configuration per impostare le proprietà Spark RAPIDS e RAPIDS Accelerator for Apache Spark Advanced Configuration per impostare le proprietà avanzate di Spark.