Accelerate documentation

Treinamento em TPUs

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Treinamento em TPUs

O treinamento em TPUs pode ser ligeiramente diferente do treinamento em multi-GPU, mesmo com o Accelerate. Este guia tem como objetivo mostrar onde você deve ter cuidado e por quê, além das melhores práticas em geral.

Treinamento em um Notebook

O principal ponto de atenção ao treinar em TPUs vem do notebook_launcher(). Como mencionado no tutorial de notebook, você precisa reestruturar seu código de treinamento em uma função que possa ser passada para a função notebook_launcher() e ter cuidado para não declarar nenhum tensor na GPU.

Embora em um TPU essa última parte não seja tão importante, uma parte crítica a entender é que, ao executar código a partir de um notebook, você o faz por meio de um processo chamado forking. Ao executar a partir da linha de comando, você realiza spawning, em que um processo Python não está em execução e você spawna um novo processo. Como seu notebook Jupyter já está utilizando um processo Python, você precisa forkar um novo processo a partir dele para executar seu código.

Isso se torna importante no que diz respeito à declaração do seu modelo. Em processos TPU forkados, é recomendado que você instancie seu modelo uma vez e passe isso para sua função de treinamento. Isso é diferente do treinamento em GPUs, onde você cria n modelos que têm seus gradientes sincronizados e retropropagados em certos momentos. Em vez disso, uma instância de modelo é compartilhada entre todos os nós e é passada de um para o outro. Isso é importante, especialmente ao treinar em TPUs de baixo recurso, como os fornecidos em kernels do Kaggle ou no Google Colaboratory.

Abaixo está um exemplo de uma função de treinamento passada para o notebook_launcher() caso o treinamento seja realizado em CPUs ou GPUs:

Este trecho de código é baseado no do notebook simple_nlp_example encontrado aqui, com pequenas modificações para fins de simplicidade

def training_function():
    # Initialize accelerator
    accelerator = Accelerator()
    model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
    train_dataloader, eval_dataloader = create_dataloaders(
        train_batch_size=hyperparameters["train_batch_size"], eval_batch_size=hyperparameters["eval_batch_size"]
    )

    # Instantiate optimizer
    optimizer = AdamW(params=model.parameters(), lr=hyperparameters["learning_rate"])

    # Prepare everything
    # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
    # prepare method.
    model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
        model, optimizer, train_dataloader, eval_dataloader
    )

    num_epochs = hyperparameters["num_epochs"]
    # Now we train the model
    for epoch in range(num_epochs):
        model.train()
        for step, batch in enumerate(train_dataloader):
            outputs = model(**batch)
            loss = outputs.loss
            accelerator.backward(loss)

            optimizer.step()
            optimizer.zero_grad()
from accelerate import notebook_launcher

notebook_launcher(training_function)

O notebook_launcher usará 8 processos por padrão se o Accelerate tiver sido configurado para um TPU

Se você usar este exemplo e declarar o modelo dentro do loop de treinamento, em um sistema com recursos limitados você poderá ver um erro como:

ProcessExitedException: process 0 terminated with signal SIGSEGV

Esse erro é extremamente criptográfico, mas a explicação básica é que a RAM do sistema acabou. Você pode evitar isso completamente reconfigurando a função de treinamento para aceitar um único argumento model e declará-lo em uma célula externa:

# In another Jupyter cell
model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
+ def training_function(model):
      # Initialize accelerator
      accelerator = Accelerator()
-     model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
      train_dataloader, eval_dataloader = create_dataloaders(
          train_batch_size=hyperparameters["train_batch_size"], eval_batch_size=hyperparameters["eval_batch_size"]
      )
  ...

E, por fim, chamando a função de treinamento com:

  from accelerate import notebook_launcher
- notebook_launcher(training_function)
+ notebook_launcher(training_function, (model,))

O workaround acima é necessário apenas ao iniciar uma instância de TPU a partir de um Jupyter Notebook em um servidor com recursos limitados, como o Google Colaboratory ou o Kaggle. Se estiver usando um script ou iniciando em um servidor muito mais robusto, não é necessário declarar o modelo previamente.

Precisão Mista e Variáveis Globais

Conforme mencionado na seção de precisão mista do tutorial de migração, o Accelerate suporta fp16 e bf16, ambos utilizáveis em TPUs. Dito isso, idealmente, bf16 deve ser utilizado, pois é extremamente eficiente.

Existem duas “camadas” ao usar bf16 e Accelerate em TPUs, no nível base e no nível de operação.

No nível básico, isso é habilitado ao passar mixed_precision="bf16" para Accelerator, como em:

accelerator = Accelerator(mixed_precision="bf16")

Por padrão, isso converterá torch.float e torch.double para bfloat16 em TPUs. A configuração específica que está sendo definida é uma variável de ambiente em que XLA_USE_BF16 é definido como 1.

Há uma configuração adicional que você pode realizar, que é definir a variável de ambiente XLA_DOWNCAST_BF16. Se definida como 1, então torch.float é bfloat16 e torch.double é float32.

Isso é realizado no objeto Accelerator ao passar downcast_bf16=True:

accelerator = Accelerator(mixed_precision="bf16", downcast_bf16=True)

Usar downcasting em vez de bf16 em todos os lugares é útil quando você está tentando calcular métricas, registrar valores e mais, onde tensores brutos em bf16 seriam inutilizáveis.

Tempos de Treinamento em TPUs

Ao executar seu script, você pode perceber que o treinamento parece excepcionalmente lento no início. Isso ocorre porque os TPUs primeiro processam alguns lotes de dados para determinar a quantidade de memória a ser alocada antes de, finalmente, utilizar essa alocação de memória configurada de forma extremamente eficiente.

Se você notar que seu código de avaliação para calcular as métricas do seu modelo leva mais tempo devido ao uso de um tamanho de lote maior, recomenda-se manter o tamanho do lote igual ao dos dados de treinamento, caso esteja lento demais. Caso contrário, a memória será realocada para esse novo tamanho de lote após as primeiras iterações.

O fato de a memória ter sido alocada não significa que ela será utilizada ou que o tamanho do lote aumentará ao voltar para o seu carregador de dados de treinamento.

Update on GitHub