HorovodRunner: aprendizagem profunda distribuída com o Horovod

important

Horovod e HorovodRunner estão obsoletos. As versões posteriores à 15.4 LTS ML não terão esse pacote pré-instalado. Para a aprendizagem profunda distribuída, a Databricks recomenda usar o TorchDistributor para treinamento distribuído com o PyTorch ou a API tf.distribute.Strategy para treinamento distribuído com o TensorFlow.

Saiba como realizar o treinamento distribuído do modelo de aprendizado de máquina usando HorovodRunner para iniciar o trabalho de treinamento Horovod como trabalho Spark em Databricks.

O que é o HorovodRunner?

HorovodRunner é um API geral para a execução de cargas de trabalho de aprendizagem profunda distribuídas em Databricks usando a Horovod estrutura. Ao integrar Horovod Sparko com o modo de barreira do, oDatabricks é capaz de oferecer maior estabilidade para aprendizagem profunda treinamento Spark Job de longa duração no. O HorovodRunner usa um método Python que contém código de treinamento de aprendizagem profunda com ganchos do Horovod. HorovodRunner seleciona o método no driver e o distribui para o funcionário Spark. Um trabalho Horovod MPI é incorporado como um trabalho Spark usando o modo de execução de barreira. O primeiro executor coleta os endereços IP de todos os executores de tarefas usando BarrierTaskContext e aciona um trabalho Horovod usando mpirun. Cada processo Python MPI carrega o programa de usuário decapado, deserializa-o e o executa.

Treinamento distribuído com HorovodRunner

HorovodRunner permite que o senhor inicie o Horovod treinamento Job como Spark Job. A API do HorovodRunner é compatível com os métodos mostrados na tabela. Para obter detalhes, consulte a documentação da API do HorovodRunner.

Método e assinatura	Descrição
init(self, np)	Criar uma instância do HorovodRunner.
**run(self, main, **kwargs)**	execução a Horovod treinamento Job invocando main(**kwargs). A função principal e os argumentos da palavra-chave são serializados usando o cloudpickle e distribuídos para o trabalhador de clustering.

A abordagem geral para desenvolver um programa de treinamento distribuído usando o HorovodRunner é a seguinte:

1. Crie uma instância HorovodRunner inicializada com o número de nós.
2. Defina um método de treinamento do Horovod de acordo com os métodos descritos no uso do Horovod, certificando-se de adicionar quaisquer instruções de importação dentro do método.
3. Passe o método de treinamento para a instância HorovodRunner.

Por exemplo:

Python

hr = HorovodRunner(np=2)

def train():
  import tensorflow as tf
  hvd.init()

hr.run(train)

Para executar HorovodRunner no driver somente com n subprocessos, use hr = HorovodRunner(np=-n). Por exemplo, se houver 4 GPUs no nó do driver, você poderá escolher n até 4. Para obter detalhes sobre o parâmetro np, consulte a documentação da API do HorovodRunner. Para obter detalhes sobre como pin uma GPU por subprocesso, consulte o guia de usoHorovod.

Um erro comum é que os objetos do TensorFlow não podem ser encontrados ou decapados. Isso acontece quando as instruções de importação da biblioteca não são distribuídas para outro executor. Para evitar esse problema, inclua todas as instruções de importação (por exemplo, import tensorflow as tf) na parte superior do método de treinamento do Horovod e dentro de qualquer outra função definida pelo usuário chamada no método de treinamento do Horovod.

Registre o treinamento do Horovod com o Horovod Timeline

O Horovod tem a capacidade de registrar a linha do tempo de sua atividade, chamada Horovod Timeline.

important

A linha do tempo do Horovod tem um impacto significativo no desempenho. Inception3 A taxa de transferência pode diminuir em ~40% quando o Horovod Timeline é ativado. Para acelerar o HorovodRunner Job, não use o Horovod Timeline.

O senhor não pode view a linha de tempo Horovod enquanto o treinamento estiver em andamento.

Para gravar uma linha do tempo do Horovod, defina a variável de ambiente HOROVOD_TIMELINE como o local onde deseja salvar o arquivo da linha do tempo. A Databricks recomenda o uso de um local no armazenamento compartilhado para que o arquivo de linha do tempo possa ser facilmente recuperado. Por exemplo, o senhor pode usar as APIs de arquivo local do DBFS conforme mostrado:

Python

timeline_dir = "/dbfs/ml/horovod-timeline/%s" % uuid.uuid4()
os.makedirs(timeline_dir)
os.environ['HOROVOD_TIMELINE'] = timeline_dir + "/horovod_timeline.json"
hr = HorovodRunner(np=4)
hr.run(run_training_horovod, params=params)

Em seguida, adicione o código específico da linha do tempo no início e no final da função de treinamento. O Notebook de exemplo a seguir inclui um código de exemplo que o senhor pode usar como solução alternativa para view treinamento progress.

