Usar GPUs com o Dataproc sem servidor

É possível anexar aceleradores de GPU ao Dataproc sem servidor cargas de trabalho em lote 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.

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

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 dos benefícios de usar GPUs com o Dataproc sem servidor Cargas de trabalho do Spark:

• Melhoria de desempenho: a aceleração de GPU pode aumentar significativamente Desempenho das cargas de trabalho do Spark, principalmente para tarefas com uso intenso de computação, como aprendizado profundo e de máquina, 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.

• Escalonabilidade: os clientes podem adicionar mais nós de GPU ou GPUs mais avançadas a nós para e lidar com necessidades de processamento cada vez mais complexas.

• Eficiência de custo: embora as GPUs exijam um investimento inicial, você pode alcançar economia ao longo do tempo devido à redução dos tempos de processamento e ao uso mais eficiente dos recursos.

• Análise de dados aprimorada:com a aceleração de GPU, você realiza análises avançadas, como análise de imagem e vídeo e processamento de linguagem natural em grandes conjuntos de dados.

• Produtos aprimorados:processamento mais rápido possibilita uma tomada de decisão 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 da GPU do Compute Engine.

• A biblioteca XGBoost é fornecida apenas ao Dataproc sem servidor Cargas de trabalho aceleradas por GPU ao usar o Dataproc sem servidor Ambiente de execução do Spark versão 1.x.

• Os lotes acelerados por GPU do Dataproc sem servidor com XGBoost utilizam aumentos Cotas do Compute Engine. 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 sua organização aplica essa política, a versão com acelerador ativada os jobs 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 Crie 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 dos 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. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative as APIs Dataproc, Compute Engine, and Cloud Storage.

   Ative as APIs

5. Instale a CLI do Google Cloud.

6. Para inicializar a CLI gcloud, execute o seguinte comando:

   gcloud init

7. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

8. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

9. Ative as APIs Dataproc, Compute Engine, and Cloud Storage.

   Ative as APIs

10. Instale a CLI do Google Cloud.

11. Para inicializar a CLI gcloud, execute o seguinte comando:

    gcloud init

12. No console do Cloud, acesse a página Buckets do Cloud Storage.

    Acessar a página "Buckets"

13. Clique em Criar bucket.
14. Na página Criar um bucket, insira as informações do seu bucket. Para ir à próxima etapa, clique em Continuar.
    • Em Nomear o bucket, insira um nome que atenda aos requisitos de nomenclatura de bucket.
    • Em Escolha um local para armazenar seus dados, faça o seguinte:
      • Selecione uma opção de Tipo de local.
      • Escolha uma opção de Local.
    • Em Escolher uma classe de armazenamento padrão para seus dados, selecione uma classe de armazenamento.
    • Em Escolha como controlar o acesso a objetos, selecione uma opção de Controle de acesso.
    • Em Configurações avançadas (opcional), especifique um método de criptografia, uma política de retenção ou rótulos de bucket.
15. Clique em Criar.

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.

   Quero 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 sem servidor com cinco workers, com cada um 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 do Dataproc sem servidor compatíveis adicione o 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): nós com A100-40, A100-80 ou L4 os aceleradores devem usar a camada de disco premium.

  • spark.dataproc.executor.resource.accelerator.type=l4 (obrigatório): somente é necessário especificar um tipo de GPU. O job de exemplo seleciona a GPU L4. A os seguintes tipos de acelerador podem ser especificados com o seguinte argumento nomes:

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

  • spark.executor.instances=5 (obrigatório): precisa ser pelo menos dois. Definir 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 ou 16. Os únicos campos válidos e padrão para GPUs A100 é 12.

  • spark.dataproc.executor.disk.size (obrigatório): as GPUs L4 exigem a versão 375. Tamanho em GB. Se você definir esta propriedade com um valor diferente ao enviar em uma carga de trabalho acelerada L4, ocorre um erro. Se você selecionar uma GPU A100 40 ou A100 80, os tamanhos válidos são 375g, 750g, 1500g, 3000g, 6000g; e 9.000 g.

  • spark.executor.memory (opcional) e spark.executor.memoryOverhead (opcional): é possível definir uma das opções mas não ambas. 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)
    Memória total máxima (MB)	78040	165080	13384	26768	40152	53536

  • 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 Gerenciador de embaralhamento do 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 do RAPIDS para configuração do Apache Spark e defina as propriedades do Spark RAPIDS, e Acelerador do RAPIDS para configuração avançada do Apache Spark para definir as propriedades avançadas do Spark.