PyTorch - Amazon SageMaker
PyTorch Modelos con Hugging Face Transformers

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

PyTorch

Utilice su propio PyTorch modelo y ejecute el trabajo de formación con SageMaker Training Compiler. SageMaker

PyTorch Modelos con Hugging Face Transformers

PyTorch los modelos con Hugging Face Transformers se PyTorch basan en la API torch.NN.Module. Hugging Face Transformers también ofrece clases de modelos para instructores y previamente entrenados PyTorch para ayudar a reducir el esfuerzo de configuración de los modelos de procesamiento del lenguaje natural (NLP). Tras preparar el guion de formación, puede iniciar un trabajo de formación utilizando el estimador SageMaker PyTorch o el HuggingFace estimador configurado con el compilador de SageMaker formación. Después, pasará al siguiente tema en. Habilite el compilador SageMaker de formación

sugerencia

Cuando cree un tokenizador para un modelo de PNL con Transformers en su script de entrenamiento, asegúrese de utilizar una forma de tensor de entrada estática especificando padding='max_length'. No utilice padding='longest' porque rellenar la secuencia más larga del lote puede cambiar la forma del tensor de cada lote de entrenamiento. La forma de entrada dinámica puede desencadenar la recompilación del modelo y aumentar el tiempo total de entrenamiento. Para obtener más información sobre las opciones de relleno de los tokenizadores de Transformers, consulte Padding and truncation en la documentación de Hugging Face Transformers.

Grandes modelos lingüísticos mediante la clase Trainer de Hugging Face Transformers

Si utilizas la clase de entrenador de la biblioteca de transformers, no necesitas realizar ningún cambio adicional en tu guion de formación. SageMaker Training Compiler compila automáticamente tu modelo Trainer si lo habilitas en la clase Estimador. El siguiente código muestra la forma básica de un guion de PyTorch entrenamiento con la API Hugging Face Trainer.

from transformers import Trainer, TrainingArguments

training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)

Para el entrenamiento con una sola GPU

No necesita cambiar su código cuando utilice la clase transformers.Trainer.

Para entrenamiento distribuido

PyTorch v1.11.0 y versiones posteriores

Para ejecutar un entrenamiento distribuido con SageMaker Training Compiler, debe agregar la siguiente _mp_fn() función a su script de entrenamiento y empaquetar la función. main() Redirige las llamadas a _mp_fn(index) funciones del motor de ejecución SageMaker distribuido para PyTorch (pytorchxla) a la main() función de tu script de entrenamiento. 

def _mp_fn(index):
    main()

Esta función acepta el argumento index para indicar el rango de la GPU actual en el clúster para el entrenamiento distribuido. Para encontrar más scripts de ejemplo, consulte los scripts de ejemplo de modelado lingüístico de Hugging Face Transformers.

Para Transformers v4.17 y anteriores con v1.10.2 y anteriores PyTorch

SageMaker Training Compiler utiliza un mecanismo alternativo para lanzar un trabajo de formación distribuido y no es necesario realizar ninguna modificación en el guion de formación. En cambio, SageMaker Training Compiler requiere que pases un guion de inicio de entrenamiento SageMaker distribuido al entry_point argumento y que pases tu guion de entrenamiento al hyperparameters argumento del estimador Hugging SageMaker Face.

Mejores prácticas para utilizar Training Compiler con SageMaker Trainer

Cuando haya terminado de adaptar su script de entrenamiento, continúe con Ejecute trabajos PyTorch de entrenamiento con SageMaker Training Compiler.

Modelos de idiomas de gran tamaño que se utilizan PyTorch directamente (sin la API Hugging Face Transformers Trainer)

Si tiene un script de entrenamiento que se usa PyTorch directamente, debe realizar cambios adicionales en el script de PyTorch entrenamiento para implementar /XLA. PyTorch Siga las instrucciones para modificar el script y configurar correctamente las primitivas de /XLA. PyTorch

Para el entrenamiento con una sola GPU

  1. Importe las bibliotecas de optimización.

    import torch_xla
