Esta página foi traduzida pela API Cloud Translation.

Resolva problemas com a tarefa da GPU do Dataflow

Se tiver problemas ao executar a tarefa do Dataflow com GPUs, siga estes passos:

Siga o fluxo de trabalho nas práticas recomendadas para trabalhar com GPUs do Dataflow para garantir que o pipeline está configurado corretamente.
Confirme se a tarefa do Dataflow está a usar GPUs. Consulte a secção Valide a tarefa do Dataflow em "Execute um pipeline com GPUs".
Depure a sua tarefa com uma VM autónoma ou usando o Dataflow.
Se o problema persistir, siga os restantes passos de resolução de problemas nesta página.

Depure a sua tarefa

Se possível, depure a tarefa com uma VM autónoma, porque a depuração com uma VM autónoma é normalmente mais rápida. No entanto, se as políticas organizacionais impedirem a depuração com uma VM autónoma, pode depurar através do Dataflow.

Depure com uma VM autónoma

Enquanto cria e itera numa imagem de contentor que funciona para si, pode ser mais rápido reduzir o ciclo de feedback experimentando a imagem de contentor numa VM autónoma.

Pode depurar o seu contentor personalizado numa VM autónoma com GPUs criando uma VM do Compute Engine que execute GPUs no SO otimizado para contentores, instalando controladores e iniciando o contentor da seguinte forma.

Crie uma instância de VM.

gcloud compute instances create INSTANCE_NAME \
  --project "PROJECT" \
  --image-family cos-stable \
  --image-project=cos-cloud  \
  --zone=us-central1-f \
  --accelerator type=nvidia-tesla-t4,count=1 \
  --maintenance-policy TERMINATE \
  --restart-on-failure  \
  --boot-disk-size=200G \
  --scopes=cloud-platform

Use ssh para estabelecer ligação à VM.

gcloud compute ssh INSTANCE_NAME --project "PROJECT"

Instale os controladores da GPU. Depois de estabelecer ligação à VM através de ssh, execute os seguintes comandos na VM:

# Run these commands on the virtual machine
cos-extensions install gpu
sudo mount --bind /var/lib/nvidia /var/lib/nvidia
sudo mount -o remount,exec /var/lib/nvidia
/var/lib/nvidia/bin/nvidia-smi

Inicie o contentor personalizado.

Os contentores do SDK do Apache Beam usam o ponto de entrada /opt/apache/beam/boot. Para fins de depuração, pode iniciar o contentor manualmente com um ponto de entrada diferente:
```
docker-credential-gcr configure-docker
docker run --rm \
  -it \
  --entrypoint=/bin/bash \
  --volume /var/lib/nvidia/lib64:/usr/local/nvidia/lib64 \
  --volume /var/lib/nvidia/bin:/usr/local/nvidia/bin \
  --privileged \
  IMAGE
```
Substitua IMAGE pelo caminho do Artifact Registry para a sua imagem do Docker.
Verifique se as bibliotecas de GPU instaladas no seu contentor podem aceder aos dispositivos de GPU.

Se estiver a usar o TensorFlow, pode imprimir os dispositivos disponíveis no intérprete Python com o seguinte:
```
>>> import tensorflow as tf
>>> print(tf.config.list_physical_devices("GPU"))
```
Se estiver a usar o PyTorch, pode inspecionar os dispositivos disponíveis no intérprete Python com o seguinte:
```
>>> import torch
>>> print(torch.cuda.is_available())
>>> print(torch.cuda.device_count())
>>> print(torch.cuda.get_device_name(0))
```

Para iterar na sua pipeline, pode iniciá-la no Direct Runner. Também pode iniciar pipelines no Dataflow Runner a partir deste ambiente.

Depure através do Dataflow

Se as restrições organizacionais impedirem a depuração numa VM autónoma, pode depurar através do Dataflow.

Simplifique o seu pipeline para que apenas detete se existem GPUs e, em seguida, execute o pipeline no Dataflow. O exemplo seguinte demonstra o aspeto do código para este pipeline:

def check_if_gpus_present(element):
  import torch
  import tensorflow as tf

  tensorflow_detects_gpus = tf.config.list_physical_devices("GPU")
  torch_detects_gpus = torch.cuda.is_available()
  if tensorflow_detects_gpus and torch_detects_gpus:
    return element

  if tensorflow_detects_gpus:
    raise Exception('PyTorch failed to detect GPUs with your setup')
  if torch_detects_gpus:
    raise Exception('Tensorflow failed to detect GPUs with your setup')
  raise Exception('Both Tensorflow and PyTorch failed to detect GPUs with your setup')

