Aumente a velocidade do checkpoint e reduza os custos com a Nebula

Artigo
09/01/2024

Saiba como aumentar a velocidade do ponto de verificação e reduzir o custo do ponto de verificação para grandes modelos de treinamento do Azure Machine Learning usando o Nebula.

Descrição geral

Nebula é uma ferramenta de ponto de verificação rápida, simples, sem disco e com reconhecimento de modelo no Azure Container for PyTorch (ACPT). A Nebula oferece uma solução de checkpoint simples e de alta velocidade para trabalhos de treinamento de modelos distribuídos em grande escala usando o PyTorch. Ao utilizar as mais recentes tecnologias de computação distribuída, a Nebula pode reduzir os tempos de checkpoint de horas para segundos - potencialmente economizando de 95% a 99,9% do tempo. Trabalhos de treinamento em grande escala podem se beneficiar muito do desempenho da Nebula.

Para disponibilizar o Nebula para seus trabalhos de treinamento, importe o nebulaml pacote python em seu script. Nebula tem total compatibilidade com diferentes estratégias de treinamento distribuídas PyTorch, incluindo PyTorch Lightning, DeepSpeed e muito mais. A API Nebula oferece uma maneira simples de monitorar e visualizar os ciclos de vida dos pontos de verificação. As APIs suportam vários tipos de modelo e garantem a consistência e a confiabilidade do ponto de verificação.

Importante

O nebulaml pacote não está disponível no índice de pacote python PyPI público. Ele só está disponível no ambiente com curadoria do Azure Container for PyTorch (ACPT) no Azure Machine Learning. Para evitar problemas, não tente instalar nebulaml a partir do PyPI ou usando o pip comando.

Neste documento, você aprenderá a usar o Nebula com ACPT no Aprendizado de Máquina do Azure para verificar rapidamente seus trabalhos de treinamento de modelo. Além disso, você aprenderá a visualizar e gerenciar dados de pontos de verificação da Nebula. Você também aprenderá como retomar os trabalhos de treinamento de modelo a partir do último ponto de verificação disponível se houver interrupção, falha ou término do Aprendizado de Máquina do Azure.

Por que a otimização de pontos de verificação para treinamento de modelos grandes é importante

À medida que os volumes de dados crescem e os formatos de dados se tornam mais complexos, os modelos de aprendizado de máquina também se tornaram mais sofisticados. O treinamento desses modelos complexos pode ser um desafio devido aos limites de capacidade de memória da GPU e aos longos tempos de treinamento. Como resultado, o treinamento distribuído é frequentemente usado ao trabalhar com grandes conjuntos de dados e modelos complexos. No entanto, as arquiteturas distribuídas podem experimentar falhas inesperadas e falhas de nós, o que pode se tornar cada vez mais problemático à medida que o número de nós em um modelo de aprendizado de máquina aumenta.

Os pontos de verificação podem ajudar a mitigar esses problemas salvando periodicamente um instantâneo do estado completo do modelo em um determinado momento. No caso de uma falha, esse instantâneo pode ser usado para reconstruir o modelo para seu estado no momento do snapshot para que o treinamento possa ser retomado a partir desse ponto.

Quando grandes operações de treinamento de modelo sofrem falhas ou encerramentos, cientistas de dados e pesquisadores podem restaurar o processo de treinamento a partir de um ponto de verificação salvo anteriormente. No entanto, qualquer progresso feito entre o ponto de verificação e o término é perdido, pois os cálculos devem ser executados novamente para recuperar resultados intermediários não salvos. Intervalos de ponto de verificação mais curtos podem ajudar a reduzir essa perda. O diagrama ilustra o tempo perdido entre o processo de treinamento dos pontos de verificação e o término:

No entanto, o próprio processo de salvar pontos de verificação pode gerar uma sobrecarga significativa. Salvar um ponto de verificação do tamanho de TB muitas vezes pode se tornar um gargalo no processo de treinamento, com o processo de ponto de verificação sincronizado bloqueando o treinamento por horas. Em média, as despesas gerais relacionadas com os pontos de controlo podem representar 12% do tempo total de treino e podem chegar aos 43% (Maeng et al., 2021).

Para resumir, o gerenciamento de pontos de verificação de modelos grandes envolve armazenamento pesado e despesas gerais de tempo de recuperação de tarefas. Salvamentos frequentes em pontos de verificação, combinados com retomadas de trabalho de treinamento a partir dos últimos pontos de verificação disponíveis, tornam-se um grande desafio.

Nebulosa para o resgate

