Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# FP16 Formazione con Model Parallelism
<a name="model-parallel-extended-features-pytorch-fp16"></a>

Per la FP16 formazione, applica le seguenti modifiche allo script di addestramento e allo stimatore.

**Nota**  
Questa funzionalità è disponibile PyTorch nella libreria di parallelismo dei SageMaker modelli v1.10.0 e versioni successive.

** PyTorch Adatta il tuo script di allenamento**

1. Effettua il wrapping del modello usando il gestore di contesto [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 = ...
   ```
**Suggerimento**  
Se stai usando il parallelismo tensoriale, aggiungi `tensor_parallelism=smp.tp_size() > 1` al gestore di contesto `smp.model_creation`. L'aggiunta di questa linea aiuta anche a rilevare automaticamente se il parallelismo tensoriale è attivato o meno.  

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

1. Quando racchiudi l'ottimizzatore con `smdistributed.modelparallel.torch.DistributedOptimizer`, imposta l'argomento `static_loss_scaling` o `dynamic_loss_scaling`. Per impostazione predefinita, `static_loss_scaling` è impostato su `1.0` e `dynamic_loss_scaling` è impostato su `False`. Se imposti `dynamic_loss_scale=True`, puoi inserire le opzioni di dimensionamento dinamico delle perdite come dizionario tramite l'argomento `dynamic_loss_args`. Nella maggior parte dei casi, si consiglia di utilizzare la scala dinamica delle perdite con le opzioni predefinite. [Per ulteriori informazioni, opzioni ed esempi della funzione wrapper dell'ottimizzatore, consultate 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.

   Il codice seguente è un esempio di avvolgimento di un oggetto `Adadelta` ottimizzatore con una scalatura dinamica delle perdite per l'addestramento. FP16 

   ```
   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
       }
   )
   ```

**Configura uno stimatore SageMaker PyTorch **

Aggiungi il FP16 parametro (`"fp16"`) alla configurazione di distribuzione per il parallelismo del modello durante la creazione di un SageMaker PyTorch oggetto estimatore. Per un elenco completo dei parametri di configurazione per il parallelismo dei modelli, vedere [Parametri per `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(...)
```

[All'inizio dell' FP16 addestramento, il modello e l'ottimizzatore vengono integrati rispettivamente da `FP16_Module` e, `FP16_Optimizer` rispettivamente, `smdistributed` versioni modificate delle utilità Apex.](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils) `FP16_Module`converte il modello in FP16 dtype e si occupa del forward pass in. FP16

**Suggerimento**  
È possibile applicare il ritaglio del gradiente chiamando `clip_master_grads` prima di `optimizer.step`.  

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

**Suggerimento**  
Durante l'utilizzo `torch.optim.lr_scheduler` e l' FP16 addestramento, è necessario passare `optimizer.optimizer` allo scheduler LR anziché all'ottimizzatore. Guarda il codice di esempio seguente.  

```
from torch.optim.lr_scheduler import StepLR

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