FP16Entrenamiento con paralelismo de modelos - Amazon SageMaker AI

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.

FP16Entrenamiento con paralelismo de modelos

Para la FP16 formación, aplique las siguientes modificaciones al guion y al estimador de formación.

nota

Esta función está disponible PyTorch en la biblioteca de paralelismo de SageMaker modelos, versión 1.10.0 y versiones posteriores.

PyTorch Adapta tu guion de entrenamiento

  1. Encapsule su modelo con el administrador de contexto smdistributed.modelparallel.torch.model_creation().

    # fp16_training_script.py

import torch
import smdistributed.modelparallel.torch as smp

with smp.model_creation(
    dtype=torch.float16 if args.fp16 else torch.get_default_dtype()
):
    model = ...
    sugerencia

    Si utiliza el paralelismo de tensores, agregue tensor_parallelism=smp.tp_size() > 1 al gestor contextual smp.model_creation. Agregar esta línea también ayuda a detectar automáticamente si el paralelismo de tensores está activado o no.

    with smp.model_creation(
    ... ,
    tensor_parallelism=smp.tp_size() > 1
):
    model = ...

  2. Al encapsular el optimizador con smdistributed.modelparallel.torch.DistributedOptimizer, establezca el argumento static_loss_scaling o dynamic_loss_scaling. De forma predeterminada, static_loss_scaling se establece en 1.0 y dynamic_loss_scaling se establece en False. Si establece dynamic_loss_scale=True, puede introducir las opciones de escalado dinámico de pérdidas como un diccionario a través del argumento dynamic_loss_args. En la mayoría de los casos, le recomendamos utilizar el escalado de pérdidas dinámico con las opciones predeterminadas. Para obtener más información, opciones y ejemplos de la función encapsuladora del optimizador, consulte smdistributed.modelparallel.torch. DistributedOptimizerAPI.

    El siguiente código es un ejemplo de cómo empaquetar un objeto Adadelta optimizador con una escala dinámica de pérdidas para el FP16 entrenamiento.

    optimizer = torch.optim.Adadelta(...)
optimizer = smp.DistributedOptimizer(
    optimizer,
    static_loss_scale=None,
    dynamic_loss_scale=True,
    dynamic_loss_args={
        "scale_window": 1000,
        "min_scale": 1,
        "delayed_shift": 2
    }
)

Configure un estimador SageMaker PyTorch

Agregue el FP16 parámetro ("fp16") a la configuración de distribución para el paralelismo del modelo al crear un objeto estimador. SageMaker PyTorch Para obtener una lista completa de los parámetros de configuración del paralelismo de modelos, consulte Parámetros de smdistributed.

from sagemaker.pytorch import PyTorch

smp_options = {
    "enabled": True,
    "parameters":  {
        "microbatches":  4,
        "pipeline_parallel_degree":  2,
        "tensor_parallel_degree":  2,
        ...,

        "fp16": True
    }
}

fp16_estimator = PyTorch(
    entry_point="fp16_training_script.py", # Specify your train script
    ...,

    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": {...}
    }
)

fp16_estimator.fit(...)

Cuando se inicia el FP16 entrenamiento, el modelo y el optimizador vienen acompañados de versiones modificadas smdistributed de las FP16_Module utilidades de Apex, FP16_Optimizer respectivamente. FP16_Moduleconvierte el modelo en FP16 dtype y se ocupa de la transferencia hacia adelante. FP16

sugerencia

Puede aplicar recorte de gradiente llamando clip_master_grads antes de optimizer.step.

optimizer.clip_master_grads(max_norm)     # max_norm(float or int): max norm of the gradients
sugerencia

Al usar torch.optim.lr_scheduler y FP16 entrenar, debes pasar optimizer.optimizer al programador LR en lugar del optimizador. Vea el siguiente código de ejemplo:

from torch.optim.lr_scheduler import StepLR

scheduler = StepLR(
    optimizer.optimizer if smp.state.cfg.fp16 else optimizer,
    step_size=1,
    gamma=args.gamma
)