Horovod Exemplo de linha do tempo Notebook

Open notebook in new tab

Para download o arquivo de linha do tempo, use o botão Databricks CLIe, em seguida, use o recurso chrome://tracing do navegador Chrome para view. Por exemplo:

Desenvolvimento fluxo de trabalho

Essas são as etapas gerais da migração do código de aprendizagem profunda de nó único para o treinamento distribuído. Os exemplos: Migrar para a aprendizagem profunda distribuída com o HorovodRunner nesta seção ilustram essas etapas.

1. Preparar o código de nó único: Preparar e testar o código de nó único com TensorFlow, Keras ou PyTorch.

2. Migrar para o Horovod: Siga as instruções de uso do Horovod para migrar o código com o Horovod e testá-lo no driver:

   1. Adicione hvd.init() para inicializar o Horovod.
   2. Fixe uma GPU de servidor para ser usada por esse processo usando config.gpu_options.visible_device_list. Com a configuração típica de uma GPU por processo, isso pode ser definido para a classificação local. Nesse caso, o primeiro processo no servidor receberá a primeira GPU, o segundo processo receberá a segunda GPU e assim por diante.
   3. Incluir um fragmento do site dataset. Esse operador dataset é muito útil ao executar o treinamento distribuído, pois permite que cada worker leia um subconjunto exclusivo.
   4. escala a taxa de aprendizado por número de trabalhadores. O tamanho efetivo dos lotes no treinamento distribuído síncrono é dimensionado pelo número de funcionários. O aumento da taxa de aprendizado compensa o aumento do tamanho dos lotes.
   5. Envolva o otimizador em hvd.DistributedOptimizer. O otimizador distribuído delega o cálculo do gradiente ao otimizador original, calcula a média dos gradientes usando allreduce ou allgather e, em seguida, aplica os gradientes médios.
   6. Adicione hvd.BroadcastGlobalVariablesHook(0) para transmitir estados variáveis iniciais da classificação 0 para todos os outros processos. Isso é necessário para garantir a inicialização consistente de todos os trabalhadores quando o treinamento é iniciado com pesos aleatórios ou restaurado a partir de um ponto de verificação. Como alternativa, se não estiver usando MonitoredTrainingSession, o senhor pode executar as operações de hvd.broadcast_global_variables após a inicialização das variáveis globais.
   7. Modifique seu código para salvar os pontos de verificação somente em worker 0 para evitar que outros trabalhadores os corrompam.

3. Migrar para HorovodRunner : HorovodRunner executar o Horovod treinamento Job invocando uma função Python. O senhor deve agrupar o procedimento principal de treinamento em uma única função Python. Em seguida, o senhor pode testar o HorovodRunner no modo local e no modo distribuído.

Atualizar a aprendizagem profunda biblioteca

Se o senhor fizer upgrade ou downgrade do TensorFlow, do Keras ou do PyTorch, deverá reinstalar o Horovod para que ele seja compilado com base na biblioteca recém-instalada. Por exemplo, se o senhor quiser fazer upgrade do TensorFlow, o Databricks recomenda usar o init script das instruções de instalação doTensorFlow e anexar o seguinte código de instalação TensorFlow específico do Horovod ao final dele. Consulte as instruções de instalação doHorovod para trabalhar com diferentes combinações, como atualização ou downgrade do PyTorch e de outras bibliotecas.

Bash

add-apt-repository -y ppa:ubuntu-toolchain-r/test
apt update

# Using the same compiler that TensorFlow was built to compile Horovod
apt install g++-7 -y
update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 60

HOROVOD_GPU_ALLREDUCE=NCCL HOROVOD_CUDA_HOME=/usr/local/cuda pip install horovod==0.18.1 --force-reinstall --no-deps --no-cache-dir

Exemplos: Migrar para a aprendizagem profunda distribuída com o HorovodRunner

Os exemplos a seguir, baseados no MNIST dataset, demonstram como migrar um programa de aprendizagem profunda de nó único para aprendizagem profunda distribuída com HorovodRunner.

• Aprendizagem profunda usando TensorFlow com HorovodRunner para MNIST
• Adaptar o PyTorch de nó único à aprendizagem profunda distribuída

Limitações

• Ao trabalhar com arquivos workspace, o HorovodRunner não funcionará se np for definido como maior que 1 e o Notebook importar de outros arquivos relativos. Considere a possibilidade de usar Horovod.spark em vez de HorovodRunner.
• Se o senhor encontrar erros como WARNING: Open MPI accepted a TCP connection from what appears to be a another Open MPI process but cannot find a corresponding process entry for that peer, isso indica um problema com a comunicação de rede entre os nós do clustering. Para solucionar esse erro, adicione o seguinte trecho ao seu código de treinamento para usar a interface de rede primária.

Python

import os
os.environ["OMPI_MCA_btl_tcp_if_include"]="eth0"
os.environ["NCCL_SOCKET_IFNAME"]="eth0"