with beam.Pipeline() as p:
  _ = (p | beam.Create([1,2,3]) # Create a PCollection of the prompts.
         | beam.Map(check_if_gpus_present)
  )

Se o pipeline for bem-sucedido, o seu código consegue aceder aos GPUs. Para identificar o código problemático, insira gradualmente exemplos progressivamente maiores no código do pipeline, executando o pipeline após cada alteração.

Se o seu pipeline não detetar GPUs, siga os passos na secção Sem utilização da GPU deste documento.

Os trabalhadores não começam

Se a tarefa estiver bloqueada e os trabalhadores do Dataflow nunca começarem a processar dados, é provável que tenha um problema relacionado com a utilização de um contentor personalizado com o Dataflow. Para mais detalhes, leia o guia de resolução de problemas de contentores personalizados.

Se for utilizador do Python, verifique se as seguintes condições são cumpridas:

A versão secundária do intérprete Python na imagem do contentor é a mesma versão que usa quando inicia o pipeline. Se houver uma incompatibilidade, podem ser apresentados erros como SystemError: unknown opcode com um rastreio de pilha que envolva apache_beam/internal/pickler.py.
Se estiver a usar o SDK do Apache Beam 2.29.0 ou anterior, o elemento pip tem de estar acessível na imagem em /usr/local/bin/pip.

Recomendamos que reduza as personalizações a uma configuração de funcionamento mínima na primeira vez que usar uma imagem personalizada. Use as imagens de contentores personalizados de exemplo fornecidas nos exemplos desta página. Certifique-se de que pode executar um pipeline do Dataflow simples com esta imagem de contentor sem pedir GPUs. Em seguida, itere na solução.

Verifique se os trabalhadores têm espaço em disco suficiente para transferir a imagem do contentor. Ajuste o tamanho do disco, se necessário. As imagens grandes demoram mais tempo a ser transferidas, o que aumenta o tempo de arranque do trabalhador.

A tarefa falha imediatamente no arranque

Se encontrar os erros ZONE_RESOURCE_POOL_EXHAUSTED ou ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS, pode seguir os seguintes passos:

Não especifique a zona do trabalhador para que o Dataflow selecione a zona ideal para si.
Inicie o pipeline numa zona diferente ou com um tipo de acelerador diferente.

A tarefa falha no tempo de execução

Se a tarefa falhar no tempo de execução, verifique se existem erros de falta de memória (OOM) na máquina do trabalhador e na GPU. Os erros de OOM da GPU podem manifestar-se como erros cudaErrorMemoryAllocation out of memory nos registos do trabalhador. Se estiver a usar o TensorFlow, verifique se usa apenas um processo do TensorFlow para aceder a um dispositivo GPU. Para mais informações, leia o artigo GPUs e paralelismo de trabalhadores.

Sem utilização da GPU

Se o seu trabalho não parecer estar a usar GPUs, siga os passos na secção Depure o seu trabalho deste documento para verificar se as GPUs estão disponíveis com a sua imagem do Docker.

Se as GPUs estiverem disponíveis, mas não forem usadas, o problema é provavelmente com o código do pipeline. Para depurar o código do pipeline, comece com um pipeline simples que use GPUs com êxito e, em seguida, adicione gradualmente código ao pipeline, testando-o com cada nova adição. Para mais informações, consulte a secção Depurar no Dataflow deste documento.

Se o seu pipeline não detetar GPUs, verifique o seguinte:

As bibliotecas da NVIDIA instaladas na imagem do contentor correspondem aos requisitos do código do utilizador do pipeline e das bibliotecas que usa.
As bibliotecas NVIDIA instaladas em imagens de contentores são acessíveis como bibliotecas partilhadas.

Se os dispositivos não estiverem disponíveis, pode estar a usar uma configuração de software incompatível. Para validar a configuração da imagem, execute um pipeline simples que apenas verifique se as GPUs estão disponíveis e acessíveis aos trabalhadores.

Resolva problemas do TensorFlow

Se o PyTorch detetar GPUs no seu pipeline, mas o TensorFlow não, experimente os seguintes passos de resolução de problemas:

Verifique se tem uma combinação compatível do TensorFlow, da versão do cuDNN e da versão do CUDA Toolkit. Para mais informações, consulte as Configurações de compilação testadas na documentação do TensorFlow.
Se possível, atualize para as versões mais recentes compatíveis do TensorFlow e do CUDA.
Reveja os problemas conhecidos do TensorFlow e CUDA para verificar se um problema conhecido está a causar problemas no seu pipeline. Por exemplo, o seguinte problema conhecido pode impedir que o TensorFlow detete GPUs: O TF 2.17.0 RC0 não funciona com GPUs.