import torch_xla.core.xla_model as xm

  2. Cambiar el dispositivo de destino para que sea XLA en lugar de torch.device("cuda") 

    device=xm.xla_device()

  3. Si utiliza PyTorch la precisión mixta automática (AMP), haga lo siguiente:

    1. Reemplace torch.cuda.amp por lo siguiente:

      import torch_xla.amp

    2. Reemplace torch.optim.SGD y torch.optim.Adam por lo siguiente:

      import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD

    3. Reemplace torch.cuda.amp.GradScaler por lo siguiente:

      import torch_xla.amp.GradScaler as grad_scaler

  4. Si no utiliza AMP, reemplace optimizer.step() por lo siguiente:

    xm.optimizer_step(optimizer)

  5. Si utilizas un cargador de datos distribuido, incluye tu cargador de datos en la clase /XLA PyTorch: ParallelLoader

    import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)

  6. Añada mark_step al final del bucle de entrenamiento cuando no estés utilizando parallel_loader:

    xm.mark_step()

  7. Para comprobar tu entrenamiento, utiliza el método de puntos de control del modelo /XLA: PyTorch

    xm.save(model.state_dict(), path_to_save)

Cuando haya terminado de adaptar su script de entrenamiento, continúe con Ejecute trabajos PyTorch de entrenamiento con SageMaker Training Compiler.

Para entrenamiento distribuido

Además de los cambios enumerados en la sección Para el entrenamiento con una sola GPU anterior, añada los siguientes cambios para distribuir correctamente la carga de trabajo entre las GPU.

  1. Si esta utilizando AMP, añada all_reduce después de scaler.scale(loss).backward():

    gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())

  2. Si necesita establecer variables para local_ranks y world_size, utilice un código similar al siguiente:

    local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()

  3. Para cualquier world_size (num_gpus_per_node*num_nodes) mayor que 1, debe definir un muestreador de entrenamiento que debe tener un aspecto similar al siguiente:

    import torch_xla.core.xla_model as xm

if xm.xrt_world_size() > 1:
    train_sampler=torch.utils.data.distributed.DistributedSampler(
        train_dataset,
        num_replicas=xm.xrt_world_size(),
        rank=xm.get_ordinal(),
        shuffle=True
    )

train_loader=torch.utils.data.DataLoader(
    train_dataset, 
    batch_size=args.batch_size,
    sampler=train_sampler,
    drop_last=args.drop_last,
    shuffle=False if train_sampler else True,
    num_workers=args.num_workers
)

  4. Realice los siguientes cambios para asegurarse de que utiliza el parallel_loader proporcionado por el módulo torch_xla distributed. 

    import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)

    train_device_loaderFunciona como un cargador normal PyTorch de la siguiente manera: 

    for step, (data, target) in enumerate(train_device_loader):
    optimizer.zero_grad()
    output=model(data)
    loss=torch.nn.NLLLoss(output, target)
    loss.backward()

    Con todos estos cambios, deberías poder lanzar un entrenamiento distribuido con cualquier PyTorch modelo sin la API de Transformer Trainer. Tenga en cuenta que estas instrucciones se pueden utilizar tanto para varias GPU de un solo nodo como para varias GPU de varios nodos.

  5. Para la PyTorch versión 1.11.0 y versiones posteriores

    Para ejecutar un entrenamiento distribuido con SageMaker Training Compiler, debe agregar la siguiente _mp_fn() función a su script de entrenamiento y empaquetar la función. main() Redirige las llamadas a _mp_fn(index) funciones del motor de ejecución SageMaker distribuido para PyTorch (pytorchxla) a la main() función de tu script de entrenamiento. 

    def _mp_fn(index):
    main()

    Esta función acepta el argumento index para indicar el rango de la GPU actual en el clúster para el entrenamiento distribuido. Para encontrar más scripts de ejemplo, consulte los scripts de ejemplo de modelado lingüístico de Hugging Face Transformers.

    Para Transformers v4.17 y anteriores con v1.10.2 y anteriores PyTorch

    SageMaker Training Compiler utiliza un mecanismo alternativo para lanzar un trabajo de formación distribuido y requiere que pases un guion de inicio de formación SageMaker distribuido al entry_point argumento y que pases tu guion de formación al hyperparameters argumento del estimador Hugging SageMaker Face.

