Usar GPUs com o Dataproc sem servidor

É possível anexar aceleradores de GPU às cargas de trabalho em lote do Dataproc sem servidor para alcançar os seguintes resultados:

• Acelere o processamento de cargas de trabalho de análise de dados em grande escala.

• Acelere treinamento de modelo em grandes conjuntos de dados usando as bibliotecas de machine learning da GPU.

• Fazer análises avançadas de dados, como processamento de vídeo ou linguagem natural.

Todos os ambientes de execução Spark sem servidor do Dataproc com suporte adicione a biblioteca RAPIDS do Spark a cada nó da carga de trabalho. Ambiente de execução do Spark sem servidor para Dataproc versão 1.1 também adiciona a biblioteca XGBoost aos nós de carga de trabalho. Essas bibliotecas oferecem um poderoso ferramentas de machine learning que podem ser usadas em cargas de trabalho com aceleração de GPU.

Benefícios da GPU

Confira alguns benefícios do uso de GPUs com as cargas de trabalho do Spark sem servidor do Dataproc:

• Melhoria de desempenho: a aceleração da GPU pode aumentar significativamente a performance das cargas de trabalho do Spark, principalmente para tarefas que exigem computação intensiva, como machine learning e aprendizado profundo, processamento de gráficos e análises complexas.

• Treinamento de modelo mais rápido:para tarefas de machine learning, anexar GPUs pode reduz drasticamente o tempo necessário para treinar modelos, permitindo que cientistas de dados e engenheiros para iterar e testar rapidamente.

• Escalabilidade: os clientes podem adicionar mais nós de GPU ou GPUs mais potentes aos nós para processar necessidades cada vez mais complexas.

• Eficiência de custo: embora as GPUs exijam um investimento inicial, é possível economizar ao longo do tempo devido à redução do tempo de processamento e à utilização mais eficiente de recursos.

• Análise de dados aprimorada: a aceleração da GPU permite realizar análises avançadas, como análise de imagens e vídeos e processamento de linguagem natural, em grandes conjuntos de dados.

• Melhoria dos produtos: o processamento mais rápido permite a tomada de decisões mais rápida e aplicativos mais responsivos.

Limitações e considerações

• Você pode conectar a NVIDIA A100 ou GPUs NVIDIA L4 para cargas de trabalho em lote do Dataproc sem servidor. Os aceleradores A100 e L4 estão sujeitos à disponibilidade regional de GPU do Compute Engine.

• A biblioteca XGBoost só é fornecida para cargas de trabalho com aceleração de GPU do Dataproc Serverless ao usar o ambiente de execução do Spark versão 1.x do Dataproc Serverless.

• Os lotes acelerados por GPU sem servidor do Dataproc com XGBoost utilizam cotas do Compute Engine aumentadas. Por exemplo, para executar uma carga de trabalho em lote sem servidor que usa uma GPU NVIDIA L4, você precisa alocar a cota NVIDIA_L4_GPUS.

• Jobs ativados para acelerador não são compatíveis com constraints/compute.requireShieldedVm política da organização. Se a organização aplicar essa política, os trabalhos ativados pelo acelerador não serão executados.

• Defina o conjunto de caracteres padrão como UTF-8 ao usar a aceleração de GPU do RAPIDS com compatíveis com os ambientes de execução sem servidor do Dataproc anteriores à versão 2.2. Consulte Criar uma carga de trabalho em lote sem servidor com aceleradores de GPU para mais informações.

Preços

Consulte Preços do Dataproc sem servidor para informações sobre preços de aceleradores.

Antes de começar

Antes de criar uma carga de trabalho em lote sem servidor com aceleradores de GPU anexados, faça o seguinte:

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. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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.

Criar uma carga de trabalho em lote sem servidor com aceleradores de GPU

Envie uma carga de trabalho em lote do Dataproc sem servidor que use GPUs NVIDIA L4 para executar uma tarefa do PySpark carregada em paralelo. Siga estas etapas usando a CLI gcloud:

1. Clique em Expandir-me, crie e salve o código PySpark listado em um test-py-spark-gpu.py na máquina local usando um editor de texto ou de código.

   Expandir Fechar

   #!/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. Use a CLI gcloud na sua máquina local para enviar o job em lote sem servidor do Dataproc Serverless com cinco workers, cada um deles acelerado com GPUs 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
   

Observações:

