"Fossies" - the Fresh Open Source Software Archive

Member "transformers-4.21.1/docs/source/pt/accelerate.mdx" (4 Aug 2022, 5075 Bytes) of package /linux/misc/transformers-4.21.1.tar.gz:

    1 <!--Copyright 2022 The HuggingFace Team. All rights reserved.
    2 
    3 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
    4 the License. You may obtain a copy of the License at
    5 
    6 http://www.apache.org/licenses/LICENSE-2.0
    7 
    8 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
    9 an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
   10 specific language governing permissions and limitations under the License.
   11 -->
   12 
   13 # Treinamento distribuído com o 🤗 Accelerate
   14 
   15 O paralelismo surgiu como uma estratégia para treinar modelos grandes em hardware limitado e aumentar a velocidade
   16 de treinamento em várias órdens de magnitude. Na Hugging Face criamos a biblioteca [🤗 Accelerate](https://huggingface.co/docs/accelerate/index.html)
   17 para ajudar os usuários a treinar modelos 🤗 Transformers com qualquer configuração distribuída, seja em uma máquina
   18 com múltiplos GPUs ou em múltiplos GPUs distribuidos entre muitas máquinas. Neste tutorial, você irá aprender como
   19 personalizar seu laço de treinamento de PyTorch para poder treinar em ambientes distribuídos.
   20 
   21 ## Configuração
   22 
   23 De início, instale o 🤗 Accelerate:
   24 
   25 ```bash
   26 pip install accelerate
   27 ```
   28 
   29 Logo, devemos importar e criar um objeto [`Accelerator`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator).
   30 O `Accelerator` detectará automáticamente a configuração distribuída disponível e inicializará todos os
   31 componentes necessários para o treinamento. Não há necessidade portanto de especificar o dispositivo onde deve colocar seu modelo.
   32 
   33 ```py
   34 >>> from accelerate import Accelerator
   35 
   36 >>> accelerator = Accelerator()
   37 ```
   38 
   39 ## Preparando a aceleração
   40 
   41 Passe todos os objetos relevantes ao treinamento para o método [`prepare`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator.prepare).
   42 Isto inclui os DataLoaders de treino e evaluação, um modelo e um otimizador:
   43 
   44 ```py
   45 >>> train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
   46 ...     train_dataloader, eval_dataloader, model, optimizer
   47 ... )
   48 ```
   49 
   50 ## Backward
   51 
   52 Por último, substitua o `loss.backward()` padrão em seu laço de treinamento com o método [`backward`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator.backward) do 🤗 Accelerate:
   53 
   54 ```py
   55 >>> for epoch in range(num_epochs):
   56 ...     for batch in train_dataloader:
   57 ...         outputs = model(**batch)
   58 ...         loss = outputs.loss
   59 ...         accelerator.backward(loss)
   60 
   61 ...         optimizer.step()
   62 ...         lr_scheduler.step()
   63 ...         optimizer.zero_grad()
   64 ...         progress_bar.update(1)
   65 ```
   66 
   67 Como se poder ver no seguinte código, só precisará adicionar quatro linhas de código ao seu laço de treinamento
   68 para habilitar o treinamento distribuído!
   69 
   70 ```diff
   71 + from accelerate import Accelerator
   72   from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
   73 
   74 + accelerator = Accelerator()
   75 
   76   model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
   77   optimizer = AdamW(model.parameters(), lr=3e-5)
   78 
   79 - device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
   80 - model.to(device)
   81 
   82 + train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
   83 +     train_dataloader, eval_dataloader, model, optimizer
   84 + )
   85 
   86   num_epochs = 3
   87   num_training_steps = num_epochs * len(train_dataloader)
   88   lr_scheduler = get_scheduler(
   89       "linear",
   90       optimizer=optimizer,
   91       num_warmup_steps=0,
   92       num_training_steps=num_training_steps
   93   )
   94 
   95   progress_bar = tqdm(range(num_training_steps))
   96 
   97   model.train()
   98   for epoch in range(num_epochs):
   99       for batch in train_dataloader:
  100 -         batch = {k: v.to(device) for k, v in batch.items()}
  101           outputs = model(**batch)
  102           loss = outputs.loss
  103 -         loss.backward()
  104 +         accelerator.backward(loss)
  105 
  106           optimizer.step()
  107           lr_scheduler.step()
  108           optimizer.zero_grad()
  109           progress_bar.update(1)
  110 ```
  111 
  112 ## Treinamento
  113 
  114 Quando tiver adicionado as linhas de código relevantes, inicie o treinamento por um script ou notebook como o Colab.
  115 
  116 ### Treinamento em um Script
  117 
  118 Se estiver rodando seu treinamento em um Script, execute o seguinte comando para criar e guardar um arquivo de configuração:
  119 
  120 ```bash
  121 accelerate config
  122 ```
  123 
  124 Comece o treinamento com:
  125 
  126 ```bash
  127 accelerate launch train.py
  128 ```
  129 
  130 ### Treinamento em um Notebook
  131 
  132 O 🤗 Accelerate pode rodar em um notebook, por exemplo, se estiver planejando usar as TPUs do Google Colab.
  133 Encapsule o código responsável pelo treinamento de uma função e passe-o ao `notebook_launcher`:
  134 
  135 ```py
  136 >>> from accelerate import notebook_launcher
  137 
  138 >>> notebook_launcher(training_function)
  139 ```
  140 
  141 Para obter mais informações sobre o 🤗 Accelerate e suas numerosas funções, consulte a [documentación](https://huggingface.co/docs/accelerate/index.html).