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.

# FP16 Entrenamiento con paralelismo de modelos
<a name="model-parallel-extended-features-pytorch-fp16"></a>

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\$1creation()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#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 = ...
   ```

1. 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. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API.

   El siguiente código es un ejemplo de cómo empaquetar un objeto `Adadelta` optimizador con una escala de pérdida dinámica 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`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-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.](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils) `FP16_Module`convierte 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
)
```