Para treinar efetivamente grandes modelos distribuídos, é importante ter uma maneira confiável e eficiente de salvar e retomar o progresso do treinamento que minimize a perda de dados e o desperdício de recursos. O Nebula ajuda a reduzir os tempos de economia de pontos de verificação e as demandas de horas de GPU para trabalhos de treinamento do Azure Machine Learning de modelo grande, fornecendo gerenciamento de ponto de verificação mais rápido e fácil.

Com Nebula você pode:

Aumente as velocidades dos pontos de verificação em até 1000 vezes com uma API simples que funciona de forma assíncrona com o seu processo de treinamento. Nebulosa pode reduzir os tempos de checkpoint de horas para segundos - uma redução potencial de 95% a 99%.

Este exemplo mostra o ponto de verificação e a redução do tempo de treinamento de ponta a ponta para quatro pontos de verificação, salvando os trabalhos de treinamento Hugging Face GPT2, GPT2-Large e GPT-XL. Para os médios saves de checkpoint Hugging Face GPT2-XL (20,6 GB), a Nebula conseguiu uma redução de tempo de 96,9% para um ponto de controlo.

O ganho de velocidade do ponto de verificação ainda pode aumentar com o tamanho do modelo e os números da GPU. Por exemplo, testar uma economia de ponto de verificação de ponto de treinamento de 97 GB em 128 GPUs Nvidia A100 pode diminuir de 20 minutos para 1 segundo.
Reduza o tempo de treinamento completo e os custos de computação para modelos grandes, minimizando a sobrecarga do ponto de verificação e reduzindo o número de horas de GPU desperdiçadas na recuperação de tarefas. Nebula salva pontos de verificação de forma assíncrona e desbloqueia o processo de treinamento, para reduzir o tempo de treinamento de ponta a ponta. Ele também permite salvamentos de pontos de controle mais frequentes. Dessa forma, você pode retomar seu treinamento a partir do ponto de verificação mais recente após qualquer interrupção e economizar tempo e dinheiro desperdiçados em horas de recuperação de trabalho e treinamento de GPU.
Fornece total compatibilidade com o PyTorch. Nebula oferece total compatibilidade com o PyTorch e oferece integração total com estruturas de treinamento distribuídas, incluindo DeepSpeed (>=0.7.3) e PyTorch Lightning (>=1.5.0). Você também pode usá-lo com diferentes destinos de computação do Azure Machine Learning, como o Azure Machine Learning Compute ou AKS.
Gerencie facilmente seus pontos de verificação com um pacote Python que ajuda a listar, obter, salvar e carregar seus pontos de verificação. Para mostrar o ciclo de vida do ponto de verificação, o Nebula também fornece logs abrangentes no estúdio do Azure Machine Learning. Você pode optar por salvar seus pontos de verificação em um local de armazenamento local ou remoto
- Armazenamento de Blobs do Azure
- Azure Data Lake Storage
- NFS
e acessá-los a qualquer momento com algumas linhas de código.

Pré-requisitos

Uma assinatura do Azure e um espaço de trabalho do Azure Machine Learning. Consulte Criar recursos de espaço de trabalho para obter mais informações sobre a criação de recursos de espaço de trabalho
Um destino de computação do Azure Machine Learning. Consulte Gerenciar treinamento e implantar computações para saber mais sobre a criação de destino de computação
Um script de treinamento que usa o PyTorch.
Ambiente com curadoria ACPT (Azure Container for PyTorch). Consulte Ambientes curados para obter a imagem ACPT. Saiba como usar o ambiente com curadoria

Como utilizar Nebulosa

Nebula fornece uma experiência de ponto de verificação rápida e fácil, diretamente em seu script de treinamento existente. Os passos para iniciar rapidamente Nebula incluem:

Usando o ambiente ACPT
Inicializando a nebulosa
Chamando APIs para salvar e carregar pontos de verificação

Usando o ambiente ACPT

O Azure Container for PyTorch (ACPT), um ambiente com curadoria para treinamento de modelo PyTorch, inclui o Nebula como um pacote Python dependente e pré-instalado. Consulte Azure Container for PyTorch (ACPT) para exibir o ambiente selecionado e Habilitando o Deep Learning com o Azure Container for PyTorch no Azure Machine Learning para saber mais sobre a imagem ACPT.

Inicializando a nebulosa

