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

# Pelatihan terdistribusi dengan perpustakaan paralelisme data terdistribusi SageMaker AI
<a name="data-parallel-modify-sdp"></a>

Pustaka paralelisme data terdistribusi SageMaker AI (SMDDP) dirancang untuk kemudahan penggunaan dan untuk memberikan integrasi yang mulus. PyTorch

Saat melatih model pembelajaran mendalam dengan perpustakaan SMDDP tentang SageMaker AI, Anda dapat fokus menulis skrip pelatihan dan pelatihan model Anda. 

Untuk memulai, impor perpustakaan SMDDP untuk menggunakan operasi kolektifnya yang dioptimalkan. AWS Topik berikut memberikan instruksi tentang apa yang harus ditambahkan ke skrip pelatihan Anda tergantung pada operasi kolektif mana yang ingin Anda optimalkan.

**Topics**
+ [Mengadaptasi skrip pelatihan Anda untuk menggunakan operasi kolektif SMDDP](data-parallel-modify-sdp-select-framework.md)
+ [Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md)

# Mengadaptasi skrip pelatihan Anda untuk menggunakan operasi kolektif SMDDP
<a name="data-parallel-modify-sdp-select-framework"></a>

Contoh skrip pelatihan yang disediakan di bagian ini disederhanakan dan hanya menyoroti perubahan yang diperlukan untuk mengaktifkan perpustakaan SageMaker AI distributed data parallelism (SMDDP) dalam skrip pelatihan Anda. Untuk contoh end-to-end notebook Jupyter yang menunjukkan cara menjalankan pekerjaan pelatihan terdistribusi dengan pustaka SMDDP, lihat. [Contoh perpustakaan paralelisme data Amazon SageMaker AI](distributed-data-parallel-v2-examples.md)

**Topics**
+ [Gunakan perpustakaan SMDDP dalam skrip pelatihan Anda PyTorch](data-parallel-modify-sdp-pt.md)
+ [Gunakan perpustakaan SMDDP dalam skrip pelatihan PyTorch Lightning Anda](data-parallel-modify-sdp-pt-lightning.md)
+ [Gunakan pustaka SMDDP dalam skrip TensorFlow pelatihan Anda (tidak digunakan lagi)](data-parallel-modify-sdp-tf2.md)

# Gunakan perpustakaan SMDDP dalam skrip pelatihan Anda PyTorch
<a name="data-parallel-modify-sdp-pt"></a>

