"Fossies" - the Fresh Open Source Software Archive

Member "transformers-4.21.1/docs/source/es/accelerate.mdx" (4 Aug 2022, 5148 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. See also the last Fossies "Diffs" side-by-side code changes report for "accelerate.mdx": 4.19.4_vs_4.20.0.

A hint: This file contains one or more very long lines, so maybe it is better readable using the pure text view mode that shows the contents as wrapped lines within the browser window.


    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 # Entrenamiento distribuido con 馃 Accelerate
   14 
   15 El paralelismo ha emergido como una estrategia para entrenar modelos grandes en hardware limitado e incrementar la velocidad de entrenamiento en varios 贸rdenes de magnitud. En Hugging Face creamos la biblioteca [馃 Accelerate](https://huggingface.co/docs/accelerate/index.html) para ayudar a los usuarios a entrenar modelos 馃 Transformers en cualquier tipo de configuraci贸n distribuida, ya sea en una m谩quina con m煤ltiples GPUs o en m煤ltiples GPUs distribuidas entre muchas m谩quinas. En este tutorial aprender谩s c贸mo personalizar tu bucle de entrenamiento de PyTorch nativo para poder entrenar en entornos distribuidos.
   16 
   17 ## Configuraci贸n
   18 
   19 Empecemos por instalar 馃 Accelerate:
   20 
   21 ```bash
   22 pip install accelerate
   23 ```
   24 
   25 Luego, importamos y creamos un objeto [`Accelerator`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator). `Accelerator` detectar谩 autom谩ticamente el tipo de configuraci贸n distribuida que tengas disponible e inicializar谩 todos los componentes necesarios para el entrenamiento. No necesitas especificar el dispositivo en donde se debe colocar tu modelo.
   26 
   27 ```py
   28 >>> from accelerate import Accelerator
   29 
   30 >>> accelerator = Accelerator()
   31 ```
   32 
   33 ## Prep谩rate para acelerar
   34 
   35 Pasa todos los objetos relevantes para el entrenamiento al m茅todo [`prepare`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator.prepare). Esto incluye los DataLoaders de entrenamiento y evaluaci贸n, un modelo y un optimizador:
   36 
   37 ```py
   38 >>> train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
   39 ...     train_dataloader, eval_dataloader, model, optimizer
   40 ... )
   41 ```
   42 
   43 ## Backward
   44 
   45 Por 煤ltimo, reemplaza el t铆pico `loss.backward()` en tu bucle de entrenamiento con el m茅todo [`backward`](https://huggingface.co/docs/accelerate/accelerator.html#accelerate.Accelerator.backward) de 馃 Accelerate:
   46 
   47 ```py
   48 >>> for epoch in range(num_epochs):
   49 ...     for batch in train_dataloader:
   50 ...         outputs = model(**batch)
   51 ...         loss = outputs.loss
   52 ...         accelerator.backward(loss)
   53 
   54 ...         optimizer.step()
   55 ...         lr_scheduler.step()
   56 ...         optimizer.zero_grad()
   57 ...         progress_bar.update(1)
   58 ```
   59 
   60 Como se puede ver en el siguiente c贸digo, 隆solo necesitas adicionar cuatro l铆neas de c贸digo a tu bucle de entrenamiento para habilitar el entrenamiento distribuido!
   61 
   62 ```diff
   63 + from accelerate import Accelerator
   64   from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
   65 
   66 + accelerator = Accelerator()
   67 
   68   model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
   69   optimizer = AdamW(model.parameters(), lr=3e-5)
   70 
   71 - device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
   72 - model.to(device)
   73 
   74 + train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
   75 +     train_dataloader, eval_dataloader, model, optimizer
   76 + )
   77 
   78   num_epochs = 3
   79   num_training_steps = num_epochs * len(train_dataloader)
   80   lr_scheduler = get_scheduler(
   81       "linear",
   82       optimizer=optimizer,
   83       num_warmup_steps=0,
   84       num_training_steps=num_training_steps
   85   )
   86 
   87   progress_bar = tqdm(range(num_training_steps))
   88 
   89   model.train()
   90   for epoch in range(num_epochs):
   91       for batch in train_dataloader:
   92 -         batch = {k: v.to(device) for k, v in batch.items()}
   93           outputs = model(**batch)
   94           loss = outputs.loss
   95 -         loss.backward()
   96 +         accelerator.backward(loss)
   97 
   98           optimizer.step()
   99           lr_scheduler.step()
  100           optimizer.zero_grad()
  101           progress_bar.update(1)
  102 ```
  103 
  104 ## Entrenamiento
  105 
  106 Una vez que hayas a帽adido las l铆neas de c贸digo relevantes, inicia el entrenamiento desde un script o notebook como Colaboratory.
  107 
  108 ### Entrenar con un script
  109 
  110 Si est谩s corriendo tu entrenamiento desde un script ejecuta el siguiente comando para crear y guardar un archivo de configuraci贸n:
  111 
  112 ```bash
  113 accelerate config
  114 ```
  115 
  116 Comienza el entrenamiento con:
  117 
  118 ```bash
  119 accelerate launch train.py
  120 ```
  121 
  122 ### Entrenar con un notebook
  123 
  124 馃 Accelerate puede correr en un notebook si, por ejemplo, est谩s planeando utilizar las TPUs de Colaboratory. Encierra el c贸digo responsable del entrenamiento en una funci贸n y p谩salo a `notebook_launcher`:
  125 
  126 ```py
  127 >>> from accelerate import notebook_launcher
  128 
  129 >>> notebook_launcher(training_function)
  130 ```
  131 
  132 Para obtener m谩s informaci贸n sobre 馃 Accelerate y sus numerosas funciones, consulta la [documentaci贸n](https://huggingface.co/docs/accelerate/index.html).