Para habilitar o Nebula com o ambiente ACPT, você só precisa modificar seu script de treinamento para importar o nebulaml pacote e, em seguida, chamar as APIs do Nebula nos locais apropriados. Você pode evitar a modificação do SDK ou da CLI do Azure Machine Learning. Você também pode evitar a modificação de outras etapas para treinar seu modelo grande na Plataforma de Aprendizado de Máquina do Azure.

Nebula precisa de inicialização para ser executado em seu script de treinamento. Na fase de inicialização, especifique as variáveis que determinam o local e a frequência de salvamento do ponto de verificação, conforme mostrado neste trecho de código:

  import nebulaml as nm
  nm.init(persistent_storage_path=<YOUR STORAGE PATH>) # initialize Nebula

Nebula foi integrada no DeepSpeed e PyTorch Lightning. Como resultado, a inicialização torna-se simples e fácil. Estes exemplos mostram como integrar a Nebula em seus scripts de treinamento.

Importante

Salvar pontos de verificação com Nebula requer alguma memória para armazenar pontos de verificação. Certifique-se de que a sua memória é maior do que pelo menos três cópias dos pontos de verificação.

Se a memória não for suficiente para manter pontos de verificação, sugerimos que você configure uma variável NEBULA_MEMORY_BUFFER_SIZE de ambiente no comando para limitar o uso da memória por cada nó ao salvar pontos de verificação. Ao definir essa variável, a Nebula usará essa memória como buffer para salvar pontos de verificação. Se o uso de memória não for limitado, Nebula usará a memória tanto quanto possível para armazenar os pontos de verificação.

Se vários processos estiverem em execução no mesmo nó, a memória máxima para salvar pontos de verificação será metade do limite dividido pelo número de processos. Nebulosa usará a outra metade para coordenação de vários processos. Por exemplo, se quiser limitar o uso de memória por cada nó a 200 MB, você pode definir a variável de ambiente como export NEBULA_MEMORY_BUFFER_SIZE=200000000 (em bytes, cerca de 200 MB) no comando. Neste caso, a Nebula usará apenas 200MB de memória para armazenar os pontos de verificação em cada nó. Se houver 4 processos em execução no mesmo nó, a Nebula usará 25MB de memória por cada processo para armazenar os pontos de verificação.

Chamando APIs para salvar e carregar pontos de verificação

A Nebula fornece APIs para lidar com salvamentos de pontos de verificação. Você pode usar essas APIs em seus scripts de treinamento, semelhante à API do PyTorch torch.save() . Estes exemplos mostram como usar Nebula em seus scripts de treinamento.

Ver os seus históricos de pontos de verificação

Quando o trabalho de treinamento terminar, navegue até o painel Trabalho Name> Outputs + logs . No painel esquerdo, expanda a pasta Nebula e selecione checkpointHistories.csv para ver informações detalhadas sobre o ponto de verificação Nebula salva - duração, taxa de transferência e tamanho do ponto de verificação.

Exemplos

Estes exemplos mostram como usar Nebula com diferentes tipos de estrutura. Você pode escolher o exemplo que melhor se adapta ao seu script de treinamento.

Para habilitar a compatibilidade total do Nebula com scripts de treinamento baseados no PyTorch, modifique seu script de treinamento conforme necessário.

Primeiro, importe o pacote necessário nebulaml :

  # Import the Nebula package for fast-checkpointing 
  import nebulaml as nm

Para inicializar a Nebulosa, chame a nm.init() função no main(), conforme mostrado aqui:

  # Initialize Nebula with variables that helps Nebula to know where and how often to save your checkpoints
  persistent_storage_path="/tmp/test",
  nm.init(persistent_storage_path, persistent_time_interval=2)

Para salvar pontos de verificação, substitua a instrução original torch.save() para salvar seu ponto de verificação com Nebula. Certifique-se de que sua instância de ponto de verificação comece com "global_step", como "global_step500" ou "global_step1000":
```
checkpoint = nm.Checkpoint('global_step500')  
checkpoint.save('<CKPT_NAME>', model)  
```
Nota

<'CKPT_TAG_NAME'> é o ID exclusivo do ponto de verificação. Uma tag geralmente é o número de etapas, o número de época ou qualquer nome definido pelo usuário. O parâmetro opcional <'NUM_OF_FILES'> especifica o número do estado que você salvaria para essa tag.
Carregue o ponto de verificação válido mais recente, conforme mostrado aqui:
```
latest_ckpt = nm.get_latest_checkpoint()
p0 = latest_ckpt.load(<'CKPT_NAME'>)
```
Como um ponto de verificação ou instantâneo pode conter muitos arquivos, você pode carregar um ou mais deles pelo nome. Com o ponto de verificação mais recente, o estado de treinamento pode ser restaurado para o estado salvo pelo último ponto de verificação.