Cuando haya terminado de adaptar su script de entrenamiento, continúe con Ejecute trabajos PyTorch de entrenamiento con SageMaker Training Compiler.

Mejores prácticas para usar Training Compiler con /XLA SageMaker PyTorch

Si desea utilizar el compilador de SageMaker formación en su script de PyTorch formación nativo, puede que primero desee familiarizarse con PyTorch el uso de dispositivos XLA. En las siguientes secciones se enumeran algunas de las mejores prácticas para habilitar XLA. PyTorch

nota

En esta sección de prácticas recomendadas se parte del supuesto de que se utilizan los siguientes módulos PyTorch /XLA:

import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
Comprenda el modo perezoso en /XLA PyTorch

Una diferencia significativa entre PyTorch /XLA y el sistema nativo PyTorch es que el sistema PyTorch /XLA se ejecuta en modo lento, mientras que el sistema nativo se ejecuta en modo ansioso. PyTorch Los tensores en modo Lazy son marcadores de posición para construir el gráfico computacional hasta que se materializan después de que la compilación y la evaluación se hayan completado. El sistema PyTorch /XLA crea el gráfico computacional sobre la marcha cuando se utilizan las PyTorch API para crear el cálculo mediante tensores y operadores. El gráfico computacional se compila y ejecuta cuando xm.mark_step() es llamado explícita o implícitamente por pl.MpDeviceLoader/pl.ParallelLoader, o cuando se solicita explícitamente el valor de un tensor como por ejemplo llamando a loss.item() o print(loss).

Minimice la cantidad de usos y compilation-and-executionspl.MpDeviceLoader/pl.ParallelLoaderxm.step_closure

Para obtener el mejor rendimiento, debe tener en cuenta las posibles formas de iniciar, tal compilation-and-executionscomo se describe en, Comprenda el modo perezoso en /XLA PyTorch y debe intentar minimizar la cantidad de compilation-and-executions. Lo ideal es que solo compilation-and-execution sea necesaria una por iteración de entrenamiento y que se inicie automáticamente porpl.MpDeviceLoader/pl.ParallelLoader. El MpDeviceLoader está optimizado para XLA y debe utilizarse siempre que sea posible para obtener el mejor rendimiento. Durante el entrenamiento, es posible que desee examinar algunos resultados intermedios, como los valores de pérdida. En tal caso, la impresión de tensores perezosos debe envolverse con tensores perezosos xm.add_step_closure() para evitar que sea innecesaria. compilation-and-executions

Utilizar AMP y optimizadores syncfree

Entrenar en el modo Automatic Mixed Precision (AMP) acelera considerablemente la velocidad de entrenamiento al aprovechar los núcleos tensores de las GPU NVIDIA. SageMaker Training Compiler proporciona syncfree optimizadores optimizados para XLA a fin de mejorar el rendimiento de AMP. Actualmente, están disponibles los tres optimizadores syncfree siguientes, que deben utilizarse si es posible para obtener el mejor rendimiento.

torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW

Estos optimizadores syncfree deben emparejarse con torch_xla.amp.GradScaler para el escalado/desescalado de gradientes.

sugerencia

A partir de la versión PyTorch 1.13.1, SageMaker Training Compiler mejora el rendimiento al permitir que PyTorch /XLA anule automáticamente los optimizadores (como SGD, Adam, AdamW) incluidos en torch.optim sus versiones sin sincronización (como,,). transformers.optimization torch_xla.amp.syncfree torch_xla.amp.syncfree.SGD torch_xla.amp.syncfree.Adam torch_xla.amp.syncfree.AdamW No tiene que cambiar las líneas de código en las que define los optimizadores en su script de entrenamiento.