"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:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    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).