Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# FP16 Pelatihan dengan Model Paralelisme
<a name="model-parallel-extended-features-pytorch-fp16"></a>

Untuk FP16 pelatihan, terapkan modifikasi berikut pada skrip pelatihan dan estimator Anda.

**catatan**  
Fitur ini tersedia untuk PyTorch di pustaka paralelisme SageMaker model v1.10.0 dan yang lebih baru.

**Sesuaikan skrip PyTorch pelatihan Anda**

1. Bungkus model Anda menggunakan pengelola konteks [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 = ...
   ```
**Tip**  
Jika Anda menggunakan paralelisme tensor, tambahkan `tensor_parallelism=smp.tp_size() > 1` ke manajer konteks. `smp.model_creation` Menambahkan baris ini juga membantu mendeteksi secara otomatis apakah paralelisme tensor diaktifkan atau tidak.  

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

1. Saat Anda membungkus pengoptimal dengan`smdistributed.modelparallel.torch.DistributedOptimizer`, atur `dynamic_loss_scaling` argumen `static_loss_scaling` atau. Secara default, `static_loss_scaling` diatur ke `1.0`, dan `dynamic_loss_scaling` diatur ke `False`. Jika Anda mengatur`dynamic_loss_scale=True`, Anda dapat memasukkan opsi penskalaan kerugian dinamis sebagai kamus melalui `dynamic_loss_args` argumen. Dalam kebanyakan kasus, kami sarankan Anda menggunakan penskalaan kerugian dinamis dengan opsi default. [Untuk informasi selengkapnya, opsi, dan contoh fungsi pembungkus pengoptimal, lihat 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.

   Kode berikut adalah contoh membungkus objek `Adadelta` pengoptimal dengan penskalaan kerugian dinamis untuk pelatihan. 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
       }
   )
   ```

**Konfigurasikan SageMaker PyTorch estimator**

Tambahkan FP16 parameter (`"fp16"`) ke konfigurasi distribusi untuk paralelisme model saat membuat objek SageMaker PyTorch estimator. Untuk daftar lengkap parameter konfigurasi paralelisme model, lihat [Parameter](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) untuk. `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(...)
```

Saat FP16 pelatihan dimulai, model dan pengoptimal dibungkus oleh `FP16_Module` dan `FP16_Optimizer` masing-masing, yang merupakan `smdistributed` versi modifikasi dari utilitas [Apex](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils). `FP16_Module`mengubah model menjadi FP16 dtype dan berurusan dengan forward pass in. FP16

**Tip**  
Anda dapat menerapkan kliping gradien dengan menelepon `clip_master_grads` sebelumnya. `optimizer.step`  

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

**Tip**  
Saat menggunakan `torch.optim.lr_scheduler` dan FP16 melatih, Anda harus meneruskan `optimizer.optimizer` ke penjadwal LR daripada pengoptimal. Lihat contoh kode berikut.  

```
from torch.optim.lr_scheduler import StepLR

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