[Mulai dari perpustakaan SageMaker AI distributed data parallelism (SMDDP) v1.4.0, Anda dapat menggunakan library sebagai opsi backend untuk paket terdistribusi. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Untuk menggunakan SMDDP `AllReduce` dan operasi `AllGather` kolektif, Anda hanya perlu mengimpor perpustakaan SMDDP di awal skrip pelatihan Anda dan menetapkan SMDDP sebagai backend modul terdistribusi selama inisialisasi grup proses. PyTorch Dengan satu baris spesifikasi backend, Anda dapat menyimpan semua modul PyTorch terdistribusi asli dan seluruh skrip pelatihan tidak berubah. [Cuplikan kode berikut menunjukkan cara menggunakan pustaka SMDDP sebagai backend paket pelatihan terdistribusi PyTorch berbasis: distributed [PyTorch data parallel (DDP), [PyTorch full sharded data parallelism](https://pytorch.org/docs/stable/fsdp.html) (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html), dan Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed)

## Untuk PyTorch DDP atau FSDP
<a name="data-parallel-enable-for-ptddp-ptfsdp"></a>

Inisialisasi kelompok proses sebagai berikut.

```
import torch.distributed as dist
import smdistributed.dataparallel.torch.torch_smddp

dist.init_process_group(backend="smddp")
```

**catatan**  
(Hanya untuk pekerjaan PyTorch DDP) `smddp` Backend saat ini tidak mendukung pembuatan grup subproses dengan API. `torch.distributed.new_group()` Anda juga tidak dapat menggunakan `smddp` backend secara bersamaan dengan backend grup proses lainnya seperti dan. `NCCL` `Gloo`

## Untuk DeepSpeed atau Megatron- DeepSpeed
<a name="data-parallel-enable-for-deepspeed"></a>

Inisialisasi kelompok proses sebagai berikut.

```
import deepspeed
import smdistributed.dataparallel.torch.torch_smddp

deepspeed.init_distributed(dist_backend="smddp")
```

**catatan**  
Untuk menggunakan SMDDP `AllGather` dengan peluncur `mpirun` berbasis (`smdistributed`dan`pytorchddp`) di[Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md), Anda juga perlu mengatur variabel lingkungan berikut dalam skrip pelatihan Anda.  

```
export SMDATAPARALLEL_OPTIMIZE_SDP=true
```

Untuk panduan umum tentang menulis skrip pelatihan PyTorch FSDP, lihat [Pelatihan Model Lanjutan dengan Paralel Data Berbagi Penuh (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) dalam dokumentasi. PyTorch

Untuk panduan umum tentang menulis skrip pelatihan PyTorch DDP, lihat [Memulai dengan data terdistribusi paralel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) dalam PyTorch dokumentasi.

Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md).

# Gunakan perpustakaan SMDDP dalam skrip pelatihan PyTorch Lightning Anda
<a name="data-parallel-modify-sdp-pt-lightning"></a>

Jika Anda ingin membawa skrip pelatihan [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) dan menjalankan pekerjaan pelatihan paralel data terdistribusi di SageMaker AI, Anda dapat menjalankan pekerjaan pelatihan dengan sedikit perubahan dalam skrip pelatihan Anda. Perubahan yang diperlukan meliputi: mengimpor PyTorch modul `smdistributed.dataparallel` perpustakaan, mengatur variabel lingkungan untuk PyTorch Lightning untuk menerima variabel lingkungan SageMaker AI yang telah ditetapkan oleh toolkit SageMaker pelatihan, dan mengaktifkan perpustakaan SMDDP dengan menyetel backend grup proses ke. `"smddp"` Untuk mempelajari lebih lanjut, ikuti instruksi berikut yang memecah langkah-langkah dengan contoh kode.

**catatan**  
Dukungan PyTorch Lightning tersedia di perpustakaan paralel data SageMaker AI v1.5.0 dan yang lebih baru.

## PyTorch Petir == v2.1.0 dan == 2.0.1 PyTorch
<a name="smddp-pt-201-lightning-210"></a>

1. Impor `pytorch_lightning` perpustakaan dan `smdistributed.dataparallel.torch` modul.

   ```
   import lightning as pl
   import smdistributed.dataparallel.torch.torch_smddp
   ```

1. Instantiate. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html)

   ```
   from lightning.fabric.plugins.environments.lightning import LightningEnvironment
   
   env = LightningEnvironment()
   env.world_size = lambda: int(os.environ["WORLD_SIZE"])
   env.global_rank = lambda: int(os.environ["RANK"])
   ```

1. **Untuk PyTorch DDP** — Buat objek [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)kelas dengan `"smddp"` for `process_group_backend` dan `"gpu"` for`accelerator`, dan berikan itu ke kelas [Trainer](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html).

   ```
   import lightning as pl
   from lightning.pytorch.strategies import DDPStrategy
   
   ddp = DDPStrategy(
       cluster_environment=env, 
       process_group_backend="smddp", 
       accelerator="gpu"
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=ddp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

   **Untuk PyTorch FSDP** [- Buat objek [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)kelas (dengan [kebijakan pembungkus](https://pytorch.org/docs/stable/fsdp.html) pilihan) dengan `"smddp"` for `process_group_backend` dan `"gpu"` for`accelerator`, dan teruskan ke kelas Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html)

   ```
   import lightning as pl
   from lightning.pytorch.strategies import FSDPStrategy
   
   from functools import partial
   from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy
   
   policy = partial(
       size_based_auto_wrap_policy, 
       min_num_params=10000
   )
   
   fsdp = FSDPStrategy(
       auto_wrap_policy=policy,
       process_group_backend="smddp", 
       cluster_environment=env
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=fsdp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md). 

**catatan**  
Saat Anda membuat PyTorch estimator SageMaker AI dan mengajukan permintaan pekerjaan pelatihan[Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md), Anda perlu menyediakan `requirements.txt` untuk menginstal `pytorch-lightning` dan `lightning-bolts` dalam wadah PyTorch pelatihan SageMaker AI.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Untuk informasi selengkapnya tentang menentukan direktori sumber untuk menempatkan `requirements.txt` file bersama dengan skrip pelatihan dan pengiriman pekerjaan, lihat [Menggunakan pustaka pihak ketiga](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) dalam dokumentasi Amazon *AI SageMaker Python* SDK.

# Gunakan pustaka SMDDP dalam skrip TensorFlow pelatihan Anda (tidak digunakan lagi)
<a name="data-parallel-modify-sdp-tf2"></a>

**penting**  
Pustaka SMDDP menghentikan dukungan untuk TensorFlow dan tidak lagi tersedia di TensorFlow lebih dari DLCs v2.11.0. Untuk menemukan sebelumnya TensorFlow DLCs dengan perpustakaan SMDDP diinstal, lihat. [Kerangka kerja yang didukung](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks)

Langkah-langkah berikut menunjukkan cara memodifikasi skrip TensorFlow pelatihan untuk memanfaatkan perpustakaan paralel data terdistribusi SageMaker AI.  

Perpustakaan APIs dirancang agar mirip dengan Horovod APIs. Untuk detail tambahan tentang setiap API yang ditawarkan library TensorFlow, lihat [dokumentasi TensorFlow API paralel data terdistribusi SageMaker AI](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation).

**catatan**  
SageMaker AI distributed data parallel dapat disesuaikan dengan skrip TensorFlow pelatihan yang terdiri dari modul `tf` inti kecuali `tf.keras` modul. SageMaker AI distributed data parallel tidak mendukung TensorFlow implementasi Keras.

**catatan**  
Pustaka paralelisme data terdistribusi SageMaker AI mendukung Automatic Mixed Precision (AMP) di luar kotak. Tidak diperlukan tindakan tambahan untuk mengaktifkan AMP selain modifikasi tingkat kerangka kerja pada skrip pelatihan Anda. Jika gradien masuk FP16, perpustakaan paralelisme data SageMaker AI menjalankan operasinya `AllReduce` di. FP16 Untuk informasi selengkapnya tentang penerapan AMP APIs ke skrip pelatihan Anda, lihat sumber daya berikut:  
[Kerangka kerja - TensorFlow dalam dokumentasi](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) *NVIDIA Deep Learning Performance*
[Presisi Campuran Otomatis untuk Pembelajaran Mendalam](https://developer.nvidia.com/automatic-mixed-precision) di *Dokumen Pengembang NVIDIA*
[TensorFlow presisi campuran APIs](https://www.tensorflow.org/guide/mixed_precision) dalam *TensorFlowdokumentasi*

1. Impor TensorFlow klien perpustakaan dan inisialisasi.

   ```
   import smdistributed.dataparallel.tensorflow as sdp 
   sdp.init()
   ```

1. Sematkan setiap GPU ke satu `smdistributed.dataparallel` proses dengan `local_rank` —ini mengacu pada peringkat relatif proses dalam node tertentu. `sdp.tensorflow.local_rank()`API memberi Anda peringkat lokal perangkat. Node pemimpin adalah peringkat 0, dan node pekerja adalah peringkat 1, 2, 3, dan seterusnya. Ini dipanggil dalam blok kode berikut sebagai`sdp.local_rank()`. `set_memory_growth`tidak terkait langsung dengan SageMaker AI yang didistribusikan, tetapi harus ditetapkan untuk pelatihan terdistribusi dengan TensorFlow. 

   ```
   gpus = tf.config.experimental.list_physical_devices('GPU')
   for gpu in gpus:
       tf.config.experimental.set_memory_growth(gpu, True)
   if gpus:
       tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')
   ```

1. Skala tingkat pembelajaran dengan jumlah pekerja. `sdp.tensorflow.size()`API memberi Anda jumlah pekerja di cluster. Ini dipanggil dalam blok kode berikut sebagai`sdp.size()`. 

   ```
   learning_rate = learning_rate * sdp.size()
   ```

1. Gunakan perpustakaan `DistributedGradientTape` untuk mengoptimalkan `AllReduce` operasi selama pelatihan. Ini membungkus`tf.GradientTape`.  

   ```
   with tf.GradientTape() as tape:
         output = model(input)
         loss_value = loss(label, output)
       
   # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
   tape = sdp.DistributedGradientTape(tape)
   ```

1. Siarkan variabel model awal dari node pemimpin (peringkat 0) ke semua node pekerja (peringkat 1 hingga n). Ini diperlukan untuk memastikan inisialisasi yang konsisten di semua peringkat pekerja. Gunakan `sdp.tensorflow.broadcast_variables` API setelah variabel model dan pengoptimal diinisialisasi. Ini dipanggil dalam blok kode berikut sebagai`sdp.broadcast_variables()`. 

   ```
   sdp.broadcast_variables(model.variables, root_rank=0)
   sdp.broadcast_variables(opt.variables(), root_rank=0)
   ```

1. Terakhir, modifikasi skrip Anda untuk menyimpan pos pemeriksaan hanya pada node pemimpin. Node pemimpin memiliki model yang disinkronkan. Ini juga menghindari node pekerja yang menimpa pos pemeriksaan dan mungkin merusak pos pemeriksaan. 

   ```
   if sdp.rank() == 0:
       checkpoint.save(checkpoint_dir)
   ```

Berikut ini adalah contoh skrip TensorFlow pelatihan untuk pelatihan terdistribusi dengan perpustakaan.

```
import tensorflow as tf

# SageMaker AI data parallel: Import the library TF API
import smdistributed.dataparallel.tensorflow as sdp

# SageMaker AI data parallel: Initialize the library
sdp.init()

gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)
if gpus:
    # SageMaker AI data parallel: Pin GPUs to a single library process
    tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')

# Prepare Dataset
dataset = tf.data.Dataset.from_tensor_slices(...)

# Define Model
mnist_model = tf.keras.Sequential(...)
loss = tf.losses.SparseCategoricalCrossentropy()

# SageMaker AI data parallel: Scale Learning Rate
# LR for 8 node run : 0.000125
# LR for single node run : 0.001
opt = tf.optimizers.Adam(0.000125 * sdp.size())

@tf.function
def training_step(images, labels, first_batch):
    with tf.GradientTape() as tape:
        probs = mnist_model(images, training=True)
        loss_value = loss(labels, probs)

    # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
    tape = sdp.DistributedGradientTape(tape)

    grads = tape.gradient(loss_value, mnist_model.trainable_variables)
    opt.apply_gradients(zip(grads, mnist_model.trainable_variables))

    if first_batch:
       # SageMaker AI data parallel: Broadcast model and optimizer variables
       sdp.broadcast_variables(mnist_model.variables, root_rank=0)
       sdp.broadcast_variables(opt.variables(), root_rank=0)

    return loss_value

...

# SageMaker AI data parallel: Save checkpoints only from master node.
if sdp.rank() == 0:
    checkpoint.save(checkpoint_dir)
```

Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK](data-parallel-use-api.md). 

# Meluncurkan pekerjaan pelatihan terdistribusi dengan SMDDP menggunakan Python SageMaker SDK
<a name="data-parallel-use-api"></a>

Untuk menjalankan pekerjaan pelatihan terdistribusi dengan skrip adaptasi Anda dari[Mengadaptasi skrip pelatihan Anda untuk menggunakan operasi kolektif SMDDP](data-parallel-modify-sdp-select-framework.md), gunakan kerangka kerja SageMaker Python SDK atau estimator generik dengan menentukan skrip pelatihan yang disiapkan sebagai skrip titik masuk dan konfigurasi pelatihan terdistribusi.

Halaman ini memandu Anda melalui cara menggunakan [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) dalam dua cara.
+ Jika Anda ingin mencapai adopsi cepat dari pekerjaan pelatihan terdistribusi Anda di SageMaker AI, konfigurasikan kelas SageMaker AI [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)atau penaksir [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)kerangka kerja. Estimator framework mengambil skrip latihan Anda dan secara otomatis mencocokkan URI gambar yang tepat dari Deep Learning Containers (DLC) yang [sudah dibuat sebelumnya PyTorch atau TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), dengan nilai yang ditentukan pada parameter. `framework_version`
+ Jika Anda ingin memperluas salah satu container yang sudah dibuat sebelumnya atau membuat container khusus untuk membuat lingkungan MLmu sendiri dengan SageMaker AI, gunakan `Estimator` class generik AI dan tentukan URI image dari container Docker kustom yang dihosting di Amazon Elastic Container Registry (Amazon ECR). SageMaker 

Kumpulan data pelatihan Anda harus disimpan di Amazon S3 [atau FSx Amazon](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) untuk Lustre Wilayah AWS di mana Anda meluncurkan pekerjaan pelatihan Anda. Jika Anda menggunakan notebook Jupyter, Anda harus memiliki instance SageMaker notebook atau aplikasi SageMaker Studio Classic yang berjalan dalam hal yang sama. Wilayah AWS Untuk informasi selengkapnya tentang menyimpan data latihan, lihat dokumentasi [SageMaker input data SDK Python](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). 

**Tip**  
Kami menyarankan Anda menggunakan Amazon FSx untuk Lustre alih-alih Amazon S3 untuk meningkatkan kinerja pelatihan. Amazon FSx memiliki throughput yang lebih tinggi dan latensi yang lebih rendah daripada Amazon S3.

**Tip**  
Untuk menjalankan pelatihan terdistribusi dengan benar pada jenis instans yang mendukung EFA, Anda harus mengaktifkan lalu lintas antar instans dengan menyiapkan grup keamanan VPC Anda untuk memungkinkan semua lalu lintas masuk dan keluar ke dan dari grup keamanan itu sendiri. Untuk mempelajari cara mengatur aturan grup keamanan, lihat [Langkah 1: Mempersiapkan grup keamanan berkemampuan EFA di Panduan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) Pengguna *Amazon EC2*.

Pilih salah satu topik berikut untuk instruksi tentang cara menjalankan pekerjaan pelatihan terdistribusi dari skrip pelatihan Anda. Setelah Anda meluncurkan pekerjaan pelatihan, Anda dapat memantau pemanfaatan sistem dan kinerja model menggunakan [Amazon SageMaker Debugger](train-debugger.md) atau Amazon CloudWatch.

Saat Anda mengikuti petunjuk dalam topik berikut untuk mempelajari lebih lanjut tentang detail teknis, kami juga menyarankan Anda mencoba [Contoh perpustakaan paralelisme data Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) untuk memulai.

**Topics**
+ [Gunakan estimator PyTorch kerangka kerja di SageMaker Python SDK](data-parallel-framework-estimator.md)
+ [Gunakan estimator generik SageMaker AI untuk memperluas wadah DLC yang sudah dibuat sebelumnya](data-parallel-use-python-skd-api.md)
+ [Buat wadah Docker Anda sendiri dengan perpustakaan paralel data terdistribusi SageMaker AI](data-parallel-bring-your-own-container.md)

# Gunakan estimator PyTorch kerangka kerja di SageMaker Python SDK
<a name="data-parallel-framework-estimator"></a>

Anda dapat meluncurkan pelatihan terdistribusi dengan menambahkan `distribution` argumen ke estimator kerangka kerja SageMaker AI, [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)atau [https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator). Untuk detail selengkapnya, pilih salah satu kerangka kerja yang didukung oleh perpustakaan SageMaker AI distributed data parallelism (SMDDP) dari pilihan berikut.

------
#### [ PyTorch ]

Opsi peluncur berikut tersedia untuk meluncurkan pelatihan PyTorch terdistribusi.
+ `pytorchddp`— Opsi ini menjalankan `mpirun` dan mengatur variabel lingkungan yang diperlukan untuk menjalankan pelatihan PyTorch terdistribusi tentang SageMaker AI. Untuk menggunakan opsi ini, teruskan kamus berikut ke `distribution` parameter.

  ```
  { "pytorchddp": { "enabled": True } }
  ```
+ `torch_distributed`— Opsi ini menjalankan `torchrun` dan mengatur variabel lingkungan yang diperlukan untuk menjalankan pelatihan PyTorch terdistribusi tentang SageMaker AI. Untuk menggunakan opsi ini, teruskan kamus berikut ke `distribution` parameter.

  ```
  { "torch_distributed": { "enabled": True } }
  ```
+ `smdistributed`— Opsi ini juga berjalan `mpirun` tetapi dengan `smddprun` itu mengatur variabel lingkungan yang diperlukan untuk menjalankan pelatihan PyTorch terdistribusi tentang SageMaker AI.

  ```
  { "smdistributed": { "dataparallel": { "enabled": True } } }
  ```

Jika Anda memilih untuk mengganti NCCL `AllGather` ke SMDDP`AllGather`, Anda dapat menggunakan ketiga opsi. Pilih satu opsi yang sesuai dengan kasus penggunaan Anda.

Jika Anda memilih untuk mengganti NCCL `AllReduce` dengan SMDDP`AllReduce`, Anda harus memilih salah satu opsi `mpirun` berbasis: atau. `smdistributed` `pytorchddp` Anda juga dapat menambahkan opsi MPI tambahan sebagai berikut.

```
{ 
    "pytorchddp": {
        "enabled": True, 
        "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
    }
}
```

```
{ 
    "smdistributed": { 
        "dataparallel": {
            "enabled": True, 
            "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
        }
    }
}
```

Contoh kode berikut menunjukkan struktur dasar PyTorch estimator dengan opsi pelatihan terdistribusi.

```
from sagemaker.pytorch import PyTorch

pt_estimator = PyTorch(
    base_job_name="training_job_name_prefix",
    source_dir="subdirectory-to-your-code",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    py_version="py310",
    framework_version="2.0.1",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p4de.24xlarge
    instance_type="ml.p4d.24xlarge",

    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

pt_estimator.fit("s3://bucket/path/to/training/data")
```

**catatan**  
PyTorch Lightning dan perpustakaan utilitasnya seperti Lightning Bolts tidak diinstal sebelumnya di AI. SageMaker PyTorch DLCs Buat `requirements.txt` file berikut dan simpan di direktori sumber tempat Anda menyimpan skrip pelatihan.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Misalnya, direktori terstruktur pohon akan terlihat seperti berikut ini.  

```
├── pytorch_training_launcher_jupyter_notebook.ipynb
└── sub-folder-for-your-code
    ├──  adapted-training-script.py
    └──  requirements.txt
```
Untuk informasi selengkapnya tentang menentukan direktori sumber untuk menempatkan `requirements.txt` file bersama dengan skrip pelatihan dan pengiriman pekerjaan, lihat [Menggunakan pustaka pihak ketiga](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) dalam dokumentasi Amazon *AI SageMaker Python* SDK.

**Pertimbangan untuk mengaktifkan operasi kolektif SMDDP dan menggunakan opsi peluncur pelatihan terdistribusi yang tepat**
+ SMDDP `AllReduce` dan SMDDP tidak saling `AllGather` kompatibel saat ini.
+ SMDDP `AllReduce` diaktifkan secara default saat menggunakan `smdistributed` atau`pytorchddp`, yang `mpirun` berbasis peluncur, dan NCCL digunakan. `AllGather`
+ SMDDP `AllGather` diaktifkan secara default saat menggunakan `torch_distributed` peluncur, dan kembali ke `AllReduce` NCCL.
+ SMDDP juga `AllGather` dapat diaktifkan saat menggunakan peluncur `mpirun` berbasis dengan variabel lingkungan tambahan yang ditetapkan sebagai berikut.

  ```
  export SMDATAPARALLEL_OPTIMIZE_SDP=true
  ```

------
#### [ TensorFlow ]

**penting**  
Pustaka SMDDP menghentikan dukungan untuk TensorFlow dan tidak lagi tersedia di TensorFlow lebih dari DLCs v2.11.0. Untuk menemukan sebelumnya TensorFlow DLCs dengan pustaka SMDDP diinstal, lihat. [TensorFlow (usang)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow)

```
from sagemaker.tensorflow import TensorFlow

tf_estimator = TensorFlow(
    base_job_name = "training_job_name_prefix",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    framework_version="2.11.0",
    py_version="py38",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge
    instance_type="ml.p3.16xlarge",

    # Training using the SageMaker AI data parallel distributed training strategy
    distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }
)

tf_estimator.fit("s3://bucket/path/to/training/data")
```

------

# Gunakan estimator generik SageMaker AI untuk memperluas wadah DLC yang sudah dibuat sebelumnya
<a name="data-parallel-use-python-skd-api"></a>

Anda dapat menyesuaikan kontainer prebuilt SageMaker AI atau memperluasnya untuk menangani persyaratan fungsional tambahan apa pun untuk algoritme atau model Anda yang tidak didukung oleh image SageMaker AI Docker bawaan. Untuk contoh bagaimana Anda dapat memperluas kontainer yang sudah dibuat sebelumnya, lihat [Memperluas Kontainer Prebuilt](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).

Untuk memperluas wadah bawaan atau menyesuaikan wadah Anda sendiri untuk menggunakan pustaka, Anda harus menggunakan salah satu gambar yang tercantum di dalamnya[Kerangka kerja yang didukung](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

**catatan**  
Dari TensorFlow 2.4.1 dan PyTorch 1.8.1, kerangka kerja SageMaker AI DLCs mendukung jenis instans berkemampuan EFA. Kami menyarankan Anda menggunakan gambar DLC yang berisi TensorFlow 2.4.1 atau yang lebih baru dan PyTorch 1.8.1 atau yang lebih baru. 

Misalnya, jika Anda menggunakan PyTorch, Dockerfile Anda harus berisi `FROM` pernyataan yang mirip dengan berikut ini:

```
# SageMaker AI PyTorch image
FROM 763104351884.dkr.ecr.<aws-region>.amazonaws.com/pytorch-training:<image-tag>

ENV PATH="/opt/ml/code:${PATH}"

# this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code

# /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code.
COPY train.py /opt/ml/code/train.py

# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```

Anda dapat lebih lanjut menyesuaikan wadah Docker Anda sendiri untuk bekerja dengan SageMaker AI menggunakan [toolkit SageMaker Pelatihan](https://github.com/aws/sagemaker-training-toolkit) dan file biner dari perpustakaan paralel SageMaker data terdistribusi AI. Untuk mempelajari lebih lanjut, lihat petunjuk di bagian berikut.

# Buat wadah Docker Anda sendiri dengan perpustakaan paralel data terdistribusi SageMaker AI
<a name="data-parallel-bring-your-own-container"></a>

Untuk membangun wadah Docker Anda sendiri untuk pelatihan dan menggunakan perpustakaan paralel data SageMaker AI, Anda harus menyertakan dependensi yang benar dan file biner dari pustaka paralel SageMaker terdistribusi AI di Dockerfile Anda. Bagian ini memberikan instruksi tentang cara membuat Dockerfile lengkap dengan kumpulan dependensi minimum untuk pelatihan terdistribusi di SageMaker AI menggunakan pustaka paralel data.

**catatan**  
Opsi Docker khusus ini dengan pustaka paralel data SageMaker AI sebagai biner hanya tersedia untuk PyTorch.

**Untuk membuat Dockerfile dengan toolkit SageMaker pelatihan dan pustaka paralel data**

1. Mulailah dengan gambar Docker dari [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Gunakan versi pengembang cuDNN yang berisi runtime CUDA dan alat pengembangan (header dan pustaka) untuk membangun dari kode sumber. PyTorch ](https://github.com/pytorch/pytorch#from-source)

   ```
   FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04
   ```
**Tip**  
Gambar AWS Deep Learning Container (DLC) resmi dibuat dari gambar dasar [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Jika Anda ingin menggunakan gambar DLC bawaan sebagai referensi sambil mengikuti instruksi lainnya, lihat [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/tree/master/pytorch) untuk Dockerfiles. PyTorch 

1. Tambahkan argumen berikut untuk menentukan versi PyTorch dan paket lainnya. Juga, tunjukkan jalur bucket Amazon S3 ke perpustakaan paralel data SageMaker AI dan perangkat lunak lain untuk menggunakan AWS sumber daya, seperti plug-in Amazon S3. 

   Untuk menggunakan versi pustaka pihak ketiga selain yang disediakan dalam contoh kode berikut, kami sarankan Anda melihat ke [Dockerfiles resmi AWS Deep Learning Container PyTorch untuk](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) menemukan versi yang diuji, kompatibel, dan cocok untuk aplikasi Anda. 

    URLs Untuk menemukan `SMDATAPARALLEL_BINARY` argumen, lihat tabel pencarian di[Kerangka kerja yang didukung](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

   ```
   ARG PYTORCH_VERSION=1.10.2
   ARG PYTHON_SHORT_VERSION=3.8
   ARG EFA_VERSION=1.14.1
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
   ARG CONDA_PREFIX="/opt/conda"
   ARG BRANCH_OFI=1.1.3-aws
   ```

1. Atur variabel lingkungan berikut untuk membangun komponen SageMaker pelatihan dengan benar dan menjalankan pustaka paralel data. Anda menggunakan variabel-variabel ini untuk komponen pada langkah selanjutnya.

   ```
   # Set ENV variables required to build PyTorch
   ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0"
   ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
   ENV NCCL_VERSION=2.10.3
   
   # Add OpenMPI to the path.
   ENV PATH /opt/amazon/openmpi/bin:$PATH
   
   # Add Conda to path
   ENV PATH $CONDA_PREFIX/bin:$PATH
   
   # Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
   ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main
   
   # Add enviroment variable for processes to be able to call fork()
   ENV RDMAV_FORK_SAFE=1
   
   # Indicate the container type
   ENV DLC_CONTAINER_TYPE=training
   
   # Add EFA and SMDDP to LD library path
   ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
   ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH
   ```

1. Instal atau perbarui `curl``wget`,, dan `git` unduh dan buat paket di langkah selanjutnya.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
       apt-get update && apt-get install -y  --no-install-recommends \
           curl \
           wget \
           git \
       && rm -rf /var/lib/apt/lists/*
   ```

1. Instal [perangkat lunak Elastic Fabric Adapter (EFA) untuk komunikasi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) jaringan Amazon EC2.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update
   RUN mkdir /tmp/efa \
       && cd /tmp/efa \
       && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
       && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
       && cd aws-efa-installer \
       && ./efa_installer.sh -y --skip-kmod -g \
       && rm -rf /tmp/efa
   ```

1. Instal [Conda](https://docs.conda.io/en/latest/) untuk menangani manajemen paket. 

   ```
   RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
       chmod +x ~/miniconda.sh && \
       ~/miniconda.sh -b -p $CONDA_PREFIX && \
       rm ~/miniconda.sh && \
       $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
       $CONDA_PREFIX/bin/conda clean -ya
   ```

1. Dapatkan, bangun, PyTorch dan instal serta dependensinya. Kami membangun [PyTorch dari kode sumber](https://github.com/pytorch/pytorch#from-source) karena kami perlu memiliki kontrol versi NCCL untuk menjamin kompatibilitas dengan plug-in [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL.

   1. Mengikuti langkah-langkah di [dockerfile PyTorch resmi](https://github.com/pytorch/pytorch/blob/master/Dockerfile), instal dependensi build dan atur [ccache untuk mempercepat kompilasi ulang](https://ccache.dev/).

      ```
      RUN DEBIAN_FRONTEND=noninteractive \
          apt-get install -y --no-install-recommends \
              build-essential \
              ca-certificates \
              ccache \
              cmake \
              git \
              libjpeg-dev \
              libpng-dev \
          && rm -rf /var/lib/apt/lists/*
        
      # Setup ccache
      RUN /usr/sbin/update-ccache-symlinks
      RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache
      ```

   1. [Ketergantungan umum dan Linux](https://github.com/pytorch/pytorch#install-dependencies) InstallPyTorch.

      ```
      # Common dependencies for PyTorch
      RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses
      
      # Linux specific dependency for PyTorch
      RUN conda install -c pytorch magma-cuda113
      ```

   1. Kloning [PyTorch GitHubrepositori](https://github.com/pytorch/pytorch).

      ```
      RUN --mount=type=cache,target=/opt/ccache \
          cd / \
          && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
      ```

   1. Instal dan buat versi [NCCL](https://developer.nvidia.com/nccl) tertentu. Untuk melakukan ini, ganti konten di folder NCCL default (`/pytorch/third_party/nccl`) dengan versi NCCL tertentu dari repositori NVIDIA. PyTorch Versi NCCL ditetapkan pada langkah 3 panduan ini.

      ```
      RUN cd /pytorch/third_party/nccl \
          && rm -rf nccl \
          && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
          && cd nccl \
          && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
          && make pkg.txz.build \
          && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1
      ```

   1. Membangun dan menginstal PyTorch. Proses ini biasanya memakan waktu sedikit lebih dari 1 jam untuk menyelesaikannya. Itu dibangun menggunakan versi NCCL yang diunduh pada langkah sebelumnya.

      ```
      RUN cd /pytorch \
          && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
          python setup.py install \
          && rm -rf /pytorch
      ```

1. Membangun dan menginstal [AWS plugin OFI NCCL](https://github.com/aws/aws-ofi-nccl). Ini memungkinkan dukungan [libfabric](https://github.com/ofiwg/libfabric) untuk perpustakaan paralel data SageMaker AI.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update \
       && apt-get install -y --no-install-recommends \
           autoconf \
           automake \
           libtool
   RUN mkdir /tmp/efa-ofi-nccl \
       && cd /tmp/efa-ofi-nccl \
       && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
       && cd aws-ofi-nccl \
       && ./autogen.sh \
       && ./configure --with-libfabric=/opt/amazon/efa \
       --with-mpi=/opt/amazon/openmpi \
       --with-cuda=/usr/local/cuda \
       --with-nccl=$CONDA_PREFIX \
       && make \
       && make install \
       && rm -rf /tmp/efa-ofi-nccl
   ```

1. Membangun dan menginstal [TorchVision](https://github.com/pytorch/vision.git).

   ```
   RUN pip install --no-cache-dir -U \
       packaging \
       mpi4py==3.0.3
   RUN cd /tmp \
       && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
       && cd vision \
       && BUILD_VERSION="0.9.1+cu111" python setup.py install \
       && cd /tmp \
       && rm -rf vision
   ```

1. Instal dan konfigurasikan OpenSSH. OpenSSH diperlukan agar MPI dapat berkomunikasi antar kontainer. Izinkan OpenSSH untuk berbicara dengan kontainer tanpa meminta konfirmasi.

   ```
   RUN apt-get update \
       && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
       && apt-get install -y --no-install-recommends openssh-client openssh-server \
       && mkdir -p /var/run/sshd \
       && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
       && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
       && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
       && rm -rf /var/lib/apt/lists/*
   
   # Configure OpenSSH so that nodes can communicate with each other
   RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
   RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config
   ```

1. Instal plug-in PT S3 untuk mengakses kumpulan data secara efisien di Amazon S3.

   ```
   RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
   RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt
   ```

1. Instal perpustakaan [libboost](https://www.boost.org/). Paket ini diperlukan untuk jaringan fungsionalitas IO asinkron dari perpustakaan paralel SageMaker data AI.

   ```
   WORKDIR /
   RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
       && tar -xzf boost_1_73_0.tar.gz \
       && cd boost_1_73_0 \
       && ./bootstrap.sh \
       && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
       && cd .. \
       && rm -rf boost_1_73_0.tar.gz \
       && rm -rf boost_1_73_0 \
       && cd ${CONDA_PREFIX}/include/boost
   ```

1. Instal alat SageMaker AI berikut untuk PyTorch pelatihan.

   ```
   WORKDIR /root
   RUN pip install --no-cache-dir -U \
       smclarify \
       "sagemaker>=2,<3" \
       sagemaker-experiments==0.* \
       sagemaker-pytorch-training
   ```

1. Terakhir, instal biner paralel data SageMaker AI dan dependensi yang tersisa.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
     apt-get update && apt-get install -y  --no-install-recommends \
     jq \
     libhwloc-dev \
     libnuma1 \
     libnuma-dev \
     libssl1.1 \
     libtool \
     hwloc \
     && rm -rf /var/lib/apt/lists/*
   
   RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
   ```

1. Setelah Anda selesai membuat Dockerfile, lihat [Mengadaptasi Wadah Pelatihan Anda Sendiri untuk mempelajari cara membuat container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) Docker, menghostingnya di Amazon ECR, dan menjalankan tugas pelatihan menggunakan Python SDK. SageMaker 

Kode contoh berikut menunjukkan Dockerfile lengkap setelah menggabungkan semua blok kode sebelumnya.

```
# This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training
FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04

# Set appropiate versions and location for components
ARG PYTORCH_VERSION=1.10.2
ARG PYTHON_SHORT_VERSION=3.8
ARG EFA_VERSION=1.14.1
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
ARG CONDA_PREFIX="/opt/conda"
ARG BRANCH_OFI=1.1.3-aws

# Set ENV variables required to build PyTorch
ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0"
ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
ENV NCCL_VERSION=2.10.3

# Add OpenMPI to the path.
ENV PATH /opt/amazon/openmpi/bin:$PATH

# Add Conda to path
ENV PATH $CONDA_PREFIX/bin:$PATH

# Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main

# Add enviroment variable for processes to be able to call fork()
ENV RDMAV_FORK_SAFE=1

# Indicate the container type
ENV DLC_CONTAINER_TYPE=training

# Add EFA and SMDDP to LD library path
ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH

# Install basic dependencies to download and build other dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
  apt-get update && apt-get install -y  --no-install-recommends \
  curl \
  wget \
  git \
  && rm -rf /var/lib/apt/lists/*

# Install EFA.
# This is required for SMDDP backend communication
RUN DEBIAN_FRONTEND=noninteractive apt-get update
RUN mkdir /tmp/efa \
    && cd /tmp/efa \
    && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
    && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
    && cd aws-efa-installer \
    && ./efa_installer.sh -y --skip-kmod -g \
    && rm -rf /tmp/efa

# Install Conda
RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
    chmod +x ~/miniconda.sh && \
    ~/miniconda.sh -b -p $CONDA_PREFIX && \
    rm ~/miniconda.sh && \
    $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
    $CONDA_PREFIX/bin/conda clean -ya

# Install PyTorch.
# Start with dependencies listed in official PyTorch dockerfile
# https://github.com/pytorch/pytorch/blob/master/Dockerfile
RUN DEBIAN_FRONTEND=noninteractive \
    apt-get install -y --no-install-recommends \
        build-essential \
        ca-certificates \
        ccache \
        cmake \
        git \
        libjpeg-dev \
        libpng-dev && \
    rm -rf /var/lib/apt/lists/*

# Setup ccache
RUN /usr/sbin/update-ccache-symlinks
RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache

# Common dependencies for PyTorch
RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses

# Linux specific dependency for PyTorch
RUN conda install -c pytorch magma-cuda113

# Clone PyTorch
RUN --mount=type=cache,target=/opt/ccache \
    cd / \
    && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
# Note that we need to use the same NCCL version for PyTorch and OFI plugin.
# To enforce that, install NCCL from source before building PT and OFI plugin.

# Install NCCL.
# Required for building OFI plugin (OFI requires NCCL's header files and library)
RUN cd /pytorch/third_party/nccl \
    && rm -rf nccl \
    && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
    && cd nccl \
    && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
    && make pkg.txz.build \
    && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1

# Build and install PyTorch.
RUN cd /pytorch \
    && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
    python setup.py install \
    && rm -rf /pytorch

RUN ccache -C

# Build and install OFI plugin. \
# It is required to use libfabric.
RUN DEBIAN_FRONTEND=noninteractive apt-get update \
    && apt-get install -y --no-install-recommends \
        autoconf \
        automake \
        libtool
RUN mkdir /tmp/efa-ofi-nccl \
    && cd /tmp/efa-ofi-nccl \
    && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
    && cd aws-ofi-nccl \
    && ./autogen.sh \
    && ./configure --with-libfabric=/opt/amazon/efa \
        --with-mpi=/opt/amazon/openmpi \
        --with-cuda=/usr/local/cuda \
        --with-nccl=$CONDA_PREFIX \
    && make \
    && make install \
    && rm -rf /tmp/efa-ofi-nccl

# Build and install Torchvision
RUN pip install --no-cache-dir -U \
    packaging \
    mpi4py==3.0.3
RUN cd /tmp \
    && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
    && cd vision \
    && BUILD_VERSION="0.9.1+cu111" python setup.py install \
    && cd /tmp \
    && rm -rf vision

# Install OpenSSH.
# Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation
RUN apt-get update \
    && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
    && apt-get install -y --no-install-recommends openssh-client openssh-server \
    && mkdir -p /var/run/sshd \
    && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
    && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
    && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
    && rm -rf /var/lib/apt/lists/*
# Configure OpenSSH so that nodes can communicate with each other
RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config

# Install PT S3 plugin.
# Required to efficiently access datasets in Amazon S3
RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt

# Install libboost from source.
# This package is needed for smdataparallel functionality (for networking asynchronous IO).
WORKDIR /
RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
    && tar -xzf boost_1_73_0.tar.gz \
    && cd boost_1_73_0 \
    && ./bootstrap.sh \
    && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
    && cd .. \
    && rm -rf boost_1_73_0.tar.gz \
    && rm -rf boost_1_73_0 \
    && cd ${CONDA_PREFIX}/include/boost

# Install SageMaker AI PyTorch training.
WORKDIR /root
RUN pip install --no-cache-dir -U \
    smclarify \
    "sagemaker>=2,<3" \
    sagemaker-experiments==0.* \
    sagemaker-pytorch-training

# Install SageMaker AI data parallel binary (SMDDP)
# Start with dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
    apt-get update && apt-get install -y  --no-install-recommends \
        jq \
        libhwloc-dev \
        libnuma1 \
        libnuma-dev \
        libssl1.1 \
        libtool \
        hwloc \
    && rm -rf /var/lib/apt/lists/*

# Install SMDDP
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```

**Tip**  
Untuk informasi lebih umum tentang membuat Dockerfile khusus untuk pelatihan SageMaker AI, lihat [Menggunakan Algoritma Pelatihan Anda Sendiri](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html).

**Tip**  
Jika Anda ingin memperluas Dockerfile khusus untuk menggabungkan pustaka paralel model SageMaker AI, lihat. [Buat Container Docker Anda Sendiri dengan Perpustakaan Paralel Model SageMaker Terdistribusi](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container)