#
Entrenamiento distribuido con 🤗 Accelerate

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

##
Configuración

Empecemos por instalar 🤗 Accelerate:

    pip install accelerate

Luego, importamos y creamos un objeto `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.

    >>> from accelerate import Accelerator

    >>> accelerator = Accelerator()

##
Prepárate para acelerar

Pasa todos los objetos relevantes para el entrenamiento al método `prepare`. Esto incluye los DataLoaders de entrenamiento y evaluación, un modelo y un optimizador:

    >>> train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
    ...     train_dataloader, eval_dataloader, model, optimizer
    ... )

##
Backward

Por último, reemplaza el típico `loss.backward()` en tu bucle de entrenamiento con el método `backward` de 🤗 Accelerate:

    >>> for epoch in range(num_epochs):
    ...     for batch in train_dataloader:
    ...         outputs = model(**batch)
    ...         loss = outputs.loss
    ...         accelerator.backward(loss)

    ...         optimizer.step()
    ...         lr_scheduler.step()
    ...         optimizer.zero_grad()
    ...         progress_bar.update(1)

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!

    + from accelerate import Accelerator
      from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler

    + accelerator = Accelerator()

      model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
      optimizer = AdamW(model.parameters(), lr=3e-5)

    - device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    - model.to(device)

    + train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
    +     train_dataloader, eval_dataloader, model, optimizer
    + )

      num_epochs = 3
      num_training_steps = num_epochs * len(train_dataloader)
      lr_scheduler = get_scheduler(
          "linear",
          optimizer=optimizer,
          num_warmup_steps=0,
          num_training_steps=num_training_steps
      )

      progress_bar = tqdm(range(num_training_steps))

      model.train()
      for epoch in range(num_epochs):
          for batch in train_dataloader:
    -         batch = {k: v.to(device) for k, v in batch.items()}
              outputs = model(**batch)
              loss = outputs.loss
    -         loss.backward()
    +         accelerator.backward(loss)

              optimizer.step()
              lr_scheduler.step()
              optimizer.zero_grad()
              progress_bar.update(1)

##
Entrenamiento

Una vez que hayas añadido las líneas de código relevantes, inicia el entrenamiento desde un script o notebook como Colaboratory.

###
Entrenar con un script

Si estás corriendo tu entrenamiento desde un script ejecuta el siguiente comando para crear y guardar un archivo de configuración:

    accelerate config

Comienza el entrenamiento con:

    accelerate launch train.py

###
Entrenar con un notebook

🤗 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`:

    >>> from accelerate import notebook_launcher

    >>> notebook_launcher(training_function)

Para obtener más información sobre 🤗 Accelerate y sus numerosas funciones, consulta la documentación.