View a markdown version of this page

PyTorch - Amazon SageMaker AI
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

Incorpore su propio PyTorch modelo a la SageMaker IA y ejecute el trabajo de formación con SageMaker Training Compiler.

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, podrá iniciar un trabajo de formación con la SageMaker IA PyTorch o con un HuggingFace estimador con la configuración del compilador de SageMaker formación. Después, pasará al siguiente tema en. Habilita el compilador SageMaker de entrenamiento

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.

Modelos lingüísticos de gran tamaño que utilizan la clase de entrenador 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 distribuido por la SageMaker IA para PyTorch (pytorchxla) a la main() función de tu guion 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 un lanzador de entrenamiento distribuido por SageMaker IA al entry_point argumento y que pases tu guion de entrenamiento al hyperparameters argumento del estimador Hugging Face de SageMaker IA.

Mejores prácticas para utilizar Training Compiler con Trainer SageMaker

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 guion de formación que se utiliza PyTorch directamente, tendrá que realizar cambios adicionales en el guion de PyTorch formación para poder implementarlo. PyTorch/XLA Siga las instrucciones para modificar el script y configurar correctamente las PyTorch/XLA primitivas.

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 utilizas PyTorch la precisión mixta automática (AMP), haz 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's: PyTorch/XLA 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, usa el método de puntos de control del PyTorch/XLA modelo:

    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 PyTorch cargador normal 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 distribuido por la SageMaker IA para PyTorch (pytorchxla) a la main() función de tu guion 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 un lanzador de entrenamiento distribuido de SageMaker IA al entry_point argumento y que pases tu guion de entrenamiento al hyperparameters argumento del estimador Hugging Face de SageMaker IA.

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 utilizar Training Compiler con SageMaker PyTorch/XLA

Si desea utilizar el compilador de SageMaker formación en su script de PyTorch formación nativo, puede que le interese familiarizarse primero con los dispositivos PyTorch 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 PyTorch/XLA módulos:

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

Una diferencia significativa entre el sistema nativo PyTorch/XLA y el nativo PyTorch es que el PyTorch/XLA sistema se ejecuta en modo lento, mientras que el sistema nativo PyTorch se ejecuta en modo ansioso. 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 PyTorch/XLA sistema 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 compilación y ejecuciones usando pl. MpDeviceLoader/pl.ParallelLoadery xm.step_closure

Para obtener el mejor rendimiento, debe tener en cuenta las posibles formas de iniciar compilación y ejecuciones como se describe en Comprenda el modo perezoso en PyTorch/XLA e intentar minimizar el número de compilación y ejecuciones. Idealmente, solo es necesaria una compilación y ejecución por iteración de entrenamiento y se inicia automáticamente mediante pl.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 Lazy debe encapsularse utilizando xm.add_step_closure() para evitar compilación y ejecuciones innecesarias.

Usa optimizadores AMP y syncfree

Entrenar en el modo Automatic Mixed Precision (AMP) acelera considerablemente tu 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 syncfree optimizadores deben combinarse con el gradiente. torch_xla.amp.GradScaler scaling/unscaling

sugerencia

A partir de la versión PyTorch 1.13.1, SageMaker Training Compiler mejora el rendimiento PyTorch/XLA al permitir anular automáticamente los optimizadores (como SGD, Adam, AdamW) en torch.optim o transformers.optimization con sus versiones sin sincronización (como,,). 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.