Outras APIs podem lidar com o gerenciamento de pontos de verificação
- Listar todos os pontos de verificação
- Obtenha os pontos de verificação mais recentes
```
# Managing checkpoints
## List all checkpoints
ckpts = nm.list_checkpoints()
## Get Latest checkpoint path
latest_ckpt_path = nm.get_latest_checkpoint_path("checkpoint", persisted_storage_path)
```

Um script de treinamento baseado em DeepSpeed (>=0.7.3) pode usar Nebula, se você habilitar Nebula em seu ds_config.json arquivo de configuração, como mostrado:

"nebula": {
      "enabled": true,
      "persistent_storage_path": "<YOUR STORAGE PATH>",
      "persistent_time_interval": 100,
      "num_of_version_in_retention": 2,
      "enable_nebula_load": true
  }

Essa função de trechos JSON funciona como a nebulaml.init() função.

A inicialização com ds_config.json configuração de arquivo habilita a Nebula, que permite salvar pontos de verificação por sua vez. O método de salvamento DeepSpeed original, com a API model_engine.save_checkpoint()de ponto de verificação de modelo, usa automaticamente Nebula. Esse método de salvamento evita a necessidade de modificação de código.

Pontos de verificação PyTorch Lightning (Nebula suporta versão >=1.5.0) automaticamente quando o Trainer é usado. Como você costuma salvar pontos de verificação com comportamentos personalizados para controle refinado, o PyTorch Lightning fornece duas maneiras de salvar o ponto de verificação: salvamentos condicionais com ModelCheckpoint(), e salvamentos manuais com trainer.save_checkpoint(). Estas técnicas aplicam-se aos scripts de treino PyTorch (>=0.15.0).

Se você usar ModelCheckpoint para salvar condicionalmente seus pontos de verificação, você pode usar NebulaCallback em vez de ModelCheckpoint para inicialização.

# import Nebula package
import nebulaml as nm

# define NebulaCallback
config_params = dict()
config_params["persistent_storage_path"] = "<YOUR STORAGE PATH>"
config_params["persistent_time_interval"] = 10

nebula_checkpoint_callback = nm.NebulaCallback(
   ****, # Original ModelCheckpoint params
   config_params=config_params, # customize the config of init nebula
)

Em seguida, adicione nm.NebulaCheckpointIO() como um plug-in ao seu Trainer, e modifique os trainer.save_checkpoint() parâmetros de armazenamento conforme mostrado:

trainer = Trainer(plugins=[nm.NebulaCheckpointIO()],   # add NebulaCheckpointIO as a plugin
                  callbacks=[nebula_checkpoint_callback]) # use NebulaCallback as a plugin

Se você usar trainer.save_checkpoint() para salvar manualmente seus pontos de verificação, você pode usar o NebulaCheckpointIO plug-in em seu Trainer, e modificar os parâmetros de armazenamento da trainer.save_checkpoint() seguinte maneira:

# import Nebula package
import nebulaml as nm

# initialize Nebula
nm.init(persistent_storage_path=<YOUR STORAGE PATH>) 

trainer = Trainer(plugins=[nm.NebulaCheckpointIO()])  # add NebulaCheckpointIO as a plugin

# Saving checkpoints
storage_options = {}
storage_options['is_best'] = True
storage_options['persist_path'] = "/tmp/tier3/checkpoint"

trainer.save_checkpoint("example.ckpt",
  storage_options=storage_options, # customize the config of Nebula saving checkpoint
)

Ponto de verificação de carga

Carregamos pontos de verificação consistentes com PyTorch e PyTorch Lightning. A única modificação especifica o caminho de armazenamento.

Para carregar o ponto de verificação mais recente, MyLightningModule.load_from_checkpoint() ainda funciona, como mostrado:

  persistent_path = "/tmp/tier3/checkpoint"
  latest_ckpt_path = nebulaml.get_latest_checkpoint_path("checkpoint", persist_path)
  model = MyLightningModule.load_from_checkpoint(latest_ckpt_path)

Se você usou nebula_checkpoint_callback no , Trainer()seu script original inalterado, conforme mostrado, ainda funciona:

  trainer = Trainer(
      default_root_dir=tmpdir, 
      max_steps=100,
      plugins=[NebulaCheckpointIO()],
      callbacks=[nebula_checkpoint_callback],
  )
  trainer.fit(model, ckpt_path="/path/example.ckpt")

Partilhar via