• PROJECT_ID pelo ID do projeto no Google Cloud.
• REGION: uma região disponível do Compute Engine para executar a carga de trabalho.
• BUCKET_NAME: o nome do bucket do Cloud Storage. Uploads do Spark dependências de carga de trabalho para uma pasta /dependencies neste bucket antes para executar a carga de trabalho em lote.
• --version: todos os ambientes de execução sem servidor do Dataproc com suporte adicionam a biblioteca RAPIDS a cada nó de uma carga de trabalho acelerada por GPU. Atualmente, somente a versão 1.1 do ambiente de execução adiciona a API XGBoost a cada nó de uma carga de trabalho acelerada por GPU.

• --properties (consulte Propriedades de alocação de recursos do Spark):

  • spark.dataproc.driverEnv.LANG=C.UTF-8 e spark.executorEnv.LANG=C.UTF-8 (obrigatório com versões de ambiente de execução anteriores a 2.2): essas propriedades são definidas. o conjunto de caracteres padrão como C.UTF-8.

  • spark.dataproc.executor.compute.tier=premium (obrigatório): As cargas de trabalho aceleradas por GPU são faturadas usando unidades de computação de dados premium (DCUs). Consulte "Dataproc sem servidor" Preços do acelerador.

  • spark.dataproc.executor.disk.tier=premium (obrigatório): os nós com aceleradores A100-40, A100-80 ou L4 precisam usar o nível de disco premium.

  • spark.dataproc.executor.resource.accelerator.type=l4 (obrigatório): apenas um tipo de GPU precisa ser especificado. O job de exemplo seleciona a GPU L4. Os seguintes tipos de acelerador podem ser especificados com os seguintes nomes de argumento:

    Tipo de GPU	Nome do argumento
    A100 40 GB	a100-40
    A100 80 GB	a100-80

  • spark.executor.instances=5 (obrigatório): precisa ter pelo menos dois. Defina como cinco para este exemplo.

  • spark.executor.cores (opcional): É possível definir essa propriedade para especificar o número de vCPUs de núcleo. Os valores válidos para GPUs L4 são 4, o padrão, ou 8, 12, 16, 24, 48 ou 96. O único válido e padrão, o valor para GPUs A100 é 12. As configurações com GPUs L4 e núcleos 24, 48 ou 96 têm GPUs 2, 4 ou 8 anexadas a cada executor. Todas as outras configurações têm a GPU 1 anexada.

  • spark.dataproc.executor.disk.size (obrigatório): as GPUs L4 têm um valor fixo Tamanho do disco de 375 GB, exceto para configurações com 24, 48 ou 96 núcleos, que têm 750, 1,500 ou 3,000 GB, respectivamente. Se você definir essa propriedade como um valor diferente ao enviar uma carga de trabalho acelerada por L4, um erro vai ocorrer. Se você selecionar uma GPU A100 40 ou A100 80, os tamanhos válidos são 375 g, 750 g, 1.500 g, 3.000 g, 6.000 g e 9.000 g.

  • spark.executor.memory (opcional) e spark.executor.memoryOverhead (opcional): é possível definir uma dessas propriedades, mas não as duas. A quantidade de memória disponível consumida pela propriedade definida é aplicada à propriedade não definida. Por padrão, spark.executor.memoryOverhead é definido como 40% da memória disponível para cargas de trabalho em lote do PySpark e 10% para outras cargas de trabalho (consulte Propriedades de alocação de recursos do Spark).

    A tabela a seguir mostra a quantidade máxima de memória que pode ser definida diferentes configurações de GPU A100 e L4. O valor mínimo é 1024 MB.

    	A100 (40 GB)	A100 (80 GB)	L4 (4 núcleos)	L4 (8 núcleos)	L4 (12 núcleos)	L4 (16 núcleos)	L4 (24 núcleos)	L4 (48 núcleos)	L4 (96 núcleos)
    Memória total máxima (MB)	78040	165080	13384	26768	40152	53536	113072	160608	321216

  • Propriedades RAPIDS do Spark (opcional): por padrão, Dataproc sem servidor define os seguintes valores de propriedade RAPIDS do Spark:

    • spark.plugins=com.nvidia.spark.SQLPlugin
    • spark.executor.resource.gpu.amount=1
    • spark.task.resource.gpu.amount=1/$spark_executor_cores
    • spark.shuffle.manager=". Por padrão, essa propriedade não é definida. No entanto, a NVIDIA recomenda ativar o gerenciador de shuffle RAPIDS ao usar GPUs para melhorar o desempenho. Para isso, defina spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager quando você envia uma carga de trabalho.

    Consulte Acelerador RAPIDS para configuração do Apache Spark para definir propriedades do Spark RAPIDS e Acelerador RAPIDS para configuração avançada do Apache Spark para definir propriedades avançadas do Spark.