Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# (Diarsipkan) perpustakaan SageMaker paralelisme model v1.x
**penting**
Pada 19 Desember 2023, perpustakaan SageMaker model paralelisme (SMP) v2 dirilis. Dalam mendukung perpustakaan SMP v2, kemampuan SMP v1 tidak lagi didukung dalam rilis future. Bagian dan topik berikut diarsipkan dan khusus untuk menggunakan perpustakaan SMP v1. Untuk informasi tentang menggunakan pustaka SMP v2, lihat[SageMaker perpustakaan paralelisme model v2](model-parallel-v2.md).
Gunakan perpustakaan paralel model Amazon SageMaker AI untuk melatih model deep learning (DL) besar yang sulit dilatih karena keterbatasan memori GPU. Pustaka secara otomatis dan efisien membagi model di beberapa GPUs dan instance. Dengan menggunakan perpustakaan, Anda dapat mencapai akurasi prediksi target lebih cepat dengan melatih model DL yang lebih besar secara efisien dengan miliaran atau triliunan parameter.
Anda dapat menggunakan pustaka untuk secara otomatis mempartisi sendiri TensorFlow dan PyTorch model Anda di beberapa GPUs dan beberapa node dengan perubahan kode minimal. Anda dapat mengakses API perpustakaan melalui SageMaker Python SDK.
Gunakan bagian berikut untuk mempelajari selengkapnya tentang paralelisme model dan pustaka SageMaker paralel model. Dokumentasi API pustaka ini terletak di [Pelatihan Terdistribusi APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) dalam dokumentasi *SageMaker Python SDK* v2.199.0.
**Topics**
+ [Pengantar Paralelisme Model](model-parallel-intro.md)
+ [Kerangka Kerja yang Didukung dan Wilayah AWS](distributed-model-parallel-support.md)
+ [Fitur Inti dari Perpustakaan Paralelisme SageMaker Model](model-parallel-core-features.md)
+ [Jalankan Job Pelatihan SageMaker Terdistribusi dengan Paralelisme Model](model-parallel-use-api.md)
+ [Checkpointing dan Fine-Tuning Model dengan Paralelisme Model](distributed-model-parallel-checkpointing-and-finetuning.md)
+ [Contoh perpustakaan paralelisme model Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
+ [SageMaker Praktik Terbaik Paralelisme Model Terdistribusi](model-parallel-best-practices.md)
+ [Tips dan Jebakan Konfigurasi Perpustakaan Paralelisme Model SageMaker Terdistribusi](model-parallel-customize-tips-pitfalls.md)
+ [Pemecahan Masalah Paralel Model](distributed-troubleshooting-model-parallel.md)
# Pengantar Paralelisme Model
Paralelisme model adalah metode pelatihan terdistribusi di mana model pembelajaran mendalam dipartisi di beberapa perangkat, di dalam atau di seluruh instance. Halaman pengantar ini memberikan gambaran tingkat tinggi tentang paralelisme model, deskripsi tentang bagaimana hal itu dapat membantu mengatasi masalah yang muncul saat melatih model DL yang biasanya berukuran sangat besar, dan contoh apa yang ditawarkan perpustakaan SageMaker paralel model untuk membantu mengelola strategi paralel model serta konsumsi memori.
## Apa itu Paralelisme Model?
Meningkatkan ukuran model pembelajaran mendalam (lapisan dan parameter) menghasilkan akurasi yang lebih baik untuk tugas-tugas kompleks seperti visi komputer dan pemrosesan bahasa alami. Namun, ada batasan untuk ukuran model maksimum yang dapat Anda muat dalam memori satu GPU. Saat melatih model DL, batasan memori GPU dapat menjadi hambatan dengan cara berikut:
+ Mereka membatasi ukuran model yang dapat Anda latih, karena jejak memori model berskala proporsional dengan jumlah parameter.
+ Mereka membatasi ukuran batch per GPU selama pelatihan, menurunkan pemanfaatan GPU dan efisiensi pelatihan.
Untuk mengatasi keterbatasan yang terkait dengan pelatihan model pada satu GPU, SageMaker sediakan pustaka paralel model untuk membantu mendistribusikan dan melatih model DL secara efisien pada beberapa node komputasi. Selain itu, dengan perpustakaan, Anda dapat mencapai pelatihan terdistribusi yang paling dioptimalkan menggunakan perangkat yang didukung EFA, yang meningkatkan kinerja komunikasi antar-node dengan latensi rendah, throughput tinggi, dan bypass OS.
## Perkirakan Persyaratan Memori Sebelum Menggunakan Paralelisme Model
Sebelum Anda menggunakan perpustakaan paralel SageMaker model, pertimbangkan hal berikut untuk memahami persyaratan memori untuk melatih model DL besar.
Untuk pekerjaan pelatihan yang menggunakan pengoptimal AMP (FP16) dan Adam, memori GPU yang diperlukan per parameter adalah sekitar 20 byte, yang dapat kami uraikan sebagai berikut:
+ FP16 Parameter \$1 2 byte
+ FP16 Gradien \$1 2 byte
+ Status FP32 pengoptimal \$1 8 byte berdasarkan pengoptimal Adam
+ FP32 Salinan parameter \$1 4 byte (diperlukan untuk operasi `optimizer apply` (OA))
+ FP32 Salinan gradien \$1 4 byte (diperlukan untuk operasi OA)
Bahkan untuk model DL yang relatif kecil dengan 10 miliar parameter, dapat memerlukan setidaknya 200GB memori, yang jauh lebih besar daripada memori GPU biasa (misalnya, NVIDIA A100 dengan memori 40GB/80GB dan V100 dengan 16/32 GB) tersedia pada satu GPU. Perhatikan bahwa di atas persyaratan memori untuk status model dan pengoptimal, ada konsumen memori lain seperti aktivasi yang dihasilkan dalam pass maju. Memori yang dibutuhkan bisa jauh lebih besar dari 200GB.
Untuk pelatihan terdistribusi, kami menyarankan Anda menggunakan instans Amazon EC2 P3 dan P4 yang masing-masing memiliki NVIDIA V100 dan A100 Tensor Core. GPUs Untuk detail selengkapnya tentang spesifikasi seperti inti CPU, RAM, volume penyimpanan terlampir, dan bandwidth jaringan, lihat bagian *Komputasi Akselerasi* di halaman [Jenis Instans Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
Bahkan dengan instans komputasi yang dipercepat, jelas bahwa model dengan sekitar 10 miliar parameter seperti Megatron-LM dan T5 dan bahkan model yang lebih besar dengan ratusan miliar parameter seperti GPT-3 tidak dapat memuat replika model di setiap perangkat GPU.
## Bagaimana Perpustakaan Menggunakan Paralelisme Model dan Teknik Penghematan Memori
Pustaka terdiri dari berbagai jenis fitur paralelisme model dan fitur hemat memori seperti sharding status pengoptimal, checkpointing aktivasi, dan pembongkaran aktivasi. Semua teknik ini dapat digabungkan untuk melatih model besar secara efisien yang terdiri dari ratusan miliar parameter.
**Topics**
+ [Paralelisme data sharded (tersedia untuk) PyTorch](#model-parallel-intro-sdp)
+ [Paralelisme pipa (tersedia untuk PyTorch dan) TensorFlow](#model-parallel-intro-pp)
+ [Paralelisme tensor (tersedia untuk) PyTorch](#model-parallel-intro-tp)
+ [Sharding status pengoptimal (tersedia untuk) PyTorch](#model-parallel-intro-oss)
+ [Aktivasi pembongkaran dan checkpointing (tersedia untuk) PyTorch](#model-parallel-intro-activation-offloading-checkpointing)
+ [Memilih teknik yang tepat untuk model Anda](#model-parallel-intro-choosing-techniques)
### Paralelisme data sharded (tersedia untuk) PyTorch
*Paralelisme data sharded* adalah teknik pelatihan terdistribusi hemat memori yang membagi keadaan model (parameter model, gradien, dan status pengoptimal) di dalam grup data-paralel. GPUs
SageMaker [AI mengimplementasikan paralelisme data yang dibagikan melalui implementasi MIC, yang merupakan perpustakaan yang **mi** nimizes **c** ommunication **s** cale dan dibahas dalam posting blog penskalaan hampir linier dari pelatihan model raksasa pada. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws)
Anda dapat menerapkan paralelisme data sharded ke model Anda sebagai strategi yang berdiri sendiri. Selain itu, jika Anda menggunakan instans GPU paling berkinerja yang dilengkapi dengan NVIDIA A100 Tensor Core GPUs`ml.p4d.24xlarge`, Anda dapat memanfaatkan peningkatan kecepatan pelatihan dari `AllGather` operasi yang ditawarkan oleh SMDDP Collectives.
Untuk menyelam jauh ke dalam paralelisme data sharded dan mempelajari cara mengaturnya atau menggunakan kombinasi paralelisme data sharded dengan teknik lain seperti paralelisme tensor dan pelatihan, lihat. FP16 [Paralelisme Data Sharded](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
### Paralelisme pipa (tersedia untuk PyTorch dan) TensorFlow
*Paralelisme pipa* mempartisi kumpulan lapisan atau operasi di seluruh rangkaian perangkat, membiarkan setiap operasi tetap utuh. Ketika Anda menentukan nilai untuk jumlah partisi model (`pipeline_parallel_degree`), jumlah total GPUs (`processes_per_host`) harus habis dibagi dengan jumlah partisi model. Untuk mengatur ini dengan benar, Anda harus menentukan nilai yang benar untuk `pipeline_parallel_degree` dan `processes_per_host` parameter. Matematika sederhana adalah sebagai berikut:
```
(pipeline_parallel_degree) x (data_parallel_degree) = processes_per_host
```
Pustaka menangani penghitungan jumlah replika model (juga disebut`data_parallel_degree`) mengingat dua parameter input yang Anda berikan.
Misalnya, jika Anda menyetel `"pipeline_parallel_degree": 2` dan `"processes_per_host": 8` menggunakan instance ML dengan delapan pekerja GPU seperti`ml.p3.16xlarge`, pustaka akan secara otomatis menyiapkan model terdistribusi di seluruh paralelisme data empat arah GPUs dan empat arah. Gambar berikut menggambarkan bagaimana model didistribusikan di delapan GPUs mencapai paralelisme data empat arah dan paralelisme pipa dua arah. Setiap replika model, di mana kita mendefinisikannya sebagai *grup paralel pipa* dan memberi label sebagai`PP_GROUP`, dipartisi menjadi dua. GPUs Setiap partisi model ditetapkan ke empat GPUs, di mana empat replika partisi berada dalam *grup paralel data* dan diberi label sebagai. `DP_GROUP` Tanpa paralelisme tensor, grup paralel pipa pada dasarnya adalah kelompok paralel model.
![\[Bagaimana sebuah model didistribusikan di delapan GPUs mencapai paralelisme data empat arah dan paralelisme pipa dua arah.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-pipeline-parallel-only.png)
Untuk menyelam jauh ke dalam paralelisme pipa, lihat. [Fitur Inti dari Perpustakaan Paralelisme SageMaker Model](model-parallel-core-features.md)
Untuk memulai menjalankan model menggunakan paralelisme pipeline, lihat [Menjalankan Job Pelatihan SageMaker Terdistribusi dengan Perpustakaan Paralel SageMaker Model](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html).
### Paralelisme tensor (tersedia untuk) PyTorch
*Paralelisme tensor* membagi lapisan individu, atau, di seluruh perangkat`nn.Modules`, untuk dijalankan secara paralel. Gambar berikut menunjukkan contoh paling sederhana tentang bagaimana perpustakaan membagi model dengan empat lapisan untuk mencapai paralelisme tensor dua arah (). `"tensor_parallel_degree": 2` Lapisan setiap replika model dibagi dua dan didistribusikan menjadi dua. GPUs Dalam contoh kasus ini, konfigurasi paralel model juga mencakup `"pipeline_parallel_degree": 1` dan `"ddp": True` (menggunakan PyTorch DistributedDataParallel paket di latar belakang), sehingga tingkat paralelisme data menjadi delapan. Perpustakaan mengelola komunikasi di seluruh replika model terdistribusi tensor.
![\[Contoh paling sederhana tentang bagaimana perpustakaan membagi model dengan empat lapisan untuk mencapai paralelisme tensor dua arah (). "tensor_parallel_degree": 2\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-tensor-parallel-only.png)
Kegunaan fitur ini adalah kenyataan bahwa Anda dapat memilih lapisan tertentu atau subset lapisan untuk menerapkan paralelisme tensor. Untuk menyelam jauh ke dalam paralelisme tensor dan fitur hemat memori lainnya untuk PyTorch, dan untuk mempelajari cara mengatur kombinasi paralelisme pipa dan tensor, lihat. [Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md)
### Sharding status pengoptimal (tersedia untuk) PyTorch
Untuk memahami bagaimana pustaka melakukan *sharding status pengoptimal*, pertimbangkan contoh model sederhana dengan empat lapisan. Ide kunci dalam mengoptimalkan sharding status adalah Anda tidak perlu mereplikasi status pengoptimal Anda di semua status pengoptimal Anda. GPUs Sebagai gantinya, satu replika status pengoptimal dibagi di seluruh peringkat paralel data, tanpa redundansi di seluruh perangkat. Misalnya, GPU 0 memegang status pengoptimal untuk lapisan satu, GPU 1 berikutnya memegang status pengoptimal untuk L2, dan seterusnya. Gambar animasi berikut menunjukkan propagasi mundur dengan teknik sharding status pengoptimal. Di akhir propagasi mundur, ada waktu komputasi dan jaringan untuk operasi `optimizer apply` (OA) untuk memperbarui status pengoptimal dan operasi `all-gather` (AG) untuk memperbarui parameter model untuk iterasi berikutnya. Yang terpenting, `reduce` operasi dapat tumpang tindih dengan komputasi pada GPU 0, menghasilkan propagasi mundur yang lebih efisien memori dan lebih cepat. Dalam implementasi saat ini, operasi AG dan OA tidak tumpang tindih dengan`compute`. Ini dapat menghasilkan perhitungan yang diperpanjang selama operasi AG, jadi mungkin ada tradeoff.
![\[Propagasi mundur dengan teknik sharding status pengoptimal.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-optimizer-state-sharding.gif)
Untuk informasi selengkapnya tentang cara menggunakan fitur ini, lihat [Sharding Status Optimizer](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-optimizer-state-sharding.html).
### Aktivasi pembongkaran dan checkpointing (tersedia untuk) PyTorch
Untuk menyimpan memori GPU, pustaka mendukung checkpointing aktivasi untuk menghindari penyimpanan aktivasi internal dalam memori GPU untuk modul yang ditentukan pengguna selama forward pass. Pustaka menghitung ulang aktivasi ini selama pass mundur. Selain itu, fitur pembongkaran aktivasi menurunkan aktivasi yang disimpan ke memori CPU dan mengambil kembali ke GPU selama lintasan mundur untuk lebih mengurangi jejak memori aktivasi. Untuk informasi selengkapnya tentang cara menggunakan fitur ini, lihat [Pos Pemeriksaan Aktivasi dan Pembongkaran](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-checkpointing.html) [Aktivasi](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-offloading.html).
### Memilih teknik yang tepat untuk model Anda
Untuk informasi selengkapnya tentang memilih teknik dan konfigurasi yang tepat, lihat [Praktik Terbaik Paralel Model SageMaker Terdistribusi](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-best-practices.html) dan [Tips dan Perangkap Konfigurasi](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-tips-pitfalls.html).
# Kerangka Kerja yang Didukung dan Wilayah AWS
Sebelum menggunakan pustaka paralelisme SageMaker model, periksa kerangka kerja dan jenis instance yang didukung, dan tentukan apakah ada cukup kuota di akun Anda dan. AWS Wilayah AWS
**catatan**
Untuk memeriksa pembaruan terbaru dan catatan rilis perpustakaan, lihat [Catatan Rilis Paralel SageMaker Model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) dalam dokumentasi *SageMaker Python SDK*.
## Kerangka Kerja yang Didukung
Pustaka paralelisme SageMaker model mendukung kerangka pembelajaran mendalam berikut dan tersedia dalam AWS Deep Learning Containers (DLC) atau dapat diunduh sebagai file biner.
PyTorch versi yang didukung oleh SageMaker AI dan perpustakaan paralelisme SageMaker model
| PyTorch versi | SageMaker model versi perpustakaan paralelisme | `smdistributed-modelparallel`URI gambar DLC terintegrasi | URL dari file biner\$1\$1 |
| --- | --- | --- | --- |
| v2.0.0 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-2.0.0/bangunan-artefak/2023-04-14-20-14/smdistributed\$1modelparallel-1.15.0-cp310-cp310-linux\$1x86\$164.whl |
| v1.13.1 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.13.1/bangunan-artefak/2023-04-17-15-49/smdistributed\$1modelparallel-1.15.0-cp39-cp39-linux\$1x86\$164.whl |
| v1.12.1 | smdistributed-modelparallel==v1.13.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.1/bangunan-artefak/2022-12-08-21-34/smdistributed\$1modelparallel-1.13.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.12.0 | smdistributed-modelparallel==v1.11.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.0/bangunan-artefak/2022-08-12-16-58/smdistributed\$1modelparallel-1.11.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.11.0 | smdistributed-modelparallel==v1.10.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.11.0/bangunan-artefak/2022-07-11-19-23/smdistributed\$1modelparallel-1.10.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.10.2 | smdistributed-modelparallel==v1.7.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.2-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.10.0 | smdistributed-modelparallel==v1.5.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.9.1 | smdistributed-modelparallel==v1.4.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.9.1-gpu-py38-cu111-ubuntu20.04` | - |
| v1.8.1\$1 | smdistributed-modelparallel==v1.6.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.8.1-gpu-py36-cu111-ubuntu18.04` | - |
**catatan**
Pustaka paralelisme SageMaker model v1.6.0 dan yang lebih baru menyediakan fitur tambahan untuk. PyTorch Untuk informasi selengkapnya, lihat [Fitur Inti dari Perpustakaan Paralelisme SageMaker Model](model-parallel-core-features.md).
\$1\$1 File biner adalah untuk menginstal pustaka paralelisme SageMaker model dalam wadah khusus. URLs Untuk informasi selengkapnya, lihat [Buat Container Docker Anda Sendiri dengan Perpustakaan Paralel Model SageMaker Terdistribusi](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container).
TensorFlow versi yang didukung oleh SageMaker AI dan perpustakaan paralelisme SageMaker model
| TensorFlow versi | SageMaker model versi perpustakaan paralelisme | `smdistributed-modelparallel`URI gambar DLC terintegrasi |
| --- | --- | --- |
| v2.6.0 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.6.0-gpu-py38-cu112-ubuntu20.04 |
| v2.5.1 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.5.1-gpu-py37-cu112-ubuntu18.04 |
**Versi Hugging Face Transformers didukung SageMaker oleh AI dan perpustakaan paralel data SageMaker terdistribusi**
AWS Deep Learning Containers untuk Hugging Face menggunakan SageMaker Wadah Pelatihan PyTorch untuk TensorFlow dan sebagai gambar dasarnya. [Untuk mencari versi pustaka Hugging Face Transformers dan PyTorch dipasangkan TensorFlow dan versi, lihat Wadah Wajah Pelukan terbaru [dan Versi Wadah Wajah Pelukan](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) Sebelumnya.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions)
## Wilayah AWS
Pustaka paralel SageMaker data tersedia di semua Wilayah AWS tempat [AWS Deep Learning Containers SageMaker](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) berada dalam layanan. Untuk informasi selengkapnya, lihat [Gambar Deep Learning Containers yang Tersedia](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#available-deep-learning-containers-images).
## Tipe Instans Yang Didukung
Pustaka paralelisme SageMaker model memerlukan salah satu jenis instance ML berikut.
| Tipe instans |
| --- |
| ml.g4dn.12xlarge |
| ml.p3.16xlarge |
| ml.p3dn.24xlarge |
| ml.p4d.24xlarge |
| ml.p4de.24xlarge |
Untuk spesifikasi jenis instans, lihat bagian **Komputasi Akselerasi** di halaman Jenis [Instans Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Untuk informasi tentang harga instans, lihat [Harga Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/).
Jika Anda menemukan pesan kesalahan yang mirip dengan berikut ini, ikuti petunjuk di [Minta peningkatan kuota layanan untuk sumber daya SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure).
```
ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling
the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge
for training job usage' is 0 Instances, with current utilization of 0 Instances
and a request delta of 1 Instances.
Please contact AWS support to request an increase for this limit.
```
# Fitur Inti dari Perpustakaan Paralelisme SageMaker Model
Pustaka paralelisme model Amazon SageMaker AI menawarkan strategi distribusi dan teknik penghematan memori, seperti paralelisme data sharded, paralelisme tensor, partisi model berdasarkan lapisan untuk penjadwalan pipa, dan pos pemeriksaan. Strategi dan teknik paralelisme model membantu mendistribusikan model besar di beberapa perangkat sambil mengoptimalkan kecepatan pelatihan dan konsumsi memori. Pustaka juga menyediakan fungsi pembantu Python, manajer konteks, dan fungsi pembungkus untuk mengadaptasi skrip pelatihan Anda untuk partisi otomatis atau manual model Anda.
Saat Anda menerapkan paralelisme model ke pekerjaan pelatihan Anda, Anda mempertahankan alur kerja dua langkah yang sama yang ditunjukkan di bagian [Jalankan Pekerjaan SageMaker Pelatihan Terdistribusi dengan](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) Paralelisme Model. Untuk mengadaptasi skrip pelatihan Anda, Anda akan menambahkan nol atau beberapa baris kode tambahan ke skrip pelatihan Anda. Untuk meluncurkan tugas pelatihan skrip pelatihan yang disesuaikan, Anda harus mengatur parameter konfigurasi distribusi untuk mengaktifkan fitur hemat memori atau untuk meneruskan nilai untuk tingkat paralelisme.
Untuk memulai dengan contoh, lihat buku catatan Jupyter berikut yang menunjukkan cara menggunakan pustaka paralelisme SageMaker model.
+ [PyTorch contoh notebook](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel)
+ [TensorFlow contoh notebook](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist)
Untuk menyelam jauh ke dalam fitur inti perpustakaan, lihat topik berikut.
**catatan**
Perpustakaan pelatihan SageMaker terdistribusi tersedia melalui wadah pembelajaran AWS mendalam untuk PyTorch, Hugging Face, dan TensorFlow dalam platform SageMaker Pelatihan. Untuk memanfaatkan fitur perpustakaan pelatihan terdistribusi, kami sarankan Anda menggunakan Python SageMaker SDK. Anda juga dapat mengkonfigurasi secara manual dalam sintaks permintaan JSON jika Anda menggunakan SageMaker APIs melalui SDK for Python (Boto3) atau. AWS Command Line Interface Sepanjang dokumentasi, instruksi dan contoh berfokus pada cara menggunakan pustaka pelatihan terdistribusi dengan SageMaker Python SDK.
**penting**
Pustaka paralelisme SageMaker model mendukung semua fitur inti untuk PyTorch, dan mendukung paralelisme pipa untuk. TensorFlow
**Topics**
+ [Paralelisme Data Sharded](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
+ [Pipelining Model](model-parallel-core-features-pipieline-parallelism.md)
+ [Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ [Sharding Status Optimizer](model-parallel-extended-features-pytorch-optimizer-state-sharding.md)
+ [Aktivasi Checkpointing](model-parallel-extended-features-pytorch-activation-checkpointing.md)
+ [Pembongkaran Aktivasi](model-parallel-extended-features-pytorch-activation-offloading.md)
+ [FP16 Pelatihan dengan Model Paralelisme](model-parallel-extended-features-pytorch-fp16.md)
+ [Support untuk FlashAttention](model-parallel-attention-head-size-for-flash-attention.md)
# Paralelisme Data Sharded
*Paralelisme data sharded* adalah teknik pelatihan terdistribusi hemat memori yang membagi status model (parameter model, gradien, dan status pengoptimal) di dalam grup paralel data. GPUs
**catatan**
Paralelisme data sharded tersedia untuk PyTorch di pustaka paralelisme SageMaker model v1.11.0 dan yang lebih baru.
Saat meningkatkan pekerjaan pelatihan Anda ke cluster GPU besar, Anda dapat mengurangi jejak memori per-GPU model dengan membagi status pelatihan model ke beberapa. GPUs Ini mengembalikan dua manfaat: Anda dapat memasukkan model yang lebih besar, yang jika tidak akan kehabisan memori dengan paralelisme data standar, atau Anda dapat meningkatkan ukuran batch menggunakan memori GPU yang dibebaskan.
Teknik paralelisme data standar mereplikasi status pelatihan di seluruh grup paralel data, dan melakukan agregasi gradien berdasarkan operasi. GPUs `AllReduce` Paralelisme data sharded memodifikasi prosedur pelatihan terdistribusi data-paralel standar untuk memperhitungkan sifat sharded dari status pengoptimal. Sekelompok peringkat di mana status model dan pengoptimal dipecah disebut grup *sharding*. *Teknik paralelisme data sharded memecah parameter model yang dapat dilatih dan gradien serta status pengoptimal yang sesuai di seluruh dalam grup sharding. GPUs *
SageMaker AI mencapai paralelisme data yang dibagi melalui implementasi MIC, yang dibahas dalam posting AWS blog Penskalaan [hampir](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) linier dari pelatihan model raksasa. AWS Dalam implementasi ini, Anda dapat mengatur derajat sharding sebagai parameter yang dapat dikonfigurasi, yang harus kurang dari tingkat paralelisme data. Selama setiap lintasan maju dan mundur, MIC untuk sementara menggabungkan kembali parameter model di seluruh GPUs operasi. `AllGather` Setelah pass maju atau mundur dari setiap lapisan, MIC memecah parameter lagi untuk menghemat memori GPU. Selama lintasan mundur, MIC mengurangi gradien dan secara bersamaan memecahnya melalui operasi. GPUs `ReduceScatter` Terakhir, MIC menerapkan gradien lokal tereduksi dan sharded ke pecahan parameter lokal yang sesuai, menggunakan pecahan lokal status pengoptimal. Untuk menurunkan overhead komunikasi, pustaka paralelisme SageMaker model mengambil lapisan yang akan datang di pass maju atau mundur, dan tumpang tindih komunikasi jaringan dengan komputasi.
Status pelatihan model direplikasi di seluruh kelompok sharding. Ini berarti bahwa sebelum gradien diterapkan pada parameter, `AllReduce` operasi harus dilakukan di seluruh kelompok sharding, selain `ReduceScatter` operasi yang terjadi dalam grup sharding.
Akibatnya, paralelisme data sharded memperkenalkan tradeoff antara overhead komunikasi dan efisiensi memori GPU. Menggunakan paralelisme data sharded meningkatkan biaya komunikasi, tetapi jejak memori per GPU (tidak termasuk penggunaan memori karena aktivasi) dibagi dengan tingkat paralelisme data sharded, sehingga model yang lebih besar dapat dimasukkan ke dalam cluster GPU.
**Memilih tingkat paralelisme data sharded**
Ketika Anda memilih nilai untuk tingkat paralelisme data sharded, nilai harus membagi derajat paralelisme data secara merata. Misalnya, untuk pekerjaan paralelisme data 8 arah, pilih 2, 4, atau 8 untuk tingkat paralelisme data sharded. Saat memilih tingkat paralelisme data yang dibagikan, kami menyarankan Anda memulai dengan jumlah kecil, dan secara bertahap meningkatkannya hingga model sesuai dengan memori bersama dengan ukuran batch yang diinginkan.
**Memilih ukuran batch**
Setelah menyiapkan paralelisme data sharded, pastikan Anda menemukan konfigurasi pelatihan paling optimal yang berhasil dijalankan di cluster GPU. Untuk melatih model bahasa besar (LLM), mulai dari ukuran batch 1, dan secara bertahap tingkatkan hingga Anda mencapai titik untuk menerima kesalahan out-of-memory (OOM). Jika Anda menemukan kesalahan OOM bahkan dengan ukuran batch terkecil, terapkan tingkat paralelisme data sharded yang lebih tinggi atau kombinasi paralelisme data sharded dan paralelisme tensor.
**Topics**
+ [Cara menerapkan paralelisme data sharded ke pekerjaan pelatihan Anda](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
+ [Konfigurasi referensi](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample)
+ [Paralelisme data sharded dengan SMDDP Collectives](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives)
+ [Pelatihan presisi campuran dengan paralelisme data sharded](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training)
+ [Paralelisme data sharded dengan paralelisme tensor](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism)
+ [Kiat dan pertimbangan untuk menggunakan paralelisme data sharded](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations)
## Cara menerapkan paralelisme data sharded ke pekerjaan pelatihan Anda
Untuk memulai paralelisme data sharded, terapkan modifikasi yang diperlukan pada skrip pelatihan Anda, dan atur SageMaker PyTorch estimator dengan parameter. sharded-data-parallelism-specific Pertimbangkan juga untuk mengambil nilai referensi dan contoh notebook sebagai titik awal.
### Sesuaikan skrip PyTorch pelatihan Anda
Ikuti instruksi di [Langkah 1: Ubah Skrip PyTorch Pelatihan](model-parallel-customize-training-script-pt.md) untuk membungkus objek model dan pengoptimal dengan `smdistributed.modelparallel.torch` pembungkus modul `torch.nn.parallel` dan`torch.distributed`.
**(Opsional) Modifikasi tambahan untuk mendaftarkan parameter model eksternal**
Jika model Anda dibangun dengan `torch.nn.Module` dan menggunakan parameter yang tidak ditentukan dalam kelas modul, Anda harus mendaftarkannya ke modul secara manual untuk SMP untuk mengumpulkan parameter penuh sementara. Untuk mendaftarkan parameter ke modul, gunakan`smp.register_parameter(module, parameter)`.
```
class Module(torch.nn.Module):
def __init__(self, *args):
super().__init__(self, *args)
self.layer1 = Layer1()
self.layer2 = Layer2()
smp.register_parameter(self, self.layer1.weight)
def forward(self, input):
x = self.layer1(input)
# self.layer1.weight is required by self.layer2.forward
y = self.layer2(x, self.layer1.weight)
return y
```
### Siapkan SageMaker PyTorch estimator
Saat mengonfigurasi SageMaker PyTorch estimator[Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK](model-parallel-sm-sdk.md), tambahkan parameter untuk paralelisme data sharded.
Untuk mengaktifkan paralelisme data sharded, tambahkan `sharded_data_parallel_degree` parameter ke Estimator. SageMaker PyTorch Parameter ini menentukan jumlah GPUs di mana status pelatihan dipecah. Nilai untuk `sharded_data_parallel_degree` harus berupa bilangan bulat antara satu dan derajat paralelisme data dan harus membagi derajat paralelisme data secara merata. Perhatikan bahwa pustaka secara otomatis mendeteksi jumlah GPUs sehingga tingkat paralel data. Parameter tambahan berikut tersedia untuk mengonfigurasi paralelisme data sharded.
+ `"sdp_reduce_bucket_size"`*(int, default: 5e8)* - Menentukan ukuran [ember gradien PyTorch DDP](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) dalam jumlah elemen dtype default.
+ `"sdp_param_persistence_threshold"`*(int, default: 1e6)* — Menentukan ukuran tensor parameter dalam jumlah elemen yang dapat bertahan di setiap GPU. Paralelisme data sharded membagi setiap tensor parameter di seluruh grup paralel data. GPUs Jika jumlah elemen dalam tensor parameter lebih kecil dari ambang batas ini, tensor parameter tidak terbelah; ini membantu mengurangi overhead komunikasi karena tensor parameter direplikasi di seluruh data-paralel. GPUs
+ `"sdp_max_live_parameters"`*(int, default: 1e9)* — Menentukan jumlah maksimum parameter yang secara bersamaan dapat berada dalam keadaan pelatihan rekombinasi selama pass maju dan mundur. Pengambilan parameter dengan `AllGather` operasi berhenti ketika jumlah parameter aktif mencapai ambang batas yang diberikan. Perhatikan bahwa meningkatkan parameter ini meningkatkan jejak memori.
+ `"sdp_hierarchical_allgather"`*(bool, default: True)* - Jika disetel ke`True`, `AllGather` operasi berjalan secara hierarkis: berjalan di dalam setiap node terlebih dahulu, dan kemudian berjalan melintasi node. Untuk pekerjaan pelatihan terdistribusi multi-node, `AllGather` operasi hierarkis diaktifkan secara otomatis.
+ `"sdp_gradient_clipping"`*(float, default: 1.0)* — Menentukan ambang batas untuk gradien memotong norma L2 dari gradien sebelum menyebarkannya mundur melalui parameter model. Ketika paralelisme data sharded diaktifkan, kliping gradien juga diaktifkan. Ambang batas default adalah`1.0`. Sesuaikan parameter ini jika Anda memiliki masalah gradien yang meledak.
Kode berikut menunjukkan contoh cara mengkonfigurasi paralelisme data sharded.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
# "pipeline_parallel_degree": 1, # Optional, default is 1
# "tensor_parallel_degree": 1, # Optional, default is 1
"ddp": True,
# parameters for sharded data parallelism
"sharded_data_parallel_degree": 2, # Add this to activate sharded data parallelism
"sdp_reduce_bucket_size": int(5e8), # Optional
"sdp_param_persistence_threshold": int(1e6), # Optional
"sdp_max_live_parameters": int(1e9), # Optional
"sdp_hierarchical_allgather": True, # Optional
"sdp_gradient_clipping": 1.0 # Optional
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-job"
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Konfigurasi referensi
Tim pelatihan SageMaker terdistribusi menyediakan konfigurasi referensi berikut yang dapat Anda gunakan sebagai titik awal. Anda dapat mengekstrapolasi dari konfigurasi berikut untuk bereksperimen dan memperkirakan penggunaan memori GPU untuk konfigurasi model Anda.
Paralelisme data sharded dengan SMDDP Collectives
| Model/jumlah parameter | Num contoh | Tipe instans | Panjang urutan | Ukuran batch global | Ukuran batch mini | Derajat paralel data sharded |
| --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 |
| GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 |
Misalnya, jika Anda menambah panjang urutan untuk model 20 miliar parameter atau menambah ukuran model menjadi 65 miliar parameter, Anda perlu mencoba mengurangi ukuran batch terlebih dahulu. Jika model masih tidak sesuai dengan ukuran batch terkecil (ukuran batch 1), coba tingkatkan derajat paralelisme model.
Paralelisme data sharded dengan paralelisme tensor dan NCCL Collectives
| Model/jumlah parameter | Num contoh | Tipe instans | Panjang urutan | Ukuran batch global | Ukuran batch mini | Derajat paralel data sharded | Derajat paralel tensor | Pembongkaran aktivasi |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | Y |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | Y |
Penggunaan gabungan paralelisme data sharded dan paralelisme tensor berguna ketika Anda ingin memasukkan model bahasa besar (LLM) ke dalam cluster skala besar saat menggunakan data teks dengan panjang urutan yang lebih panjang, yang mengarah pada penggunaan ukuran batch yang lebih kecil, dan akibatnya menangani penggunaan memori GPU untuk melatih urutan teks yang lebih panjang. LLMs Untuk mempelajari selengkapnya, lihat [Paralelisme data sharded dengan paralelisme tensor](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
Untuk studi kasus, tolok ukur, dan contoh konfigurasi lainnya, lihat posting blog [Peningkatan kinerja baru di perpustakaan paralel model Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
## Paralelisme data sharded dengan SMDDP Collectives
Perpustakaan paralelisme SageMaker data menawarkan primitif komunikasi kolektif (kolektif SMDDP) yang dioptimalkan untuk infrastruktur. AWS Ini mencapai optimasi dengan mengadopsi pola all-to-all-type komunikasi dengan memanfaatkan [Elastic Fabric Adapter (](https://aws.amazon.com/hpc/efa/)EFA), menghasilkan throughput tinggi dan kolektif yang kurang sensitif terhadap latensi, menurunkan pemrosesan terkait komunikasi ke CPU, dan membebaskan siklus GPU untuk komputasi. Pada cluster besar, SMDDP Collectives dapat menawarkan peningkatan kinerja pelatihan terdistribusi hingga 40% dibandingkan dengan NCCL. Untuk studi kasus dan hasil benchmark, lihat blog [Peningkatan kinerja baru di perpustakaan paralelisme model Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
**catatan**
Paralelisme data sharded dengan SMDDP Collectives tersedia di perpustakaan paralelisme SageMaker model v1.13.0 dan yang lebih baru, dan perpustakaan paralelisme data v1.6.0 dan yang lebih baru. SageMaker Lihat juga [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) untuk menggunakan paralelisme data sharded dengan SMDDP Collectives.
Dalam paralelisme data sharded, yang merupakan teknik yang umum digunakan dalam pelatihan terdistribusi skala besar, `AllGather` kolektif digunakan untuk menyusun kembali parameter lapisan sharded untuk komputasi pass maju dan mundur, secara paralel dengan komputasi GPU. Untuk model besar, melakukan `AllGather` operasi secara efisien sangat penting untuk menghindari masalah kemacetan GPU dan memperlambat kecepatan pelatihan. Ketika paralelisme data sharded diaktifkan, SMDDP Collectives masuk ke dalam kolektif kritis kinerja `AllGather` ini, meningkatkan throughput pelatihan.
**Berlatih dengan SMDDP Collectives**
Ketika pekerjaan pelatihan Anda telah berbagi paralelisme data diaktifkan dan memenuhi[Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), SMDDP Collectives diaktifkan secara otomatis. Secara internal, SMDDP Collectives mengoptimalkan `AllGather` kolektif untuk berkinerja pada AWS infrastruktur dan kembali ke NCCL untuk semua kolektif lainnya. Selanjutnya, di bawah konfigurasi yang tidak didukung, semua kolektif, termasuk`AllGather`, secara otomatis menggunakan backend NCCL.
Karena pustaka paralelisme SageMaker model versi 1.13.0, `"ddp_dist_backend"` parameter ditambahkan ke opsi. `modelparallel` Nilai default untuk parameter konfigurasi ini adalah`"auto"`, yang menggunakan SMDDP Collectives bila memungkinkan, dan kembali ke NCCL sebaliknya. Untuk memaksa perpustakaan untuk selalu menggunakan NCCL, tentukan `"nccl"` ke parameter `"ddp_dist_backend"` konfigurasi.
Contoh kode berikut menunjukkan cara mengatur PyTorch estimator menggunakan paralelisme data sharded dengan `"ddp_dist_backend"` parameter, yang diatur ke default dan, `"auto"` oleh karena itu, opsional untuk ditambahkan.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": {
"partitions": 1,
"ddp": True,
"sharded_data_parallel_degree": 64
"bf16": True,
"ddp_dist_backend": "auto" # Specify "nccl" to force to use NCCL.
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Konfigurasi yang didukung**
`AllGather`Operasi dengan SMDDP Collectives diaktifkan dalam pekerjaan pelatihan ketika semua persyaratan konfigurasi berikut terpenuhi.
+ Tingkat paralelisme data sharded lebih besar dari 1
+ `Instance_count`lebih besar dari 1
+ `Instance_type`sama dengan `ml.p4d.24xlarge`
+ SageMaker wadah pelatihan untuk PyTorch v1.12.1 atau yang lebih baru
+ Pustaka paralelisme SageMaker data v1.6.0 atau yang lebih baru
+ Pustaka paralelisme SageMaker model v1.13.0 atau yang lebih baru
**Kinerja dan penyetelan memori**
SMDDP Collectives menggunakan memori GPU tambahan. Ada dua variabel lingkungan untuk mengonfigurasi penggunaan memori GPU tergantung pada kasus penggunaan pelatihan model yang berbeda.
+ `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`— Selama `AllGather` operasi SMDDP, buffer `AllGather` input disalin ke buffer sementara untuk komunikasi antar simpul. `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`Variabel mengontrol ukuran (dalam byte) dari buffer sementara ini. Jika ukuran buffer sementara lebih kecil dari ukuran buffer `AllGather` input, `AllGather` kolektif akan kembali menggunakan NCCL.
+ Nilai default: 16 \$1 1024 \$1 1024 (16 MB)
+ Nilai yang dapat diterima: kelipatan 8192
+ `SMDDP_AG_SORT_BUFFER_SIZE_BYTES``SMDDP_AG_SORT_BUFFER_SIZE_BYTES`Variabelnya adalah untuk mengukur buffer sementara (dalam byte) untuk menyimpan data yang dikumpulkan dari komunikasi antar simpul. Jika ukuran buffer sementara ini lebih kecil dari`1/8 * sharded_data_parallel_degree * AllGather input size`, `AllGather` kolektif akan kembali menggunakan NCCL.
+ Nilai default: 128 \$1 1024 \$1 1024 (128 MB)
+ Nilai yang dapat diterima: kelipatan 8192
**Panduan penyetelan pada variabel ukuran buffer**
Nilai default untuk variabel lingkungan harus berfungsi dengan baik untuk sebagian besar kasus penggunaan. Kami merekomendasikan untuk menyetel variabel-variabel ini hanya jika pelatihan mengalami kesalahan out-of-memory (OOM).
Daftar berikut membahas beberapa tips penyetelan untuk mengurangi jejak memori GPU SMDDP Collectives sambil mempertahankan keuntungan kinerja dari mereka.
+ Penyetelan `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`
+ Ukuran buffer `AllGather` input lebih kecil untuk model yang lebih kecil. Oleh karena itu, ukuran yang diperlukan untuk `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` bisa lebih kecil untuk model dengan parameter lebih sedikit.
+ Ukuran buffer `AllGather` input berkurang seiring `sharded_data_parallel_degree` bertambahnya, karena model akan lebih banyak dipecah. GPUs Oleh karena itu, ukuran yang diperlukan untuk `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` bisa lebih kecil untuk pekerjaan pelatihan dengan nilai besar untuk`sharded_data_parallel_degree`.
+ Penyetelan `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`
+ Jumlah data yang dikumpulkan dari komunikasi antar simpul lebih sedikit untuk model dengan parameter yang lebih sedikit. Oleh karena itu, ukuran yang diperlukan untuk `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` bisa lebih kecil untuk model tersebut dengan jumlah parameter yang lebih sedikit.
Beberapa kolektif mungkin kembali menggunakan NCCL; karenanya, Anda mungkin tidak mendapatkan keuntungan kinerja dari kolektif SMDDP yang dioptimalkan. Jika memori GPU tambahan tersedia untuk digunakan, Anda dapat mempertimbangkan untuk meningkatkan nilai `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` dan `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` untuk mendapatkan keuntungan dari peningkatan kinerja.
Kode berikut menunjukkan bagaimana Anda dapat mengkonfigurasi variabel lingkungan dengan menambahkannya ke `mpi_options` dalam parameter distribusi untuk PyTorch estimator.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
.... # All modelparallel configuration options go here
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192"
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo-with-tuning",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Pelatihan presisi campuran dengan paralelisme data sharded
Untuk lebih menghemat memori GPU dengan angka floating point setengah presisi dan paralelisme data sharded, Anda dapat mengaktifkan format floating point 16-bit (FP16) atau [Brain floating point format](https://en.wikichip.org/wiki/brain_floating-point_format) (BF16) dengan menambahkan satu parameter tambahan ke konfigurasi pelatihan terdistribusi.
**catatan**
Pelatihan presisi campuran dengan paralelisme data sharded tersedia di perpustakaan paralelisme SageMaker model v1.11.0 dan yang lebih baru.
**Untuk FP16 Pelatihan dengan Paralelisme Data Sharded**
Untuk menjalankan FP16 pelatihan dengan paralelisme data sharded, tambahkan `"fp16": True"` ke kamus konfigurasi. `smp_options` Dalam skrip pelatihan Anda, Anda dapat memilih antara opsi penskalaan kerugian statis dan dinamis melalui `smp.DistributedOptimizer` modul. Untuk informasi selengkapnya, lihat [FP16 Pelatihan dengan Model Paralelisme](model-parallel-extended-features-pytorch-fp16.md).
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"fp16": True
}
}
```
**Untuk BF16 Pelatihan dengan Paralelisme Data Sharded**
Fitur paralelisme data sharded SageMaker AI mendukung pelatihan tipe data. BF16 Tipe BF16 data menggunakan 8 bit untuk mewakili eksponen nomor floating point, sedangkan tipe FP16 data menggunakan 5 bit. Mempertahankan 8 bit untuk eksponen memungkinkan untuk mempertahankan representasi yang sama dari eksponen nomor floating point () presisi tunggal 32-bit. FP32 Hal ini membuat konversi antara FP32 dan BF16 lebih sederhana dan secara signifikan kurang rentan menyebabkan masalah overflow dan underflow yang sering muncul dalam FP16 pelatihan, terutama saat melatih model yang lebih besar. Sementara kedua tipe data menggunakan total 16 bit, rentang representasi yang meningkat untuk eksponen dalam BF16 format ini mengorbankan presisi yang berkurang. Untuk melatih model besar, presisi yang berkurang ini sering dianggap sebagai trade-off yang dapat diterima untuk jangkauan dan stabilitas pelatihan.
**catatan**
Saat ini, BF16 pelatihan hanya berfungsi ketika paralelisme data sharded diaktifkan.
Untuk menjalankan BF16 pelatihan dengan paralelisme data sharded, tambahkan `"bf16": True` ke kamus konfigurasi. `smp_options`
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"bf16": True
}
}
```
## Paralelisme data sharded dengan paralelisme tensor
Jika Anda menggunakan paralelisme data sharded dan juga perlu mengurangi ukuran batch global, pertimbangkan untuk menggunakan paralelisme [tensor dengan paralelisme](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) data sharded. Saat melatih model besar dengan paralelisme data sharded pada cluster komputasi yang sangat besar (biasanya 128 node atau lebih), bahkan ukuran batch kecil per GPU menghasilkan ukuran batch global yang sangat besar. Ini mungkin menyebabkan masalah konvergensi atau masalah kinerja komputasi yang rendah. Mengurangi ukuran batch per GPU terkadang tidak dimungkinkan dengan paralelisme data sharded saja ketika satu batch sudah besar dan tidak dapat dikurangi lebih lanjut. Dalam kasus seperti itu, menggunakan paralelisme data sharded dalam kombinasi dengan paralelisme tensor membantu mengurangi ukuran batch global.
Memilih paralel data sharded optimal dan derajat paralel tensor bergantung pada skala model, jenis instance, dan ukuran batch global yang masuk akal untuk model untuk bertemu. Kami menyarankan Anda memulai dari derajat paralel tensor rendah agar sesuai dengan ukuran batch global ke dalam cluster komputasi untuk mengatasi out-of-memory kesalahan CUDA dan mencapai kinerja terbaik. Lihat dua contoh kasus berikut untuk mempelajari bagaimana kombinasi paralelisme tensor dan paralelisme data sharded membantu Anda menyesuaikan ukuran batch global dengan mengelompokkan GPUs paralelisme model, menghasilkan jumlah replika model yang lebih rendah dan ukuran batch global yang lebih kecil.
**catatan**
Fitur ini tersedia dari pustaka paralelisme SageMaker model v1.15, dan mendukung v1.13.1. PyTorch
**catatan**
Fitur ini tersedia untuk model yang didukung oleh fungsionalitas paralelisme tensor perpustakaan. Untuk menemukan daftar model yang didukung, lihat [Support for Hugging Face Transformer](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html) Models. Perhatikan juga bahwa Anda harus `tensor_parallelism=True` meneruskan `smp.model_creation` argumen sambil memodifikasi skrip pelatihan Anda. Untuk mempelajari lebih lanjut, lihat skrip pelatihan [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)di * GitHub repositori Contoh SageMaker AI*.
### Contoh 1
Asumsikan bahwa kita ingin melatih model di atas cluster 1536 GPUs (192 node dengan masing-masing 8 GPUs ), mengatur tingkat paralelisme data sharded menjadi 32 (`sharded_data_parallel_degree=32`) dan ukuran batch per GPU menjadi 1, di mana setiap batch memiliki panjang urutan 4096 token. Dalam hal ini, ada 1536 replika model, ukuran batch global menjadi 1536, dan setiap batch global berisi sekitar 6 juta token.
```
(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)
```
Menambahkan paralelisme tensor ke dalamnya dapat menurunkan ukuran batch global. Salah satu contoh konfigurasi dapat mengatur derajat paralel tensor ke 8 dan ukuran batch per GPU menjadi 4. Ini membentuk 192 kelompok paralel tensor atau 192 replika model, di mana setiap replika model didistribusikan di 8. GPUs Ukuran batch 4 adalah jumlah data pelatihan per iterasi dan per kelompok paralel tensor; yaitu, setiap replika model mengkonsumsi 4 batch per iterasi. Dalam hal ini, ukuran batch global menjadi 768, dan setiap batch global berisi sekitar 3 juta token. Oleh karena itu, ukuran batch global berkurang setengahnya dibandingkan dengan kasus sebelumnya dengan paralelisme data sharded saja.
```
(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)
```
### Contoh 2
Ketika paralelisme data sharded dan paralelisme tensor diaktifkan, perpustakaan pertama-tama menerapkan paralelisme tensor dan memecah model di seluruh dimensi ini. Untuk setiap peringkat paralel tensor, paralelisme data diterapkan sesuai. `sharded_data_parallel_degree`
Misalnya, asumsikan bahwa kita ingin mengatur 32 GPUs dengan derajat paralel tensor 4 (membentuk kelompok 4 GPUs), derajat paralel data sharded 4, berakhir dengan derajat replikasi 2. Penugasan tersebut membuat delapan grup GPU berdasarkan derajat paralel tensor sebagai berikut`(0,1,2,3)`:`(4,5,6,7)`,,,,`(8,9,10,11)`,`(12,13,14,15)`, `(16,17,18,19)``(20,21,22,23)`,`(24,25,26,27)`. `(28,29,30,31)` Artinya, empat GPUs membentuk satu kelompok paralel tensor. Dalam hal ini, kelompok paralel data tereduksi untuk peringkat 0 GPUs dari kelompok paralel tensor adalah. `(0,4,8,12,16,20,24,28)` Kelompok paralel data tereduksi dipecah berdasarkan derajat paralel data sharded 4, menghasilkan dua kelompok replikasi untuk paralelisme data. GPUs`(0,4,8,12)`membentuk satu kelompok sharding, yang secara kolektif menyimpan salinan lengkap semua parameter untuk peringkat paralel tensor ke-0, dan GPUs `(16,20,24,28)` membentuk kelompok lain seperti itu. Peringkat paralel tensor lainnya juga memiliki kelompok sharding dan replikasi yang serupa.
![\[Gambar 1: Kelompok paralelisme tensor.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg)
Gambar 1: Kelompok paralelisme tensor untuk (node, derajat paralel data sharded, derajat paralel tensor) = (4, 4, 4), di mana setiap persegi panjang mewakili GPU dengan indeks dari 0 hingga 31. GPUs Bentuk kelompok paralelisme tensor dari TPG ke 0 TPG. 7 Grup replikasi adalah (\$1TPG0, TPG4\$1, \$1TPG, TPG\$11, \$1TPG, TPG5\$1 dan \$1TPG 23, TPG 67\$1); setiap pasangan grup replikasi berbagi warna yang sama tetapi diisi secara berbeda.
![\[Gambar 2: Kelompok paralelisme data yang dibagikan.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg)
Gambar 2: Kelompok paralelisme data sharded untuk (node, derajat paralel data sharded, derajat paralel tensor) = (4, 4, 4), di mana setiap persegi panjang mewakili GPU dengan indeks dari 0 hingga 31. GPUs Formulir berbagi kelompok paralelisme data dari SDPG ke 0 SDPG. 7 Grup replikasi adalah (\$1SDPG0, SDPG4\$1, \$1SDPG, SDPG\$11, \$1SDPG, SDPG5\$1 dan \$1SDPG 23, SDPG 67\$1); setiap pasangan grup replikasi berbagi warna yang sama tetapi diisi secara berbeda.
### Cara mengaktifkan paralelisme data sharded dengan paralelisme tensor
Untuk menggunakan paralelisme data sharded dengan paralelisme tensor, Anda perlu mengatur keduanya `sharded_data_parallel_degree` dan `tensor_parallel_degree` dalam konfigurasi `distribution` saat membuat objek dari kelas estimator. SageMaker PyTorch
Anda juga perlu mengaktifkan`prescaled_batch`. Ini berarti bahwa, alih-alih setiap GPU membaca kumpulan datanya sendiri, setiap grup paralel tensor secara kolektif membaca kumpulan gabungan dari ukuran batch yang dipilih. Secara efektif, alih-alih membagi dataset menjadi bagian-bagian yang sama dengan jumlah GPUs (atau ukuran paralel data,`smp.dp_size()`), ia membagi menjadi bagian-bagian yang sama dengan jumlah GPUs dibagi dengan `tensor_parallel_degree` (juga disebut ukuran paralel data tereduksi,). `smp.rdp_size()` Untuk detail selengkapnya tentang batch pra-skala, lihat Batch [Prescaled dalam dokumentasi SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) *Python* SDK. Lihat juga contoh skrip pelatihan [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)untuk GPT-2 di repositori Contoh *SageMaker AI*. GitHub
Cuplikan kode berikut menunjukkan contoh pembuatan objek PyTorch estimator berdasarkan skenario yang disebutkan di atas. [Contoh 2](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2)
```
mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
"ddp": True,
"fp16": True,
"prescaled_batch": True,
"sharded_data_parallel_degree": 4,
"tensor_parallel_degree": 4
}
pytorch_estimator = PyTorch(
entry_point="your_training_script.py",
role=role,
instance_type="ml.p4d.24xlarge",
volume_size=200,
instance_count=4,
sagemaker_session=sagemaker_session,
py_version="py3",
framework_version="1.13.1",
distribution={
"smdistributed": {
"modelparallel": {
"enabled": True,
"parameters": smp_parameters,
}
},
"mpi": {
"enabled": True,
"processes_per_host": 8,
"custom_mpi_options": mpi_options,
},
},
source_dir="source_directory_of_your_code",
output_path=s3_output_location
)
```
## Kiat dan pertimbangan untuk menggunakan paralelisme data sharded
Pertimbangkan hal berikut saat menggunakan paralelisme data sharded pustaka paralelisme SageMaker model.
+ Paralelisme data sharded kompatibel dengan pelatihan. FP16 Untuk menjalankan FP16 pelatihan, lihat [FP16 Pelatihan dengan Model Paralelisme](model-parallel-extended-features-pytorch-fp16.md) bagian.
+ Paralelisme data sharded kompatibel dengan paralelisme tensor. Item berikut adalah apa yang mungkin perlu Anda pertimbangkan untuk menggunakan paralelisme data sharded dengan paralelisme tensor.
+ Saat menggunakan paralelisme data sharded dengan paralelisme tensor, lapisan penyematan juga didistribusikan secara otomatis di seluruh grup paralel tensor. Dengan kata lain, `distribute_embedding` parameter secara otomatis diatur ke`True`. Untuk informasi lebih lanjut tentang paralelisme tensor, lihat. [Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ Perhatikan bahwa paralelisme data sharded dengan paralelisme tensor saat ini menggunakan kolektif NCCL sebagai backend dari strategi pelatihan terdistribusi.
Untuk mempelajari lebih lanjut, lihat [Paralelisme data sharded dengan paralelisme tensor](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism) bagian.
+ [Paralelisme data sharded saat ini tidak kompatibel dengan paralelisme [pipa atau sharding status pengoptimal](model-parallel-intro.md#model-parallel-intro-pp).](model-parallel-extended-features-pytorch-optimizer-state-sharding.md) Untuk mengaktifkan paralelisme data sharded, matikan sharding status pengoptimal dan atur derajat paralel pipeline ke 1.
+ Fitur [checkpointing aktivasi](model-parallel-extended-features-pytorch-activation-checkpointing.md) dan [pembongkaran aktivasi](model-parallel-extended-features-pytorch-activation-offloading.md) kompatibel dengan paralelisme data sharded.
+ Untuk menggunakan paralelisme data sharded dengan akumulasi gradien, setel `backward_passes_per_step` argumen ke jumlah langkah akumulasi sambil membungkus model Anda dengan modul. [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) Ini memastikan bahwa `AllReduce` operasi gradien di seluruh grup replikasi model (grup sharding) berlangsung pada batas akumulasi gradien.
+ Anda dapat memeriksa model Anda yang dilatih dengan paralelisme data sharded menggunakan pos pemeriksaan perpustakaan, dan. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Untuk informasi selengkapnya, lihat [Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model v1.10.0 dan yang lebih baru)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint).
+ Perilaku parameter [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization)konfigurasi berubah di bawah paralelisme data sharded. Ketika kedua fitur ini diaktifkan secara bersamaan, parameter segera diinisialisasi pada pembuatan model secara sharded alih-alih menunda inisialisasi parameter, sehingga setiap peringkat menginisialisasi dan menyimpan pecahan parameternya sendiri.
+ Saat paralelisme data sharded diaktifkan, pustaka melakukan kliping gradien secara internal saat panggilan berjalan. `optimizer.step()` Anda tidak perlu menggunakan utilitas APIs untuk kliping gradien, seperti. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Untuk menyesuaikan nilai ambang batas untuk kliping gradien, Anda dapat mengaturnya melalui `sdp_gradient_clipping` parameter untuk konfigurasi parameter distribusi saat Anda membuat SageMaker PyTorch estimator, seperti yang ditunjukkan di bagian. [Cara menerapkan paralelisme data sharded ke pekerjaan pelatihan Anda](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
# Pipelining Model
Salah satu fitur inti dari SageMaker perpustakaan paralelisme model adalah *paralelisme pipa*, yang menentukan urutan perhitungan dibuat dan data diproses di seluruh perangkat selama pelatihan model. Pipelining adalah teknik untuk mencapai paralelisasi sejati dalam paralelisme model, dengan memiliki GPUs komputasi secara bersamaan pada sampel data yang berbeda, dan untuk mengatasi kehilangan kinerja karena komputasi sekuensial. Saat Anda menggunakan paralelisme pipeline, pekerjaan pelatihan dijalankan secara pipelined melalui microbatch untuk memaksimalkan penggunaan GPU.
**catatan**
Paralelisme pipa, juga disebut partisi model, tersedia untuk keduanya dan. PyTorch TensorFlow Untuk versi kerangka kerja yang didukung, lihat[Kerangka Kerja yang Didukung dan Wilayah AWS](distributed-model-parallel-support.md).
## Jadwal Eksekusi Pipeline
Pipelining didasarkan pada pemisahan mini-batch menjadi microbatch, yang dimasukkan ke dalam pipeline pelatihan one-by-one dan mengikuti jadwal eksekusi yang ditentukan oleh runtime perpustakaan. *Microbatch* adalah subset yang lebih kecil dari mini-batch pelatihan yang diberikan. Jadwal pipa menentukan microbatch mana yang dijalankan oleh perangkat mana untuk setiap slot waktu.
Misalnya, tergantung pada jadwal pipeline dan partisi model, GPU `i` mungkin melakukan komputasi (maju atau mundur) pada microbatch `b` sementara GPU `i+1` melakukan komputasi pada microbatch`b+1`, sehingga menjaga keduanya tetap aktif pada saat yang sama. GPUs Selama pass maju atau mundur tunggal, alur eksekusi untuk satu microbatch mungkin mengunjungi perangkat yang sama beberapa kali, tergantung pada keputusan partisi. Misalnya, operasi yang ada di awal model dapat ditempatkan pada perangkat yang sama dengan operasi di akhir model, sementara operasi di antaranya berada pada perangkat yang berbeda, yang berarti perangkat ini dikunjungi dua kali.
Pustaka menawarkan dua jadwal pipeline yang berbeda, *sederhana* dan *interleaved*, yang dapat dikonfigurasi menggunakan `pipeline` parameter di Python SageMaker SDK. Dalam kebanyakan kasus, pipa interleaved dapat mencapai kinerja yang lebih baik dengan memanfaatkan yang lebih efisien. GPUs
### Pipa Interleaved
Dalam pipa yang disisipkan, eksekusi mundur dari microbatch diprioritaskan bila memungkinkan. Hal ini memungkinkan pelepasan lebih cepat dari memori yang digunakan untuk aktivasi, menggunakan memori lebih efisien. Ini juga memungkinkan untuk menskalakan jumlah microbatch yang lebih tinggi, mengurangi waktu idle. GPUs Pada kondisi tunak, setiap perangkat bergantian antara berjalan maju dan mundur. Ini berarti bahwa lintasan mundur dari satu microbatch dapat berjalan sebelum pass maju dari microbatch lain selesai.
![\[Contoh jadwal eksekusi untuk pipeline interleaved lebih dari 2. GPUs\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png)
Gambar sebelumnya menggambarkan contoh jadwal eksekusi untuk pipeline interleaved lebih dari 2. GPUs Pada gambar, F0 mewakili pass maju untuk microbatch 0, dan B1 mewakili pass mundur untuk microbatch 1. **Pembaruan** mewakili pembaruan pengoptimal parameter. GPU0 selalu memprioritaskan pass mundur bila memungkinkan (misalnya, mengeksekusi B0 sebelum F2), yang memungkinkan untuk membersihkan memori yang digunakan untuk aktivasi sebelumnya.
### Alur Sederhana
Pipeline sederhana, sebaliknya, selesai menjalankan pass maju untuk setiap microbatch sebelum memulai lintasan mundur. Ini berarti bahwa itu hanya menyalurkan tahapan pass maju dan mundur di dalam diri mereka sendiri. Gambar berikut mengilustrasikan contoh cara kerjanya, lebih dari 2 GPUs.
![\[Contoh pada pipa yang menjalankan pass maju untuk setiap microbatch sebelum memulai lintasan mundur.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png)
### Eksekusi Pipelining dalam Kerangka Kerja Tertentu
Gunakan bagian berikut untuk mempelajari tentang keputusan penjadwalan pipeline khusus kerangka kerja yang dibuat oleh pustaka SageMaker paralelisme model untuk dan. TensorFlow PyTorch
#### Eksekusi Pipeline dengan TensorFlow
Gambar berikut adalah contoh TensorFlow grafik yang dipartisi oleh pustaka paralelisme model, menggunakan pemisahan model otomatis. Ketika grafik dibagi, setiap subgraf yang dihasilkan direplikasi B kali (kecuali untuk variabel), di mana B adalah jumlah microbatch. Pada gambar ini, setiap subgraf direplikasi 2 kali (B=2). `SMPInput`Operasi dimasukkan pada setiap input subgraf, dan `SMPOutput` operasi dimasukkan pada setiap output. Operasi ini berkomunikasi dengan backend perpustakaan untuk mentransfer tensor ke dan dari satu sama lain.
![\[Contoh TensorFlow grafik yang dipartisi oleh pustaka paralelisme model, menggunakan pemisahan model otomatis.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png)
Gambar berikut adalah contoh dari 2 subgraf yang dibagi dengan B = 2 dengan operasi gradien ditambahkan. Gradien `SMPInput` op adalah `SMPOutput` op, dan sebaliknya. Ini memungkinkan gradien mengalir mundur selama propagasi balik.
![\[Contoh 2 subgraf dibagi dengan B = 2 dengan operasi gradien ditambahkan.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif)
GIF ini menunjukkan contoh jadwal eksekusi pipeline interleaved dengan B = 2 microbatch dan 2 subgraf. Setiap perangkat secara berurutan mengeksekusi salah satu replika subgraf untuk meningkatkan pemanfaatan GPU. Saat B tumbuh lebih besar, fraksi slot waktu idle menjadi nol. Kapan pun waktunya untuk melakukan perhitungan (maju atau mundur) pada replika subgraf tertentu, lapisan pipa memberi sinyal ke operasi biru `SMPInput` yang sesuai untuk mulai mengeksekusi.
Setelah gradien dari semua microbatch dalam satu mini-batch dihitung, perpustakaan menggabungkan gradien di seluruh microbatch, yang kemudian dapat diterapkan ke parameter.
#### Eksekusi Pipeline dengan PyTorch
Secara konseptual, pipelining mengikuti ide serupa di. PyTorch Namun, karena PyTorch tidak melibatkan grafik statis sehingga PyTorch fitur perpustakaan paralelisme model menggunakan paradigma pipelining yang lebih dinamis.
Seperti dalam TensorFlow, setiap batch dibagi menjadi beberapa microbatch, yang dijalankan satu per satu pada setiap perangkat. Namun, jadwal eksekusi ditangani melalui server eksekusi yang diluncurkan pada setiap perangkat. Setiap kali output submodul yang ditempatkan pada perangkat lain diperlukan pada perangkat saat ini, permintaan eksekusi dikirim ke server eksekusi perangkat jarak jauh bersama dengan tensor input ke submodul. Server kemudian mengeksekusi modul ini dengan input yang diberikan dan mengembalikan respons ke perangkat saat ini.
Karena perangkat saat ini menganggur selama eksekusi submodul jarak jauh, eksekusi lokal untuk microbatch saat ini berhenti, dan runtime perpustakaan mengalihkan eksekusi ke microbatch lain yang dapat dikerjakan secara aktif oleh perangkat saat ini. Prioritas microbatch ditentukan oleh jadwal pipa yang dipilih. Untuk jadwal pipa yang disisipkan, microbatch yang berada dalam tahap mundur komputasi diprioritaskan bila memungkinkan.
# Paralelisme Tensor
*Paralelisme tensor adalah jenis paralelisme* model di mana bobot model tertentu, gradien, dan status pengoptimal dibagi di seluruh perangkat. Berbeda dengan paralelisme pipa, yang menjaga bobot individu tetap utuh tetapi mempartisi *set* bobot, paralelisme tensor membagi bobot individu. Ini biasanya melibatkan komputasi terdistribusi dari operasi tertentu, modul, atau lapisan model.
Paralelisme tensor diperlukan dalam kasus di mana satu parameter menghabiskan sebagian besar memori GPU (seperti tabel penyematan besar dengan ukuran kosakata besar atau lapisan softmax besar dengan sejumlah besar kelas). Dalam hal ini, memperlakukan tensor atau operasi besar ini sebagai unit atom tidak efisien dan menghambat keseimbangan beban memori.
Paralelisme tensor juga berguna untuk model yang sangat besar di mana pipelining murni tidak cukup. Misalnya, dengan model skala GPT-3 yang memerlukan partisi lebih dari puluhan instance, pipelining mikrobatch murni tidak efisien karena kedalaman pipa menjadi terlalu tinggi dan overhead menjadi sangat besar.
**catatan**
Paralelisme tensor tersedia untuk perpustakaan paralelisme SageMaker model PyTorch v1.6.0 dan yang lebih baru.
**Topics**
+ [Bagaimana Paralelisme Tensor Bekerja](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md)
+ [Jalankan Job Pelatihan Paralel Model SageMaker Terdistribusi dengan Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md)
+ [Support untuk Model Trafo Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md)
+ [Mekanisme Pemeringkatan Saat Menggunakan Kombinasi Paralelisme Pipa dan Paralelisme Tensor](model-parallel-extended-features-pytorch-ranking-mechanism.md)
# Bagaimana Paralelisme Tensor Bekerja
Paralelisme tensor terjadi pada tingkat`nn.Modules`; itu mempartisi modul tertentu dalam model di seluruh peringkat paralel tensor. Ini merupakan tambahan dari partisi yang ada dari *kumpulan modul yang* digunakan dalam paralelisme pipa.
Ketika modul dipartisi melalui paralelisme tensor, propagasi maju dan mundur didistribusikan. Pustaka menangani komunikasi yang diperlukan di seluruh perangkat untuk mengimplementasikan eksekusi terdistribusi modul-modul ini. Modul dipartisi di beberapa peringkat paralel data. Berlawanan dengan distribusi beban kerja tradisional, setiap peringkat paralel data **tidak** memiliki replika model lengkap saat paralelisme tensor perpustakaan digunakan. Sebaliknya, setiap peringkat paralel data mungkin hanya memiliki partisi dari modul terdistribusi, di samping keseluruhan modul yang tidak didistribusikan.
**Contoh:** Pertimbangkan paralelisme tensor di seluruh peringkat paralel data, di mana tingkat paralelisme data adalah 4 dan derajat paralelisme tensor adalah 2. Asumsikan bahwa Anda memiliki grup paralel data yang memegang pohon modul berikut, setelah mempartisi kumpulan modul.
```
A
├── B
| ├── E
| ├── F
├── C
└── D
├── G
└── H
```
Asumsikan bahwa paralelisme tensor didukung untuk modul B, G, dan H. Salah satu kemungkinan hasil partisi paralel tensor model ini adalah:
```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```
Setiap baris mewakili kumpulan modul yang disimpan di dalamnya`dp_rank`, dan notasi `X:y` mewakili fraksi `y` ke-modul. `X` Perhatikan hal-hal berikut:
1. Partisi terjadi di seluruh himpunan bagian dari peringkat paralel data, yang kita sebut`TP_GROUP`, bukan keseluruhan`DP_GROUP`, sehingga partisi model yang tepat direplikasi di `dp_rank` 0 dan `dp_rank` 2, dan juga di `dp_rank` 1 dan 3. `dp_rank`
1. Modul `E` dan `F` tidak lagi menjadi bagian dari model, karena modul induknya `B` dipartisi, dan setiap eksekusi yang biasanya merupakan bagian dari `E` dan `F` berlangsung di dalam modul (dipartisi). `B`
1. Meskipun `H` didukung untuk paralelisme tensor, dalam contoh ini tidak dipartisi, yang menyoroti bahwa apakah akan mempartisi modul bergantung pada input pengguna. Fakta bahwa modul didukung untuk paralelisme tensor tidak selalu berarti modul tersebut dipartisi.
## Bagaimana perpustakaan menyesuaikan paralelisme tensor ke modul PyTorch `nn.Linear`
*Ketika paralelisme tensor dilakukan melalui peringkat paralel data, subset dari parameter, gradien, dan status pengoptimal dipartisi di seluruh perangkat paralel tensor untuk modul yang dipartisi.* Untuk modul lainnya, perangkat paralel tensor beroperasi secara paralel data reguler. Untuk menjalankan modul yang dipartisi, perangkat pertama-tama mengumpulkan bagian yang diperlukan dari *semua sampel data* di seluruh perangkat rekan dalam grup paralelisme tensor yang sama. Perangkat kemudian menjalankan fraksi lokal modul pada semua sampel data ini, diikuti oleh putaran sinkronisasi lain yang menggabungkan bagian-bagian output untuk setiap sampel data dan mengembalikan sampel data gabungan ke tempat sampel data pertama kali GPUs berasal. Gambar berikut menunjukkan contoh proses ini melalui modul yang dipartisi`nn.Linear`.
![\[Dua angka menunjukkan dua konsep paralel tensor.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)
Gambar pertama menunjukkan model kecil dengan `nn.Linear` modul besar dengan paralelisme data di atas dua peringkat paralelisme tensor. `nn.Linear`Modul direplikasi ke dalam dua peringkat paralel.
Gambar kedua menunjukkan paralelisme tensor diterapkan pada model yang lebih besar saat membelah modul. `nn.Linear` Masing-masing `tp_rank` memegang setengah modul linier, dan keseluruhan operasi lainnya. Sementara modul linier berjalan, masing-masing `tp_rank` mengumpulkan setengah yang relevan dari semua sampel data dan meneruskannya melalui setengah dari `nn.Linear` modul mereka. Hasilnya perlu direduksi tersebar (dengan penjumlahan sebagai operasi reduksi) sehingga setiap peringkat memiliki keluaran linier akhir untuk sampel datanya sendiri. Sisa model berjalan dengan cara paralel data yang khas.
# Jalankan Job Pelatihan Paralel Model SageMaker Terdistribusi dengan Paralelisme Tensor
Di bagian ini, Anda belajar:
+ Cara mengonfigurasi SageMaker PyTorch estimator dan opsi paralelisme SageMaker model untuk menggunakan paralelisme tensor.
+ Cara mengadaptasi skrip pelatihan Anda menggunakan `smdistributed.modelparallel` modul yang diperluas untuk paralelisme tensor.
Untuk mempelajari lebih lanjut tentang `smdistributed.modelparallel` modul, lihat [SageMaker model parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) dalam dokumentasi *SageMaker Python SDK*.
**Topics**
+ [Paralelisme tensor saja](#model-parallel-extended-features-pytorch-tensor-parallelism-alone)
+ [Paralelisme tensor dikombinasikan dengan paralelisme pipa](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
## Paralelisme tensor saja
Berikut ini adalah contoh opsi pelatihan terdistribusi untuk mengaktifkan paralelisme tensor saja, tanpa paralelisme pipa. Konfigurasikan `mpi_options` dan `smp_options` kamus untuk menentukan opsi pelatihan terdistribusi ke estimator. SageMaker `PyTorch`
**catatan**
Fitur hemat memori yang diperluas tersedia melalui Deep Learning Containers for PyTorch, yang mengimplementasikan pustaka paralelisme SageMaker model v1.6.0 atau yang lebih baru.
**Konfigurasikan SageMaker PyTorch estimator**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"pipeline_parallel_degree": 1, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 4, # tp over 4 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Tip**
Untuk menemukan daftar lengkap parameter`distribution`, lihat [Parameter Konfigurasi untuk Paralelisme Model dalam dokumentasi](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) SageMaker Python SDK.
**Sesuaikan skrip PyTorch pelatihan Anda**
Contoh skrip pelatihan berikut menunjukkan bagaimana mengadaptasi perpustakaan paralelisme SageMaker model ke skrip pelatihan. Dalam contoh ini, diasumsikan bahwa skrip diberi nama`your_training_script.py`.
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
loss.backward()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64)
# smdistributed: Enable tensor parallelism for all supported modules in the model
# i.e., nn.Linear in this case. Alternatively, we can use
# smp.set_tensor_parallelism(model.fc1, True)
# to enable it only for model.fc1
with smp.tensor_parallelism():
model = Net()
# smdistributed: Use the DistributedModel wrapper to distribute the
# modules for which tensor parallelism is enabled
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Paralelisme tensor dikombinasikan dengan paralelisme pipa
Berikut ini adalah contoh opsi pelatihan terdistribusi yang memungkinkan paralelisme tensor dikombinasikan dengan paralelisme pipa. Siapkan `smp_options` parameter `mpi_options` dan untuk menentukan opsi paralel model dengan paralelisme tensor saat Anda mengonfigurasi estimator. SageMaker `PyTorch`
**catatan**
Fitur hemat memori yang diperluas tersedia melalui Deep Learning Containers for PyTorch, yang mengimplementasikan pustaka paralelisme SageMaker model v1.6.0 atau yang lebih baru.
**Konfigurasikan SageMaker PyTorch estimator**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Sesuaikan skrip PyTorch pelatihan Anda**
Contoh skrip pelatihan berikut menunjukkan bagaimana mengadaptasi perpustakaan paralelisme SageMaker model ke skrip pelatihan. Perhatikan bahwa skrip pelatihan sekarang menyertakan `smp.step` dekorator:
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = Net()
# smdistributed: enable tensor parallelism only for model.fc1
smp.set_tensor_parallelism(model.fc1, True)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
# Support untuk Model Trafo Hugging Face
Paralelisme tensor perpustakaan paralelisme SageMaker model menawarkan out-of-the-box dukungan untuk model Hugging Face Transformer berikut:
+ GPT-2, BERT, dan Ro BERTa (Tersedia di perpustakaan paralelisme SageMaker model v1.7.0 dan yang lebih baru)
+ GPT-J (Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)
+ GPT-neo (Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)
**catatan**
Untuk model Transformers lainnya, Anda perlu menggunakan [smdistributed.modelparallel.torch.tp\$1register\$1with\$1module () API untuk menerapkan paralelisme tensor](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module).
**catatan**
Untuk menggunakan paralelisme tensor untuk melatih model Hugging Face Transformer, pastikan Anda menggunakan Hugging Face Deep Learning Containers untuk yang SageMaker memiliki pustaka paralelisme model PyTorch v1.7.0 dan yang lebih baru. Untuk informasi selengkapnya, lihat catatan [rilis perpustakaan paralelisme SageMaker model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html).
## Model yang Didukung Di Luar Kotak
Untuk model transformator Hugging Face yang didukung oleh perpustakaan di luar kotak, Anda tidak perlu mengimplementasikan kait secara manual untuk menerjemahkan APIs Transformer `smdistributed` ke lapisan transformator. [Anda dapat mengaktifkan paralelisme tensor dengan menggunakan manajer konteks smdistributed.modelparallel.torch.tensor\$1parallelism () dan membungkus model dengan [smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism). DistributedModel()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Anda tidak perlu mendaftarkan kait secara manual untuk paralelisme tensor menggunakan API. `smp.tp_register`
Fungsi `state_dict` terjemahan antara Hugging Face Transformers `smdistributed.modelparallel` dan dapat diakses sebagai berikut.
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)
**Contoh penggunaan fungsi terjemahan GPT-2**
Mulailah dengan membungkus model seperti yang ditunjukkan pada kode berikut.
```
from transformers import AutoModelForCausalLM
with smp.tensor_parallelism():
model = AutoModelForCausalLM.from_config(hf_gpt2_config)
model = smp.DistributedModel(model)
```
Diberikan `state_dict` dari `DistributedModel` objek, Anda dapat memuat bobot ke dalam model GPT-2 Hugging Face asli menggunakan `translate_state_dict_to_hf_gpt2` fungsi seperti yang ditunjukkan pada kode berikut.
```
from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
import translate_state_dict_to_hf_gpt2
max_seq_len = 1024
# [... code block for training ...]
if smp.rdp_rank() == 0:
state_dict = dist_model.state_dict()
hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)
# can now call model.load_state_dict(hf_state_dict) to the original HF model
```
**Contoh penggunaan fungsi BERTa terjemahan Ro**
Demikian pula, dengan HuggingFace model yang didukung`state_dict`, Anda dapat menggunakan `translate_hf_state_dict_to_smdistributed` fungsi untuk mengubahnya menjadi format yang dapat dibaca oleh`smp.DistributedModel`. Ini dapat berguna dalam kasus penggunaan pembelajaran transfer, di mana model yang telah dilatih sebelumnya dimuat ke dalam fine-tuning paralel `smp.DistributedModel` untuk model-paralel:
```
from smdistributed.modelparallel.torch.nn.huggingface.roberta \
import translate_state_dict_to_smdistributed
model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)
pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
translate_state_dict_to_smdistributed(pretrained_model.state_dict())
# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)
# start fine-tuning...
```
# Mekanisme Pemeringkatan Saat Menggunakan Kombinasi Paralelisme Pipa dan Paralelisme Tensor
Bagian ini menjelaskan bagaimana mekanisme peringkat paralelisme model bekerja dengan paralelisme tensor. Ini diperpanjang dari [Dasar-Dasar Ranking](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) untuk[Fitur Inti dari Perpustakaan Paralelisme SageMaker Model](model-parallel-core-features.md). Dengan paralelisme tensor, perpustakaan memperkenalkan tiga jenis peringkat dan grup proses: untuk peringkat paralel `smp.tp_rank()` tensor, APIs untuk peringkat paralel `smp.pp_rank()` pipa, dan untuk `smp.rdp_rank()` peringkat paralel data yang dikurangi. Kelompok proses komunikasi yang sesuai adalah tensor parallel group (`TP_GROUP`), pipeline parallel group (`PP_GROUP`), dan reduced-data parallel group `RDP_GROUP` (). Kelompok-kelompok ini didefinisikan sebagai berikut:
+ *Gugus paralel tensor* (`TP_GROUP`) adalah subset yang dapat dibagi secara merata dari kelompok paralel data, di mana distribusi paralel tensor modul berlangsung. Ketika derajat paralelisme pipa adalah 1, `TP_GROUP` sama dengan model *parallel group* ()`MP_GROUP`.
+ *Pipeline parallel group* (`PP_GROUP`) adalah kelompok proses di mana paralelisme pipa terjadi. Ketika derajat paralelisme tensor adalah 1, `PP_GROUP` sama dengan. `MP_GROUP`
+ *Reduced-data parallel group* (`RDP_GROUP`) adalah serangkaian proses yang memegang partisi paralelisme pipa yang sama dan partisi paralelisme tensor yang sama, dan melakukan paralelisme data di antara mereka sendiri. Ini disebut grup paralelisme data tereduksi karena merupakan bagian dari seluruh kelompok paralelisme data,. `DP_GROUP` Untuk parameter model yang didistribusikan di dalam`TP_GROUP`, `allreduce` operasi gradien dilakukan hanya untuk grup paralel data tereduksi, sedangkan untuk parameter yang tidak didistribusikan, `allreduce` gradien berlangsung di seluruh. `DP_GROUP`
+ Model parallel group (`MP_GROUP`) mengacu pada sekelompok proses yang secara kolektif menyimpan seluruh model. Ini terdiri dari penyatuan `PP_GROUP` s dari semua peringkat yang ada dalam `TP_GROUP` proses saat ini. Ketika derajat paralelisme tensor adalah 1, `MP_GROUP` setara dengan. `PP_GROUP` Hal ini juga konsisten dengan definisi yang ada dari `MP_GROUP` dari `smdistributed` rilis sebelumnya. Perhatikan bahwa arus `TP_GROUP` adalah bagian dari arus `DP_GROUP` dan arus. `MP_GROUP`
*Untuk mempelajari lebih lanjut tentang proses komunikasi APIs di pustaka paralelisme SageMaker model, lihat [Common API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) dan [PyTorch-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) dalam dokumentasi Python APIs SageMaker SDK.*
![\[Mekanisme peringkat, distribusi parameter, dan AllReduce operasi terkait paralelisme tensor.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png)
Misalnya, pertimbangkan kelompok proses untuk satu simpul dengan 8 GPUs, di mana derajat paralelisme tensor adalah 2, derajat paralelisme pipa adalah 2, dan tingkat paralelisme data adalah 4. Bagian tengah atas dari gambar sebelumnya menunjukkan contoh model dengan 4 lapisan. Bagian kiri bawah dan kanan bawah gambar menggambarkan model 4-lapisan yang didistribusikan di 4 GPUs menggunakan paralelisme pipa dan paralelisme tensor, di mana paralelisme tensor digunakan untuk dua lapisan tengah. Kedua angka yang lebih rendah ini adalah salinan sederhana untuk menggambarkan garis batas kelompok yang berbeda. Model yang dipartisi direplikasi untuk paralelisme data di 0-3 dan 4-7. GPUs Gambar kiri bawah menunjukkan definisi`MP_GROUP`,`PP_GROUP`, dan`TP_GROUP`. Angka kanan bawah menunjukkan`RDP_GROUP`,`DP_GROUP`, dan `WORLD` di atas set yang sama GPUs. Gradien untuk lapisan dan irisan lapisan yang memiliki warna yang sama adalah `allreduce` d bersama-sama untuk paralelisme data. Misalnya, lapisan pertama (biru muda) mendapatkan `allreduce` operasi`DP_GROUP`, sedangkan irisan oranye gelap di lapisan kedua hanya mendapatkan `allreduce` operasi dalam prosesnya`RDP_GROUP`. Panah merah tua yang berani mewakili tensor dengan batch keseluruhannya. `TP_GROUP`
```
GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0
GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1
GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2
GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3
GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0
GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1
GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2
GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3
```
Dalam contoh ini, paralelisme pipa terjadi di seluruh pasangan GPU (0,1); (2,3); (4,5) dan (6,7). Selain itu, paralelisme data (`allreduce`) terjadi di GPUs 0, 2, 4, 6, dan secara independen di atas GPUs 1, 3, 5, 7. Paralelisme tensor terjadi pada himpunan bagian dari `DP_GROUP` s, di seluruh pasangan GPU (0,2); (1,3); (4,6) dan (5,7).
Untuk jenis pipa hibrida dan paralelisme tensor ini, matematika untuk `data_parallel_degree` tetap sebagai. `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree` Pustaka selanjutnya menghitung tingkat paralel data yang dikurangi dari hubungan `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree` berikut.
# Sharding Status Optimizer
*Sharding status pengoptimal* adalah teknik hemat memori yang berguna yang memecah status pengoptimal (kumpulan bobot yang menjelaskan status pengoptimal) di seluruh grup perangkat paralel data. Anda dapat menggunakan sharding status pengoptimal setiap kali Anda menggunakan pengoptimal stateful (seperti Adam) atau FP16 pengoptimal (yang menyimpan keduanya FP16 dan FP32 salinan parameter).
**catatan**
Sharding status pengoptimal tersedia PyTorch di pustaka paralelisme SageMaker model v1.6.0 dan yang lebih baru.
## Cara Menggunakan Optimizer State Sharding
Anda dapat mengaktifkan *sharding status pengoptimal* dengan mengatur konfigurasi`"shard_optimizer_state": True`. `modelparallel`
Saat fitur ini dihidupkan, pustaka mempartisi kumpulan parameter model berdasarkan tingkat paralelisme data. Gradien yang sesuai dengan partisi `i` th berkurang hanya pada peringkat paralel data `i` th. Pada akhir panggilan pertama ke fungsi `smp.step` dekorator, pengoptimal yang dibungkus dengan `smp.DistributedOptimizer` mendefinisikan ulang parameternya hanya terbatas pada parameter yang sesuai dengan partisi peringkat paralel data saat ini. Parameter yang didefinisikan ulang disebut *parameter virtual* dan berbagi penyimpanan yang mendasarinya dengan parameter asli. Selama panggilan pertama ke`optimizer.step`, status pengoptimal dibuat berdasarkan parameter yang didefinisikan ulang ini, yang di-sharded karena partisi asli. Setelah pembaruan pengoptimal, AllGather operasi (sebagai bagian dari `optimizer.step` panggilan) berjalan di seluruh peringkat paralel data untuk mencapai status parameter yang konsisten.
**Tip**
Sharding status pengoptimal dapat berguna ketika tingkat paralelisme data lebih besar dari 1 dan model memiliki lebih dari satu miliar parameter.
Tingkat paralelisme data dihitung oleh`(processes_per_host * instance_count / pipeline_parallel_degree)`, dan `smp.dp_size()` fungsi menangani ukuran di latar belakang.
**Konfigurasikan SageMaker PyTorch estimator**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"shard_optimizer_state": True
}
}
```
**Sesuaikan skrip PyTorch pelatihan Anda**
Lihat [Menyesuaikan skrip PyTorch pelatihan Anda](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) di bagian paralelisme *Tensor yang dikombinasikan dengan paralelisme pipa*. Tidak ada modifikasi tambahan yang diperlukan untuk skrip.
# Aktivasi Checkpointing
*Checkpointing aktivasi* (atau *checkpointing gradien*) adalah teknik untuk mengurangi penggunaan memori dengan membersihkan aktivasi lapisan tertentu dan mengkomputernya kembali selama lintasan mundur. Secara efektif, ini memperdagangkan waktu komputasi ekstra untuk mengurangi penggunaan memori. Jika modul diperiksa, di akhir pass maju, input ke dan output dari modul tetap berada di memori. Tensor perantara apa pun yang akan menjadi bagian dari perhitungan di dalam modul itu dibebaskan selama pass maju. Selama lintasan mundur modul checkpoint, tensor ini dihitung ulang. Pada titik ini, lapisan di luar modul checkpointed ini telah menyelesaikan backward pass mereka, sehingga penggunaan memori puncak dengan checkpointing bisa lebih rendah.
**catatan**
Fitur ini tersedia untuk PyTorch di pustaka paralelisme SageMaker model v1.6.0 dan yang lebih baru.
## Cara Menggunakan Checkpointing Aktivasi
Dengan`smdistributed.modelparallel`, Anda dapat menggunakan pos pemeriksaan aktivasi pada perincian modul. Untuk semua `torch.nn` modul kecuali`torch.nn.Sequential`, Anda hanya dapat memeriksa pohon modul jika terletak dalam satu partisi dari perspektif paralelisme pipa. Dalam kasus `torch.nn.Sequential` modul, setiap pohon modul di dalam modul sekuensial harus terletak sepenuhnya dalam satu partisi agar pos pemeriksaan aktivasi berfungsi. Saat Anda menggunakan partisi manual, perhatikan batasan ini.
Saat Anda menggunakan [partisi model otomatis](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting), Anda dapat menemukan log tugas partisi yang dimulai dengan `Partition assignments:` di log pekerjaan pelatihan. Jika modul dipartisi di beberapa peringkat (misalnya, dengan satu keturunan pada satu peringkat dan keturunan lain pada peringkat yang berbeda), pustaka mengabaikan upaya untuk memeriksa modul dan memunculkan pesan peringatan bahwa modul tidak akan diperiksa.
**catatan**
Pustaka paralelisme SageMaker model mendukung operasi yang tumpang tindih dan tidak tumpang tindih dalam kombinasi dengan pos `allreduce` pemeriksaan.
**catatan**
PyTorchAPI checkpointing asli tidak kompatibel dengan. `smdistributed.modelparallel`
**Contoh 1:** Kode contoh berikut menunjukkan cara menggunakan checkpointing aktivasi ketika Anda memiliki definisi model dalam skrip Anda.
```
import torch.nn as nn
import torch.nn.functional as F
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
# This call of fc1 will be checkpointed
x = checkpoint(self.fc1, x)
x = self.fc2(x)
return F.log_softmax(x, 1)
```
**Contoh 2:** Kode contoh berikut menunjukkan cara menggunakan checkpointing aktivasi ketika Anda memiliki model sekuensial dalam skrip Anda.
```
import torch.nn as nn
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
# This call of self.seq will be checkpointed
x = checkpoint_sequential(self.seq, x)
return F.log_softmax(x, 1)
```
**Contoh 3:** Contoh kode berikut menunjukkan cara menggunakan checkpointing aktivasi saat Anda mengimpor model bawaan dari pustaka, seperti dan PyTorch Hugging Face Transformers. Apakah Anda memeriksa modul sekuensial atau tidak, lakukan hal berikut:
1. Bungkus model dengan`smp.DistributedModel()`.
1. Tentukan objek untuk lapisan berurutan.
1. Bungkus objek layer sekuensial dengan`smp.set_activation_checkpointig()`.
```
import smdistributed.modelparallel.torch as smp
from transformers import AutoModelForCausalLM
smp.init()
model = AutoModelForCausalLM(*args, **kwargs)
model = smp.DistributedModel(model)
# Call set_activation_checkpointing API
transformer_layers = model.module.module.module.transformer.seq_layers
smp.set_activation_checkpointing(
transformer_layers, pack_args_as_tuple=True, strategy='each')
```
# Pembongkaran Aktivasi
Ketika checkpointing aktivasi dan paralelisme pipa dihidupkan dan jumlah microbatch lebih besar dari satu, *pembongkaran aktivasi* adalah fitur tambahan yang selanjutnya dapat mengurangi penggunaan memori. Pembongkaran aktivasi secara asinkron memindahkan aktivasi checkpoint yang sesuai dengan microbatch mereka yang saat ini tidak berjalan di CPU. Tepat sebelum GPU membutuhkan aktivasi untuk backward pass microbatch, fungsi ini mengambil kembali aktivasi yang diturunkan dari CPU.
**catatan**
Fitur ini tersedia untuk PyTorch di pustaka paralelisme SageMaker model v1.6.0 dan yang lebih baru.
## Cara Menggunakan Pembongkaran Aktivasi
Gunakan pembongkaran aktivasi untuk mengurangi penggunaan memori ketika **jumlah microbatch lebih besar dari 1, dan pos pemeriksaan aktivasi diaktifkan (lihat**). [Aktivasi Checkpointing](model-parallel-extended-features-pytorch-activation-checkpointing.md) Ketika checkpointing aktivasi tidak digunakan, pembongkaran aktivasi tidak berpengaruh. Ketika digunakan hanya dengan satu microbatch, itu tidak menghemat memori.
Untuk menggunakan pembongkaran aktivasi, atur `"offload_activations": True` dalam `modelparallel` konfigurasi.
Pembongkaran aktivasi memindahkan aktivasi checkpoint dalam `nn.Sequential` modul ke CPU secara asinkron. Transfer data melalui PCIe tautan tumpang tindih dengan komputasi GPU. Pembongkaran terjadi segera, segera setelah pass maju untuk lapisan checkpoint tertentu dihitung. Aktivasi dimuat kembali ke GPU sesaat sebelum diperlukan untuk pass mundur dari microbatch tertentu. Transfer CPU-GPU juga tumpang tindih dengan komputasi.
Untuk menyesuaikan seberapa awal aktivasi dimuat kembali ke GPU, Anda dapat menggunakan parameter konfigurasi `"activation_loading_horizon"` (default diatur ke 4, harus `int` lebih besar dari 0). Cakrawala pemuatan aktivasi yang lebih besar akan menyebabkan aktivasi dimuat kembali ke GPU sebelumnya. Jika cakrawala terlalu besar, dampak penghematan memori dari pembongkaran aktivasi mungkin berkurang. Jika cakrawala terlalu kecil, aktivasi mungkin tidak dimuat kembali ke masa lalu, mengurangi jumlah tumpang tindih dan menurunkan kinerja.
**Tip**
Pembongkaran aktivasi dapat berguna untuk model besar dengan lebih dari seratus miliar parameter.
**Konfigurasikan SageMaker PyTorch estimator**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"offload_activations": True,
"activation_loading_horizon": 4 # optional. default is 4.
}
}
```
# FP16 Pelatihan dengan Model Paralelisme
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
)
```
# Support untuk FlashAttention
Support for FlashAttention adalah fitur perpustakaan yang hanya berlaku untuk model *transformator terdistribusi*, yang merupakan model Transformer yang dibungkus oleh [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)untuk pelatihan model-paralel. Fitur ini juga kompatibel dengan[Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md).
[FlashAttention](https://github.com/HazyResearch/flash-attention)Pustaka hanya mendukung model ketika `attention_head_size` disetel ke nilai yang kelipatan 8 dan kurang dari 128. Oleh karena itu, ketika Anda melatih transformator terdistribusi dan memastikannya FlashAttention berfungsi dengan baik, Anda harus menyesuaikan parameter untuk membuat ukuran kepala perhatian memenuhi persyaratan. Untuk informasi selengkapnya, lihat juga [Instalasi dan fitur](https://github.com/HazyResearch/flash-attention#installation-and-features) di *FlashAttention GitHubrepositori*.
Misalnya, asumsikan bahwa Anda mengonfigurasi model Transformer dengan `hidden_width=864` dan`num_heads=48`. Ukuran kepala FlashAttention dihitung sebagai`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Untuk mengaktifkan FlashAttention, Anda perlu menyesuaikan `num_heads` parameter ke`54`, sehingga`attention_head_size = hidden_width / num_heads = 864 / 54 = 16`, yang merupakan kelipatan dari 8.
# Jalankan Job Pelatihan SageMaker Terdistribusi dengan Paralelisme Model
Pelajari cara menjalankan tugas pelatihan model-paralel dari skrip pelatihan Anda sendiri menggunakan SageMaker Python SDK dengan pustaka paralelisme model. SageMaker
Ada tiga skenario kasus penggunaan untuk menjalankan pekerjaan SageMaker pelatihan.
1. Anda dapat menggunakan salah satu AWS Deep Learning Container yang sudah dibuat sebelumnya untuk TensorFlow dan PyTorch. Opsi ini disarankan jika ini adalah pertama kalinya bagi Anda untuk menggunakan perpustakaan paralel model. Untuk menemukan tutorial tentang cara menjalankan pekerjaan pelatihan paralel SageMaker model, lihat contoh notebook saat [PyTorch pelatihan dengan perpustakaan paralelisme model Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel).
1. Anda dapat memperluas kontainer pra-bangun untuk menangani persyaratan fungsional tambahan apa pun untuk algoritme atau model Anda yang tidak didukung oleh image SageMaker Docker yang sudah dibuat sebelumnya. Untuk menemukan contoh bagaimana Anda dapat memperluas kontainer yang sudah dibuat sebelumnya, lihat[Perluas Kontainer Pra-dibangun](prebuilt-containers-extend.md).
1. Anda dapat menyesuaikan wadah Docker Anda sendiri untuk bekerja dengan SageMaker AI menggunakan [toolkit SageMaker Pelatihan](https://github.com/aws/sagemaker-training-toolkit). Sebagai contoh, lihat [Mengadaptasi Wadah Pelatihan Anda Sendiri](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html).
Untuk opsi 2 dan 3 di daftar sebelumnya, lihat [Perluas Container Docker Pra-built yang Berisi Perpustakaan Paralel Model SageMaker Terdistribusi](model-parallel-sm-sdk.md#model-parallel-customize-container) untuk mempelajari cara menginstal pustaka paralel model dalam wadah Docker yang diperluas atau disesuaikan.
Dalam semua kasus, Anda meluncurkan tugas pelatihan dengan mengonfigurasi `PyTorch` estimator SageMaker `TensorFlow` atau untuk mengaktifkan pustaka. Untuk mempelajari lebih lanjut, lihat topik berikut.
**Topics**
+ [Langkah 1: Ubah Skrip Pelatihan Anda Sendiri Menggunakan SageMaker Perpustakaan Paralel Model Terdistribusi](model-parallel-customize-training-script.md)
+ [Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK](model-parallel-sm-sdk.md)
# Langkah 1: Ubah Skrip Pelatihan Anda Sendiri Menggunakan SageMaker Perpustakaan Paralel Model Terdistribusi
Gunakan bagian ini untuk mempelajari cara menyesuaikan skrip pelatihan Anda untuk menggunakan fitur inti dari perpustakaan paralelisme model Amazon SageMaker AI. *Untuk menggunakan fungsi dan parameter API khusus perpustakaan, kami sarankan Anda menggunakan dokumentasi ini bersama [pustaka SageMaker paralel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) model APIs dalam dokumentasi Python SageMaker SDK.*
Contoh skrip pelatihan yang disediakan di bagian ini disederhanakan dan dirancang untuk menyoroti perubahan yang diperlukan yang harus Anda lakukan untuk menggunakan perpustakaan. Untuk end-to-end contoh buku catatan yang dapat dijalankan yang menunjukkan cara menggunakan skrip TensorFlow atau PyTorch pelatihan dengan pustaka paralelisme SageMaker model, lihat. [Contoh perpustakaan paralelisme model Amazon SageMaker AI v2](distributed-model-parallel-v2-examples.md)
**Topics**
+ [Pisahkan model skrip pelatihan Anda menggunakan pustaka paralelisme SageMaker model](#model-parallel-model-splitting-using-smp-lib)
+ [Memodifikasi skrip TensorFlow pelatihan](model-parallel-customize-training-script-tf.md)
+ [Memodifikasi Skrip PyTorch Pelatihan](model-parallel-customize-training-script-pt.md)
## Pisahkan model skrip pelatihan Anda menggunakan pustaka paralelisme SageMaker model
Ada dua cara untuk memodifikasi skrip pelatihan Anda untuk mengatur pemisahan model: pemisahan otomatis atau pemisahan manual.
### Pemisahan model otomatis
Saat Anda menggunakan SageMaker pustaka paralelisme model, Anda dapat memanfaatkan *pemisahan model otomatis*, juga disebut sebagai partisi model *otomatis*. Pustaka menggunakan algoritma partisi yang menyeimbangkan memori, meminimalkan komunikasi antar perangkat, dan mengoptimalkan kinerja. Anda dapat mengonfigurasi algoritma partisi otomatis untuk mengoptimalkan kecepatan atau memori.
Atau, Anda dapat menggunakan pemisahan model manual. Kami merekomendasikan pemisahan model otomatis, kecuali jika Anda sangat akrab dengan arsitektur model dan memiliki ide bagus tentang cara mempartisi model Anda secara efisien.
#### Cara kerjanya
Partisi otomatis terjadi selama langkah pelatihan pertama, ketika fungsi `smp.step` -decorated pertama kali dipanggil. Selama panggilan ini, perpustakaan pertama-tama membuat versi model pada RAM CPU (untuk menghindari keterbatasan memori GPU), dan kemudian menganalisis grafik model dan membuat keputusan partisi. Berdasarkan keputusan ini, setiap partisi model dimuat pada GPU, dan baru kemudian langkah pertama dijalankan. Karena langkah-langkah analisis dan partisi ini, langkah pelatihan pertama mungkin memakan waktu lebih lama.
Dalam kedua kerangka kerja, perpustakaan mengelola komunikasi antar perangkat melalui backend sendiri, yang dioptimalkan untuk AWS infrastruktur.
Desain partisi otomatis menyesuaikan dengan karakteristik kerangka kerja, dan perpustakaan melakukan partisi pada tingkat granularitas yang lebih alami di setiap kerangka kerja. Misalnya, di TensorFlow, setiap operasi tertentu dapat ditugaskan ke perangkat yang berbeda, sedangkan pada PyTorch, penugasan dilakukan pada tingkat modul, di mana setiap modul terdiri dari beberapa operasi. Bagian berikut mengulas spesifikasi desain di setiap kerangka kerja.
##### Pemisahan model otomatis dengan PyTorch
Selama langkah pelatihan pertama, perpustakaan paralelisme model secara internal menjalankan langkah penelusuran yang dimaksudkan untuk membangun grafik model dan menentukan bentuk tensor dan parameter. Setelah langkah penelusuran ini, perpustakaan membangun pohon, yang terdiri dari `nn.Module` objek bersarang dalam model, serta data tambahan yang dikumpulkan dari penelusuran, seperti jumlah yang disimpan`nn.Parameters`, dan waktu eksekusi untuk masing-masing. `nn.Module`
Selanjutnya, perpustakaan melintasi pohon ini dari root dan menjalankan algoritma partisi yang menetapkan masing-masing `nn.Module` ke perangkat, yang menyeimbangkan beban komputasi (diukur dengan waktu eksekusi modul) dan penggunaan memori (diukur dengan total ukuran dan aktivasi yang disimpan). `nn.Parameter` Jika beberapa `nn.Modules` berbagi yang sama`nn.Parameter`, maka modul ini ditempatkan pada perangkat yang sama untuk menghindari mempertahankan beberapa versi dari parameter yang sama. Setelah keputusan partisi dibuat, modul dan bobot yang ditetapkan dimuat ke perangkat mereka.
Untuk petunjuk tentang cara mendaftarkan `smp.step` dekorator ke skrip PyTorch pelatihan Anda, lihat[Pemisahan otomatis dengan PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
##### Pemisahan model otomatis dengan TensorFlow
Pustaka paralelisme model menganalisis ukuran variabel yang dapat dilatih dan struktur grafik, dan secara internal menggunakan algoritma partisi grafik. Algoritma ini hadir dengan penugasan perangkat untuk setiap operasi, dengan tujuan meminimalkan jumlah komunikasi yang dibutuhkan di seluruh perangkat, tunduk pada dua kendala:
+ Menyeimbangkan jumlah variabel yang disimpan di setiap perangkat
+ Menyeimbangkan jumlah operasi yang dijalankan di setiap perangkat
Jika Anda menentukan `speed` for `optimize` (dalam parameter paralelisme model di SDK Python), pustaka mencoba menyeimbangkan jumlah operasi dan `tf.Variable` objek di setiap perangkat. Jika tidak, ia mencoba menyeimbangkan ukuran total`tf.Variables`.
Setelah keputusan partisi dibuat, pustaka akan membuat representasi serial dari subgraf yang perlu dijalankan oleh setiap perangkat dan mengimpornya ke setiap perangkat. Saat mempartisi, perpustakaan menempatkan operasi yang menggunakan yang sama `tf.Variable` dan operasi yang merupakan bagian dari lapisan Keras yang sama ke perangkat yang sama. Ini juga menghormati kendala kolokasi yang diberlakukan oleh. TensorFlow Ini berarti bahwa, misalnya, jika ada dua lapisan Keras yang berbagi a`tf.Variable`, maka semua operasi yang merupakan bagian dari lapisan ini ditempatkan pada satu perangkat.
Untuk petunjuk tentang cara mendaftarkan `smp.step` dekorator ke skrip PyTorch pelatihan Anda, lihat[Pemisahan otomatis dengan TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23).
##### Perbandingan pemisahan model otomatis antar kerangka kerja
Dalam TensorFlow, unit dasar komputasi adalah a`tf.Operation`, dan TensorFlow mewakili model sebagai grafik asiklik terarah (DAG) dari `tf.Operation` s, dan oleh karena itu perpustakaan paralelisme model mempartisi DAG ini sehingga setiap node masuk ke satu perangkat. Yang terpenting, `tf.Operation` objek cukup kaya dengan atribut yang dapat disesuaikan, dan bersifat universal dalam arti bahwa setiap model dijamin terdiri dari grafik objek tersebut.
PyTorch di sisi lain, tidak memiliki gagasan operasi yang setara yang cukup kaya dan universal. Unit komputasi terdekat PyTorch yang memiliki karakteristik ini adalah`nn.Module`, yang berada pada tingkat granularitas yang jauh lebih tinggi, dan inilah mengapa perpustakaan melakukan partisi pada tingkat ini di. PyTorch
### Pemisahan Model Manual
Jika Anda ingin menentukan secara manual cara mempartisi model Anda di seluruh perangkat, gunakan pengelola `smp.partition` konteks. Untuk petunjuk tentang cara mengatur manajer konteks untuk partisi manual, lihat halaman berikut.
+ [Pemisahan manual dengan TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual)
+ [Pemisahan manual dengan PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd)
Untuk menggunakan opsi ini setelah melakukan modifikasi, pada Langkah 2, Anda harus mengatur `auto_partition` ke`False`, dan menentukan kelas estimator kerangka kerja dari SageMaker Python SDK. `default_partition` Setiap operasi yang tidak secara eksplisit ditempatkan pada partisi melalui manajer `smp.partition` konteks dijalankan pada file. `default_partition` Dalam hal ini, logika pemisahan otomatis dilewati, dan setiap operasi ditempatkan berdasarkan spesifikasi Anda. Berdasarkan struktur grafik yang dihasilkan, pustaka paralelisme model membuat jadwal eksekusi pipelined secara otomatis.
# Memodifikasi skrip TensorFlow pelatihan
Di bagian ini, Anda mempelajari cara memodifikasi skrip TensorFlow pelatihan untuk mengonfigurasi pustaka paralelisme SageMaker model untuk partisi otomatis dan partisi manual. Pemilihan contoh ini juga mencakup contoh yang terintegrasi dengan Horovod untuk model hibrida dan paralelisme data.
**catatan**
Untuk menemukan TensorFlow versi mana yang didukung oleh perpustakaan, lihat[Kerangka Kerja yang Didukung dan Wilayah AWS](distributed-model-parallel-support.md).
Modifikasi yang diperlukan yang harus Anda lakukan pada skrip pelatihan Anda untuk menggunakan perpustakaan tercantum di dalamnya[Pemisahan otomatis dengan TensorFlow](#model-parallel-customize-training-script-tf-23).
Untuk mempelajari cara memodifikasi skrip pelatihan Anda untuk menggunakan model hibrida dan paralelisme data dengan Horovod, lihat. [Pemisahan otomatis dengan TensorFlow dan Horovod untuk model hibrida dan paralelisme data](#model-parallel-customize-training-script-tf-2.3)
Jika Anda ingin menggunakan partisi manual, tinjau juga. [Pemisahan manual dengan TensorFlow](#model-parallel-customize-training-script-tf-manual)
Topik berikut menunjukkan contoh skrip pelatihan yang dapat Anda gunakan untuk mengonfigurasi SageMaker pustaka paralelisme model untuk model partisi otomatis dan partisi manual. TensorFlow
**catatan**
Partisi otomatis diaktifkan secara default. Kecuali ditentukan lain, skrip contoh menggunakan partisi otomatis.
**Topics**
+ [Pemisahan otomatis dengan TensorFlow](#model-parallel-customize-training-script-tf-23)
+ [Pemisahan otomatis dengan TensorFlow dan Horovod untuk model hibrida dan paralelisme data](#model-parallel-customize-training-script-tf-2.3)
+ [Pemisahan manual dengan TensorFlow](#model-parallel-customize-training-script-tf-manual)
+ [Fitur kerangka kerja yang tidak didukung](#model-parallel-tf-unsupported-features)
## Pemisahan otomatis dengan TensorFlow
Perubahan skrip pelatihan berikut diperlukan untuk menjalankan TensorFlow model dengan pustaka SageMaker paralelisme model:
1. Impor dan inisialisasi perpustakaan dengan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Mendefinisikan model Keras dengan mewarisi dari [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html)bukan kelas Model Keras. Kembalikan output model dari metode panggilan `smp.DistributedModel` objek. Perhatikan bahwa setiap tensor yang dikembalikan dari metode panggilan akan disiarkan di seluruh perangkat paralel model, yang menimbulkan overhead komunikasi, jadi tensor apa pun yang tidak diperlukan di luar metode panggilan (seperti aktivasi perantara) tidak boleh dikembalikan.
1. Ditetapkan `drop_remainder=True` dalam `tf.Dataset.batch()` metode. Ini untuk memastikan bahwa ukuran batch selalu habis dibagi dengan jumlah microbatch.
1. Benih operasi acak dalam pipa data menggunakan`smp.dp_rank()`, misalnya, `shuffle(ds, seed=smp.dp_rank())` untuk memastikan konsistensi sampel data di seluruh GPUs yang memegang partisi model yang berbeda.
1. Letakkan logika maju dan mundur dalam fungsi langkah dan hiasi dengan`smp.step`.
1. Lakukan pasca-pemrosesan pada output di seluruh microbatch menggunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput)metode seperti. `reduce_mean` [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init)Fungsi harus memiliki nilai kembali yang tergantung pada output dari`smp.DistributedModel`.
1. [Jika ada langkah evaluasi, tempatkan logika penerusan di dalam fungsi `smp.step` -decorated dan pasca-proses output menggunakan API. `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput)
Untuk mempelajari lebih lanjut tentang API pustaka paralelisme model, lihat dokumentasi [API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html). SageMaker
Skrip Python berikut adalah contoh skrip pelatihan setelah perubahan dilakukan.
```
import tensorflow as tf
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return the model output
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
Jika Anda selesai mempersiapkan skrip pelatihan Anda, lanjutkan ke[Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK](model-parallel-sm-sdk.md). Jika Anda ingin menjalankan model hybrid dan pekerjaan pelatihan paralel data, lanjutkan ke bagian berikutnya.
## Pemisahan otomatis dengan TensorFlow dan Horovod untuk model hibrida dan paralelisme data
Anda dapat menggunakan perpustakaan paralelisme SageMaker model dengan Horovod untuk model hibrida dan paralelisme data. Untuk membaca lebih lanjut tentang bagaimana perpustakaan membagi model untuk paralelisme hibrida, lihat. [Paralelisme pipa (tersedia untuk PyTorch dan) TensorFlow](model-parallel-intro.md#model-parallel-intro-pp)
Pada langkah ini, kami fokus pada cara memodifikasi skrip pelatihan Anda untuk mengadaptasi perpustakaan paralelisme SageMaker model.
Untuk mengatur skrip pelatihan dengan benar untuk mengambil konfigurasi paralelisme hibrida yang akan Anda atur[Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK](model-parallel-sm-sdk.md), gunakan fungsi pembantu perpustakaan, `smp.dp_rank()` dan`smp.mp_rank()`, yang secara otomatis mendeteksi peringkat paralel data dan peringkat paralel model masing-masing.
Untuk menemukan semua primitif MPI yang didukung perpustakaan, lihat [Dasar MPI](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#mpi-basics) dalam dokumentasi Python SageMaker SDK.
Perubahan yang diperlukan dalam skrip adalah:
+ Menambahkan `hvd.allreduce`
+ Variabel penyiaran setelah batch pertama, seperti yang dipersyaratkan oleh Horovod
+ Operasi and/or sharding pengocokan penyemaian benih dalam pipa data dengan. `smp.dp_rank()`
**catatan**
Saat Anda menggunakan Horovod, Anda tidak boleh langsung memanggil skrip `hvd.init` pelatihan Anda. Sebagai gantinya, Anda harus mengatur `"horovod"` ke `True` dalam parameter SDK SageMaker `modelparallel` Python di. [Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK](model-parallel-sm-sdk.md) Hal ini memungkinkan perpustakaan untuk menginisialisasi Horovod secara internal berdasarkan penetapan perangkat partisi model. Memanggil `hvd.init()` langsung dalam skrip pelatihan Anda dapat menyebabkan masalah.
**catatan**
Menggunakan `hvd.DistributedOptimizer` API secara langsung di skrip pelatihan Anda dapat mengakibatkan kinerja dan kecepatan pelatihan yang buruk, karena API secara implisit menempatkan `AllReduce` operasi di dalamnya. `smp.step` Kami menyarankan Anda untuk menggunakan perpustakaan paralelisme model dengan Horovod dengan langsung memanggil `hvd.allreduce` setelah memanggil `accumulate()` atau `reduce_mean()` pada gradien yang dikembalikan dari`smp.step`, seperti yang akan ditunjukkan pada contoh berikut.
Untuk mempelajari lebih lanjut tentang API pustaka paralelisme model, lihat dokumentasi [API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html). SageMaker
```
import tensorflow as tf
import horovod.tensorflow as hvd
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: Seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return model outputs
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels, first_batch):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
# Horovod: AllReduce the accumulated gradients
gradients = [hvd.allreduce(g.accumulate()) for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Horovod: Broadcast the variables after first batch
if first_batch:
hvd.broadcast_variables(model.variables, root_rank=0)
hvd.broadcast_variables(optimizer.variables(), root_rank=0)
# smdistributed: Merge predictions across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for batch, (images, labels) in enumerate(train_ds):
loss = train_step(images, labels, tf.constant(batch == 0))
```
## Pemisahan manual dengan TensorFlow
Gunakan manajer `smp.partition` konteks untuk menempatkan operasi di partisi tertentu. Setiap operasi yang tidak ditempatkan dalam `smp.partition` konteks apa pun ditempatkan di. `default_partition` Untuk mempelajari lebih lanjut tentang API pustaka paralelisme model, lihat dokumentasi [API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html). SageMaker
```
import tensorflow as tf
# smdistributed: Import TF2.x API.
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches.
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API.
class MyModel(smp.DistributedModel):
def __init__(self):
# define layers
def call(self, x):
with smp.partition(0):
x = self.layer0(x)
with smp.partition(1):
return self.layer1(x)
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
## Fitur kerangka kerja yang tidak didukung
TensorFlow Fitur-fitur berikut tidak didukung oleh pustaka:
+ `tf.GradientTape()`saat ini tidak didukung. Anda dapat menggunakan `Optimizer.get_gradients()` atau `Optimizer.compute_gradients()` sebagai gantinya untuk menghitung gradien.
+ `tf.train.Checkpoint.restore()`API saat ini tidak didukung. Untuk checkpointing, gunakan `smp.CheckpointManager` sebagai gantinya, yang menyediakan API dan fungsionalitas yang sama. Perhatikan bahwa pemulihan pos pemeriksaan dengan `smp.CheckpointManager` harus dilakukan setelah langkah pertama.
# Memodifikasi Skrip PyTorch Pelatihan
Di bagian ini, Anda mempelajari cara memodifikasi skrip PyTorch pelatihan untuk mengonfigurasi pustaka paralelisme SageMaker model untuk partisi otomatis dan partisi manual.
**catatan**
Untuk menemukan PyTorch versi mana yang didukung oleh perpustakaan, lihat[Kerangka Kerja yang Didukung dan Wilayah AWS](distributed-model-parallel-support.md).
**Tip**
Untuk contoh end-to-end buku catatan yang menunjukkan cara menggunakan skrip PyTorch pelatihan dengan pustaka paralelisme SageMaker model, lihat. [Contoh perpustakaan paralelisme model Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
Perhatikan bahwa partisi otomatis diaktifkan secara default. Kecuali ditentukan lain, skrip berikut menggunakan partisi otomatis.
**Topics**
+ [Pemisahan otomatis dengan PyTorch](#model-parallel-customize-training-script-pt-16)
+ [Pemisahan manual dengan PyTorch](#model-parallel-customize-training-script-pt-16-hvd)
+ [Pertimbangan-pertimbangan](#model-parallel-pt-considerations)
+ [Fitur kerangka kerja yang tidak didukung](#model-parallel-pt-unsupported-features)
## Pemisahan otomatis dengan PyTorch
Perubahan skrip pelatihan berikut diperlukan untuk menjalankan skrip PyTorch pelatihan dengan pustaka SageMaker paralelisme model:
1. Impor dan inisialisasi perpustakaan dengan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Bungkus model dengan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel). Berhati-hatilah bahwa setiap tensor yang dikembalikan dari `forward` metode `nn.Module` objek yang mendasarinya akan disiarkan di seluruh perangkat model-paralel, menimbulkan overhead komunikasi, jadi tensor apa pun yang tidak diperlukan di luar metode panggilan (seperti aktivasi perantara) tidak boleh dikembalikan.
**catatan**
Untuk FP16 pelatihan, Anda perlu 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) () untuk membungkus model. Untuk informasi selengkapnya, lihat [FP16 Pelatihan dengan Model Paralelisme](model-parallel-extended-features-pytorch-fp16.md).
1. Bungkus pengoptimal dengan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer).
**catatan**
Untuk FP16 pelatihan, Anda perlu mengatur penskalaan kerugian statis atau dinamis. Untuk informasi selengkapnya, lihat [FP16 Pelatihan dengan Model Paralelisme](model-parallel-extended-features-pytorch-fp16.md).
1. Gunakan `DistributedModel` objek yang dikembalikan alih-alih model pengguna.
1. Letakkan logika maju dan mundur dalam fungsi langkah dan hiasi dengan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Batasi setiap proses ke perangkatnya sendiri melalui`torch.cuda.set_device(smp.local_rank())`.
1. Pindahkan tensor input ke GPU menggunakan `.to()` API sebelum `smp.step` panggilan (lihat contoh di bawah).
1. Ganti `torch.Tensor.backward` dan `torch.autograd.backward` dengan`DistributedModel.backward`.
1. Lakukan pasca-pemrosesan pada output di seluruh microbatch menggunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput)metode seperti. `reduce_mean`
1. [Jika ada langkah evaluasi, tempatkan logika penerusan di dalam fungsi `smp.step` -decorated dan pasca-proses output menggunakan API. `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput)
1. Ditetapkan `drop_last=True` di`DataLoader`. Atau, lewati batch secara manual dalam loop pelatihan jika ukuran batch tidak habis dibagi dengan jumlah microbatch.
Untuk mempelajari lebih lanjut tentang API pustaka paralelisme model, lihat dokumentasi [API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html). SageMaker
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
# define layers
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Pemisahan manual dengan PyTorch
Gunakan manajer [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer)konteks untuk menempatkan modul di perangkat tertentu. Modul apa pun yang tidak ditempatkan dalam `smp.partition` konteks apa pun ditempatkan di. `default_partition` `default_partition`Kebutuhan yang harus `auto_partition` disediakan jika diatur ke`False`. Modul yang dibuat dalam `smp.partition` konteks tertentu ditempatkan pada partisi yang sesuai.
Untuk mempelajari lebih lanjut tentang API pustaka paralelisme model, lihat dokumentasi [API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html). SageMaker
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
with smp.partition(0):
# define child modules on device 0
with smp.partition(1):
# define child modules on device 1
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Pertimbangan-pertimbangan
Saat Anda mengonfigurasi skrip PyTorch pelatihan menggunakan SageMaker pustaka paralelisme model, Anda harus mengetahui hal berikut:
+ Jika Anda menggunakan teknik optimasi yang bergantung pada norma gradien global, misalnya norma gradien dari seluruh model, seperti beberapa varian pengoptimal LAMB atau kliping gradien global, Anda perlu mengumpulkan semua norma di seluruh partisi model untuk kebenaran. Anda dapat menggunakan tipe data dasar komunikasi perpustakaan untuk melakukan hal ini.
+ Semua `torch.Tensor` argumen untuk metode penerusan `nn.Modules` dalam model Anda harus digunakan dalam perhitungan output modul. Dengan kata lain, perpustakaan tidak mendukung kasus di mana ada `torch.Tensor` argumen ke modul di mana output modul tidak bergantung.
+ Argumen untuk `smp.DistributedModel.backward()` panggilan harus bergantung pada semua output model. Dengan kata lain, tidak mungkin ada output dari `smp.DistributedModel.forward` panggilan yang tidak digunakan dalam perhitungan tensor yang dimasukkan ke dalam panggilan. `smp.DistributedModel.backward`
+ Jika ada `torch.cuda.synchronize()` panggilan dalam kode Anda, Anda mungkin perlu menelepon `torch.cuda.set_device(smp.local_rank())` segera sebelum panggilan sinkronisasi. Jika tidak, konteks CUDA yang tidak perlu dapat dibuat di perangkat 0, yang akan menghabiskan memori dengan sia-sia.
+ Karena perpustakaan ditempatkan `nn.Modules` pada perangkat yang berbeda, modul dalam model tidak boleh bergantung pada keadaan global apa pun yang dimodifikasi di dalamnya`smp.step`. Setiap keadaan yang tetap selama pelatihan, atau yang dimodifikasi `smp.step` di luar dengan cara yang terlihat oleh semua proses, diperbolehkan.
+ Anda tidak perlu memindahkan model ke GPU (misalnya, menggunakan`model.to(device)`) saat menggunakan perpustakaan. Jika Anda mencoba memindahkan model ke GPU sebelum model dipartisi (sebelum `smp.step` panggilan pertama), panggilan pindah akan diabaikan. Pustaka secara otomatis memindahkan bagian model yang ditetapkan ke peringkat ke GPU-nya. Setelah pelatihan dengan perpustakaan dimulai, jangan pindahkan model ke CPU dan gunakan, karena tidak akan memiliki parameter yang benar untuk modul yang tidak ditetapkan ke partisi yang dipegang oleh proses. Jika Anda ingin melatih ulang model atau menggunakannya untuk inferensi tanpa perpustakaan setelah dilatih menggunakan pustaka paralelisme model, cara yang disarankan adalah menyimpan model lengkap menggunakan API pos pemeriksaan kami dan memuatnya kembali ke Modul biasa. PyTorch
+ Jika Anda memiliki daftar modul sehingga output dari satu umpan ke yang lain, mengganti daftar itu dengan `nn.Sequential` dapat secara signifikan meningkatkan kinerja.
+ Pembaruan bobot (`optimizer.step()`) perlu terjadi di luar `smp.step` karena saat itulah seluruh backward pass selesai dan gradien sudah siap. Saat menggunakan model hybrid dengan model dan paralelisme data, pada titik ini, AllReduce gradien juga dijamin selesai.
+ Saat menggunakan library dalam kombinasi dengan paralelisme data, pastikan jumlah batch pada semua data parallel rank sama sehingga AllReduce tidak hang menunggu rank yang tidak berpartisipasi dalam langkah tersebut.
+ Jika Anda meluncurkan pekerjaan pelatihan menggunakan jenis instans ml.p4d (seperti ml.p4d.24xlarge), Anda harus menyetel variabel pemuat data. `num_workers=0` Misalnya, Anda dapat mendefinisikan `DataLoader` sebagai berikut:
```
dataloader = torch.utils.data.DataLoader(
data,
batch_size=batch_size,
num_workers=0,
pin_memory=True,
drop_last=True,
shuffle=shuffle,
)
```
+ Input `smp.step` harus menjadi input model yang dihasilkan oleh. `DataLoader` Ini karena `smp.step` secara internal membagi tensor input di sepanjang dimensi batch dan menyalurkannya. Ini berarti bahwa meneruskan `DataLoader` dirinya ke `smp.step` fungsi untuk menghasilkan input model di dalamnya tidak berfungsi.
Misalnya, jika Anda mendefinisikan `DataLoader` sebagai berikut:
```
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
```
Anda harus mengakses input model yang dihasilkan oleh `train_loader` dan meneruskannya ke fungsi yang `smp.step` didekorasi. Jangan `train_loader` langsung lolos ke `smp.step` fungsi.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
...
_, loss_mb = train_step(model, data, target)
...
@smp.step
def train_step(model, data, target):
...
return output, loss
```
+ Tensor input `smp.step` harus dipindahkan ke perangkat saat ini menggunakan `.to()` API, yang harus dilakukan setelah panggilan. `torch.cuda.set_device(local_rank())`
Misalnya, Anda dapat mendefinisikan `train` fungsi sebagai berikut. Fungsi ini menambahkan `data` dan `target` ke perangkat saat ini menggunakan `.to()` API sebelum menggunakan tensor input tersebut untuk memanggil. `train_step`
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
```
Tensor input ke fungsi yang `smp.set` didekorasi ini telah dipindahkan ke perangkat saat ini dalam `train` fungsi di atas. Model *tidak* perlu dipindahkan ke perangkat saat ini. Pustaka secara otomatis memindahkan bagian model yang ditetapkan ke peringkat ke GPU-nya.
```
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
```
## Fitur kerangka kerja yang tidak didukung
PyTorch Fitur-fitur berikut tidak didukung oleh pustaka SageMaker paralelisme model:
+ Jika Anda menggunakan paralelisme data dengan [PyTorch DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) asli, modul [https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)pembungkus tidak didukung oleh perpustakaan. Pustaka secara internal mengelola integrasi dengan PyTorch DDP, termasuk siaran parameter dan gradien. AllReduce Saat menggunakan perpustakaan, buffer modul hanya disiarkan sekali pada awal pelatihan. Jika model Anda memiliki buffer modul yang perlu disinkronkan di seluruh grup paralel data pada setiap langkah, Anda dapat melakukannya melalui `torch.distributed` API, menggunakan grup proses yang dapat diperoleh melalui. `smp.get_dp_process_group()`
+ Untuk pelatihan presisi campuran, `apex.amp` modul tidak didukung. Cara yang disarankan untuk menggunakan perpustakaan dengan presisi campuran otomatis adalah dengan menggunakan`torch.cuda.amp`, dengan pengecualian menggunakan `smp.amp.GradScaler` alih-alih implementasi dalam obor.
+ `torch.jit.ScriptModules`atau `ScriptFunctions` tidak didukung oleh`smp.DistributedModel`.
+ `apex`:`FusedLayerNorm`,`FusedAdam`,`FusedLAMB`, dan `FusedNovoGrad` dari `apex` tidak didukung. Anda dapat menggunakan implementasi perpustakaan ini melalui `smp.optimizers` dan `smp.nn` APIs sebagai gantinya.
# Langkah 2: Luncurkan Training Job Menggunakan SageMaker Python SDK
SageMaker Python SDK mendukung pelatihan terkelola model dengan kerangka kerja ML seperti dan. TensorFlow PyTorch [Untuk meluncurkan pekerjaan pelatihan menggunakan salah satu kerangka kerja ini, Anda mendefinisikan estimator, SageMaker [TensorFlow estimator](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator), atau SageMaker [PyTorch Estimator](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) SageMaker generik untuk menggunakan skrip pelatihan yang dimodifikasi dan konfigurasi paralelisme model.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator)
**Topics**
+ [Menggunakan SageMaker TensorFlow dan PyTorch Estimator](#model-parallel-using-sagemaker-pysdk)
+ [Perluas Container Docker Pra-built yang Berisi Perpustakaan Paralel Model SageMaker Terdistribusi](#model-parallel-customize-container)
+ [Buat Container Docker Anda Sendiri dengan Perpustakaan Paralel Model SageMaker Terdistribusi](#model-parallel-bring-your-own-container)
## Menggunakan SageMaker TensorFlow dan PyTorch Estimator
Kelas TensorFlow dan PyTorch estimator berisi `distribution` parameter, yang dapat Anda gunakan untuk menentukan parameter konfigurasi untuk menggunakan kerangka pelatihan terdistribusi. Pustaka paralel SageMaker model secara internal menggunakan MPI untuk data hibrida dan paralelisme model, jadi Anda harus menggunakan opsi MPI dengan perpustakaan.
Template berikut dari TensorFlow atau PyTorch estimator menunjukkan cara mengkonfigurasi `distribution` parameter untuk menggunakan SageMaker model parallel library dengan MPI.
------
#### [ Using the SageMaker TensorFlow estimator ]
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
smp_options = {
"enabled":True, # Required
"parameters": {
"partitions": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"horovod": True, # Use this for hybrid model and data parallelism
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = TensorFlow(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='2.6.3',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
#### [ Using the SageMaker PyTorch estimator ]
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": { # Required
"pipeline_parallel_degree": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"ddp": True,
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
Untuk mengaktifkan pustaka, Anda harus meneruskan kamus konfigurasi ke `"mpi"` kunci `"smdistributed"` dan melalui `distribution` argumen konstruktor SageMaker estimator.
**Parameter konfigurasi untuk SageMaker paralelisme model**
+ Untuk `"smdistributed"` kuncinya, berikan kamus dengan `"modelparallel"` kunci dan kamus batin berikut.
**catatan**
Menggunakan `"modelparallel"` dan `"dataparallel"` dalam satu pekerjaan pelatihan tidak didukung.
+ `"enabled"` – Wajib. Untuk mengaktifkan paralelisme model, atur. `"enabled": True`
+ `"parameters"` – Wajib. Tentukan satu set parameter untuk SageMaker paralelisme model.
+ Untuk daftar lengkap parameter umum, lihat [Parameter untuk `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) dalam dokumentasi *SageMaker Python SDK*.
Untuk TensorFlow, lihat [TensorFlow-Parameter spesifik](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters).
Untuk PyTorch, lihat [PyTorch-Parameter spesifik](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters).
+ `"pipeline_parallel_degree"`(atau `"partitions"` di`smdistributed-modelparallel
Untuk memperluas wadah pra-bangun dan menggunakan SageMaker pustaka paralelisme model, Anda harus menggunakan salah satu gambar AWS Deep Learning Containers (DLC) yang tersedia untuk atau. PyTorch TensorFlow Pustaka paralelisme SageMaker model termasuk dalam gambar DLC TensorFlow (2.3.0 dan yang lebih baru) dan PyTorch (1.6.0 dan yang lebih baru) dengan CUDA (). `cuxyz` Untuk daftar lengkap gambar DLC, lihat Gambar [Deep Learning Containers yang Tersedia](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) di repositori *AWS Deep Learning Containers GitHub *.
**Tip**
Kami menyarankan Anda menggunakan gambar yang berisi versi terbaru TensorFlow atau PyTorch untuk mengakses sebagian besar up-to-date versi pustaka paralelisme SageMaker model.
Misalnya, Dockerfile Anda harus berisi `FROM` pernyataan yang mirip dengan berikut ini:
```
# Use the SageMaker DLC image URI for TensorFlow or PyTorch
FROM aws-dlc-account-id.dkr.ecr.aws-region.amazonaws.com/framework-training:{framework-version-tag}
# Add your dependencies here
RUN ...
ENV PATH="/opt/ml/code:${PATH}"
# this environment variable is used by the SageMaker AI container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
```
Selain itu, ketika Anda mendefinisikan PyTorch atau TensorFlow estimator, Anda harus menentukan bahwa `entry_point` untuk skrip pelatihan Anda. Ini harus menjadi jalur yang sama yang diidentifikasi `ENV SAGEMAKER_SUBMIT_DIRECTORY` di Dockerfile Anda.
**Tip**
Anda harus mendorong wadah Docker ini ke Amazon Elastic Container Registry (Amazon ECR) dan menggunakan URI image (`image_uri`) untuk menentukan estimator untuk pelatihan. SageMaker Untuk informasi selengkapnya, lihat [Perluas Kontainer Pra-dibangun](prebuilt-containers-extend.md).
Setelah Anda selesai menghosting wadah Docker dan mengambil URI gambar wadah, buat objek SageMaker `PyTorch` estimator sebagai berikut. Contoh ini mengasumsikan bahwa Anda telah mendefinisikan `smp_options` dan`mpi_options`.
```
smd_mp_estimator = Estimator(
entry_point="your_training_script.py",
role=sagemaker.get_execution_role(),
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
image_uri='your_aws_account_id.dkr.ecr.region.amazonaws.com/name:tag'
instance_count=1,
distribution={
"smdistributed": smp_options,
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Buat Container Docker Anda Sendiri dengan Perpustakaan Paralel Model SageMaker Terdistribusi
Untuk membangun wadah Docker Anda sendiri untuk pelatihan dan menggunakan pustaka paralel SageMaker model, Anda harus menyertakan dependensi yang benar dan file biner dari pustaka SageMaker paralel terdistribusi di Dockerfile Anda. Bagian ini menyediakan kumpulan blok kode minimum yang harus Anda sertakan untuk mempersiapkan lingkungan SageMaker pelatihan dengan benar dan pustaka paralel model di wadah Docker Anda sendiri.
**catatan**
Opsi Docker khusus ini dengan pustaka paralel SageMaker model sebagai biner hanya tersedia untuk PyTorch.
**Untuk membuat Dockerfile dengan toolkit SageMaker pelatihan dan perpustakaan paralel model**
1. Mulailah dengan salah satu [gambar dasar NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda).
```
FROM
```
**Tip**
Gambar AWS Deep Learning Container (DLC) resmi dibuat dari gambar dasar [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Kami sarankan Anda melihat ke [Dockerfiles resmi dari AWS Deep Learning Container PyTorch untuk](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) menemukan versi pustaka mana yang perlu Anda instal dan cara mengonfigurasinya. Dockerfiles resmi lengkap, benchmark diuji, dan dikelola oleh tim layanan Deep Learning Container SageMaker dan Deep Learning. Di tautan yang disediakan, pilih PyTorch versi yang Anda gunakan, pilih folder CUDA (`cuxyz`), dan pilih Dockerfile yang diakhiri dengan atau. `.gpu` `.sagemaker.gpu`
1. [Untuk mengatur lingkungan pelatihan terdistribusi, Anda perlu menginstal perangkat lunak untuk perangkat komunikasi dan jaringan, seperti [Elastic Fabric Adapter (EFA), [NVIDIA Collective Communications Library (NCCL](https://developer.nvidia.com/nccl))](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), dan Open MPI.](https://www.open-mpi.org/) Bergantung pada versi PyTorch dan CUDA yang Anda pilih, Anda harus menginstal versi pustaka yang kompatibel.
**penting**
Karena pustaka paralel SageMaker model memerlukan pustaka paralel SageMaker data pada langkah berikutnya, kami sangat menyarankan Anda mengikuti instruksi di [Buat wadah Docker Anda sendiri dengan perpustakaan paralel data terdistribusi SageMaker AI](data-parallel-bring-your-own-container.md) untuk mengatur lingkungan SageMaker pelatihan dengan benar untuk pelatihan terdistribusi.
[Untuk informasi lebih lanjut tentang pengaturan EFA dengan NCCL dan Open MPI, lihat Memulai dengan EFA dan MPI dan [Memulai dengan EFA dan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) NCCL.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html)
1. Tambahkan argumen berikut untuk menentukan URLs paket pelatihan SageMaker terdistribusi untuk PyTorch. Pustaka paralel SageMaker model membutuhkan pustaka paralel SageMaker data untuk menggunakan cross-node Remote Direct Memory Access (RDMA).
```
ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
```
1. Instal dependensi yang dibutuhkan oleh pustaka SageMaker paralel model.
1. Instal perpustakaan [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview).
```
ARG METIS=metis-5.1.0
RUN rm /etc/apt/sources.list.d/* \
&& wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
&& gunzip -f ${METIS}.tar.gz \
&& tar -xvf ${METIS}.tar \
&& cd ${METIS} \
&& apt-get update \
&& make config shared=1 \
&& make install \
&& cd .. \
&& rm -rf ${METIS}.tar* \
&& rm -rf ${METIS} \
&& rm -rf /var/lib/apt/lists/* \
&& apt-get clean
```
1. Instal [perpustakaan RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Ini membutuhkan [CMake](https://cmake.org/)3,14 atau lebih baru.
```
ARG RMM_VERSION=0.15.0
RUN wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \
&& tar -xvf v${RMM_VERSION}.tar.gz \
&& cd rmm-${RMM_VERSION} \
&& INSTALL_PREFIX=/usr/local ./build.sh librmm \
&& cd .. \
&& rm -rf v${RMM_VERSION}.tar* \
&& rm -rf rmm-${RMM_VERSION}
```
1. Instal perpustakaan paralel SageMaker model.
```
RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
```
1. Instal perpustakaan paralel SageMaker data.
```
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```
1. Instal toolkit pelatihan [sagemaker](https://github.com/aws/sagemaker-training-toolkit). Toolkit berisi fungsionalitas umum yang diperlukan untuk membuat wadah yang kompatibel dengan platform SageMaker pelatihan dan SageMaker Python SDK.
```
RUN pip install sagemaker-training
```
1. Setelah Anda selesai membuat Dockerfile, lihat [Mengadaptasi Wadah Pelatihan Anda Sendiri untuk mempelajari cara membuat wadah](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) Docker dan menghostingnya di Amazon ECR.
**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).
# Checkpointing dan Fine-Tuning Model dengan Paralelisme Model
Pustaka paralelisme SageMaker model menyediakan pos pemeriksaan APIs untuk menyimpan status model dan status pengoptimal yang dibagi oleh berbagai strategi paralelisme model, dan untuk memuat pos pemeriksaan untuk pelatihan berkelanjutan dari tempat Anda ingin memulai ulang pelatihan dan menyempurnakan. Opsi APIs juga mendukung untuk menyimpan status model dan pengoptimal sebagian atau seluruhnya.
**Topics**
+ [Checkpointing model terdistribusi](#distributed-model-parallel-checkpoint)
+ [Menyetel model terdistribusi](#distributed-model-parallel-fine-tuning)
## Checkpointing model terdistribusi
Pilih salah satu topik berikut tergantung pada kerangka kerja antara PyTorch dan TensorFlow dan versi pustaka paralelisme SageMaker model yang Anda gunakan.
**Topics**
+ [Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model v1.10.0 dan yang lebih baru)](#model-parallel-extended-features-pytorch-checkpoint)
+ [Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model antara v1.6.0 dan v1.9.0)](#model-parallel-extended-features-pytorch-saving-loading-checkpoints)
+ [Checkpointing model terdistribusi TensorFlow](#distributed-model-parallel-checkpoint-tensorflow)
### Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model v1.10.0 dan yang lebih baru)
Pustaka paralelisme SageMaker model menyediakan pos pemeriksaan APIs untuk menyimpan dan memuat pos pemeriksaan penuh atau sebagian dari status model terdistribusi dan status pengoptimalnya.
**catatan**
Metode checkpointing ini direkomendasikan jika Anda menggunakan PyTorch dan pustaka paralelisme SageMaker model v1.10.0 atau yang lebih baru.
**Pos pemeriksaan sebagian**
Untuk menyimpan pos pemeriksaan model yang dilatih dengan paralelisme model, gunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint)API dengan opsi checkpointing sebagian yang disetel ke true (). `partial=True` Ini menghemat setiap partisi model satu per satu. Selain model dan status pengoptimal, Anda juga dapat menyimpan data kustom tambahan melalui `user_content` argumen. Model checkpoint, optimizer, dan konten pengguna disimpan sebagai file terpisah. Panggilan `save_checkpoint` API membuat folder pos pemeriksaan dalam struktur berikut.
```
- path
- ${tag}_partial (folder for partial checkpoints)
- model_rankinfo.pt
- optimizer_rankinfo.pt
- fp16_states_rankinfo.pt
- user_content.pt
- $tag (checkpoint file for full checkpoints)
- user_content_$tag (user_content file for full checkpoints)
- newest (a file that indicates the newest checkpoint)
```
Untuk melanjutkan pelatihan dari pos pemeriksaan sebagian, gunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint)API dengan`partial=True`, dan tentukan direktori pos pemeriksaan dan tag yang digunakan saat menyimpan pos pemeriksaan sebagian. Perhatikan bahwa pemuatan bobot model yang sebenarnya terjadi setelah partisi model, selama menjalankan pertama fungsi langkah pelatihan `smdistributed.modelparallel.torch.step` yang didekorasi.
Saat menyimpan pos pemeriksaan sebagian, perpustakaan juga menyimpan keputusan partisi model sebagai file dengan ekstensi `.pt` file. Sebaliknya, ketika melanjutkan dari pos pemeriksaan sebagian, perpustakaan memuat file keputusan partisi bersama-sama. Setelah keputusan partisi dimuat, Anda tidak dapat mengubah partisi.
Cuplikan kode berikut menunjukkan cara mengatur pos pemeriksaan APIs dalam skrip pelatihan. PyTorch
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=True,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=True
)
```
**Checkpointing penuh**
Untuk menyimpan artefak model akhir untuk tujuan inferensi, gunakan `smdistributed.modelparallel.torch.save_checkpoint` API dengan`partial=False`, yang menggabungkan partisi model untuk membuat artefak model tunggal. Perhatikan bahwa ini tidak menggabungkan status pengoptimal.
Untuk menginisialisasi pelatihan dengan bobot tertentu, dengan pos pemeriksaan model lengkap, Anda dapat menggunakan API dengan`smdistributed.modelparallel.torch.resume_from_checkpoint`. `partial=False` Perhatikan bahwa ini tidak memuat status pengoptimal.
**catatan**
Dengan paralelisme tensor, secara umum, `state_dict` harus diterjemahkan antara implementasi model asli dan implementasi. `DistributedModel` Secara opsional, Anda dapat memberikan fungsi `state_dict` terjemahan sebagai argumen untuk. `smdistributed.modelparallel.torch.resume_from_checkpoint` Namun, untuk[Model yang Didukung Di Luar Kotak](model-parallel-extended-features-pytorch-hugging-face.md#model-parallel-extended-features-pytorch-hugging-face-out-of-the-box), perpustakaan menangani terjemahan ini secara otomatis.
Kode berikut menunjukkan contoh cara menggunakan pos pemeriksaan APIs untuk memeriksa sepenuhnya model yang dilatih dengan PyTorch paralelisme model.
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=False,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=False
)
```
### Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model antara v1.6.0 dan v1.9.0)
Pustaka paralelisme SageMaker model menyediakan fungsi Python untuk menyimpan pos pemeriksaan sebagian atau penuh untuk pekerjaan pelatihan dengan paralelisme tensor. Prosedur berikut menunjukkan cara menggunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save)dan menyimpan dan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load)memuat pos pemeriksaan saat Anda menggunakan paralelisme tensor.
**catatan**
Metode checkpointing ini direkomendasikan jika Anda menggunakan PyTorch,[Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md), dan pustaka paralelisme SageMaker model antara v1.6.0 dan v1.9.0.
1. Siapkan objek model dan bungkus dengan fungsi `smp.DistributedModel()` pembungkus perpustakaan.
```
model = MyModel(...)
model = smp.DistributedModel(model)
```
1. Siapkan pengoptimal untuk model. Satu set parameter model adalah argumen iterable yang diperlukan oleh fungsi pengoptimal. Untuk menyiapkan satu set parameter model, Anda harus memproses `model.parameters()` untuk menetapkan unik IDs untuk parameter model individual.
Jika ada parameter dengan duplikat IDs dalam parameter model yang dapat diulang, memuat status pengoptimal checkpoint gagal. Untuk membuat parameter model yang dapat diulang dengan unik IDs untuk pengoptimal Anda, lihat yang berikut ini:
```
unique_params = []
unique_params_set = set()
for p in model.parameters():
if p not in unique_params_set:
unique_params.append(p)
unique_params_set.add(p)
del unique_params_set
optimizer = MyOpt(unique_params, ...)
```
1. Bungkus pengoptimal menggunakan fungsi pembungkus perpustakaan. `smp.DistributedOptimizer()`
```
optimizer = smp.DistributedOptimizer(optimizer)
```
1. Simpan model dan status pengoptimal menggunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save). Bergantung pada bagaimana Anda ingin menyimpan pos pemeriksaan, pilih salah satu dari dua opsi berikut:
+ **Opsi 1:** Simpan sebagian model pada masing-masing `mp_rank` untuk satu`MP_GROUP`.
```
model_dict = model.local_state_dict() # save a partial model
opt_dict = optimizer.local_state_dict() # save a partial optimizer state
# Save the dictionaries at rdp_rank 0 as a checkpoint
if smp.rdp_rank() == 0:
smp.save(
{"model_state_dict": model_dict, "optimizer_state_dict": opt_dict},
f"/checkpoint.pt",
partial=True,
)
```
Dengan paralelisme tensor, perpustakaan menyimpan file yang ditunjuk periksa yang dinamai dalam format berikut:. `checkpoint.pt_{pp_rank}_{tp_rank}`
**catatan**
Dengan paralelisme tensor, pastikan Anda mengatur pernyataan if sebagai `if smp.rdp_rank() == 0` pengganti. `if smp.dp_rank() == 0` Saat status pengoptimal dibagi dengan paralelisme tensor, semua peringkat paralel data tereduksi harus menyimpan partisi mereka sendiri dari status pengoptimal. Menggunakan pernyataan *if* yang salah untuk checkpointing dapat mengakibatkan pekerjaan pelatihan yang terhenti. *Untuk informasi selengkapnya tentang penggunaan paralelisme `if smp.dp_rank() == 0` tanpa tensor, lihat [Instruksi Umum untuk Menyimpan dan Memuat](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) dalam dokumentasi Python SageMaker SDK.*
+ **Opsi 2:** Simpan model lengkap.
```
if smp.rdp_rank() == 0:
model_dict = model.state_dict(gather_to_rank0=True) # save the full model
if smp.rank() == 0:
smp.save(
{"model_state_dict": model_dict},
"/checkpoint.pt",
partial=False,
)
```
**catatan**
Pertimbangkan hal berikut untuk pos pemeriksaan lengkap:
Jika Anda mengatur`gather_to_rank0=True`, semua peringkat selain `0` mengembalikan kamus kosong.
Untuk pos pemeriksaan penuh, Anda hanya dapat memeriksa model. Pemeriksaan penuh status pengoptimal saat ini tidak didukung.
Model lengkap hanya perlu disimpan di`smp.rank() == 0`.
1. Muat pos pemeriksaan menggunakan [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load). Bergantung pada bagaimana Anda memeriksa pada langkah sebelumnya, pilih salah satu dari dua opsi berikut:
+ **Opsi 1:** Muat pos pemeriksaan sebagian.
```
checkpoint = smp.load("/checkpoint.pt", partial=True)
model.load_state_dict(checkpoint["model_state_dict"], same_partition_load=False)
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
```
Anda dapat mengatur `same_partition_load=True` `model.load_state_dict()` untuk beban yang lebih cepat, jika Anda tahu bahwa partisi tidak akan berubah.
+ **Opsi 2:** Muat pos pemeriksaan penuh.
```
if smp.rdp_rank() == 0:
checkpoint = smp.load("/checkpoint.pt", partial=False)
model.load_state_dict(checkpoint["model_state_dict"])
```
`if smp.rdp_rank() == 0`Kondisi ini tidak diperlukan, tetapi dapat membantu menghindari pemuatan berlebihan di antara s yang berbeda`MP_GROUP`. Dict status pengoptimal pos pemeriksaan penuh saat ini tidak didukung dengan paralelisme tensor.
### Checkpointing model terdistribusi TensorFlow
Untuk menyimpan TensorFlow model saat berlatih dengan paralelisme model, gunakan fungsi berikut yang disediakan oleh perpustakaan paralelisme SageMaker model.
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model)
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager)
## Menyetel model terdistribusi
Penyetelan halus perlu dikonfigurasi dalam skrip pelatihan Anda. Cuplikan kode berikut menunjukkan contoh struktur skrip pelatihan menggunakan kelas [AutoModelForCausalLM](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM) dari Hugging Face Transformers dengan modifikasi untuk mendaftarkan `smdistributed.model.parallel.torch` modul dan pengaturan untuk fine-tuning.
**catatan**
Menyetel transformator terdistribusi (model Transformer yang dibungkus oleh`smp.DistributedModel()`) dengan fungsi [smp.delayed\$1param\$1initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) diaktifkan memerlukan pekerjaan fine-tuning untuk dikonfigurasi dengan sistem file for Lustre. FSx Dalam kasus di mana Anda ingin menyempurnakan model skala besar dengan opsi inisialisasi parameter tertunda, Anda harus menyiapkan sistem file FSx untuk Lustre.
```
import argparse
from transformers import AutoModelForCausalLM
import smdistributed.modelparallel
import smdistributed.modelparallel.torch as smp
def parse_args():
parser = argparse.ArgumentParser()
# set an arg group for model
model_grp = parser.add_argument_group(
title="model", description="arguments to describe model configuration"
)
... # set up numerous args to parse from the configuration dictionary to the script for training
# add arg for activating fine-tuning
model_grp.add_argument(
"--fine_tune",
type=int,
default=0,
help="Fine-tune model from checkpoint or pretrained model",
)
def main():
"""Main function to train GPT."""
args = parse_args()
... # parse numerous args
if args.fine_tune > 0 and args.delayed_param > 0 and smp.rank() == 0:
pretrained_model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
model_state_dict = pretrained_model.state_dict()
path = os.path.join(args.model_dir, "fullmodel.pt")
torch.save(model_state_dict, path)
# create a Transformer model and wrap by smp.model_creation()
# with options to configure model parallelism parameters offered by SageMaker AI
with smp.model_creation(
tensor_parallelism=smp.tp_size() > 1 or args.use_distributed_transformer > 0,
zero_init=args.use_distributed_transformer == 0,
dtype=dtype,
distribute_embedding=args.sharded_data_parallel_degree > 1 and smp.tp_size() > 1,
use_alibi=args.alibi > 0,
attention_in_fp32=args.attention_in_fp32 > 0,
fp32_residual_addition=args.residual_addition_in_fp32 > 0,
query_key_layer_scaling=args.query_key_layer_scaling > 0 and args.bf16 < 1,
fused_softmax=args.fused_softmax > 0,
fused_dropout=args.fused_dropout > 0,
fused_bias_gelu=args.fused_bias_gelu > 0,
flash_attention=args.flash_attention > 0,
):
if args.fine_tune > 0 and args.delayed_param == 0:
model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
else:
model = AutoModelForCausalLM.from_config(model_config)
# wrap the model by smp.DistributedModel() to apply SageMaker model parallelism
model = smp.DistributedModel(
model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation
)
# wrap the optimizer by smp.DistributedOptimizer() to apply SageMaker model parallelism
optimizer= ... # define an optimizer
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
)
# for fine-tuning, use smp.resume_from_checkpoint() to load a pre-trained model
if args.fine_tune > 0 and args.delayed_param > 0:
smp.resume_from_checkpoint(args.model_dir, tag="fullmodel.pt", partial=False)
```
*Untuk contoh lengkap skrip pelatihan dan notebook Jupyter, lihat contoh [GPT-2 di repositori Contoh AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2). PyTorch SageMaker GitHub*
# Contoh perpustakaan paralelisme model Amazon SageMaker AI v1
Halaman ini menyediakan daftar blog dan notebook Jupyter yang menyajikan contoh praktis penerapan pustaka SageMaker model paralelisme (SMP) v1 untuk menjalankan pekerjaan pelatihan terdistribusi pada AI. SageMaker
## Blog dan Studi Kasus
Blog berikut membahas studi kasus tentang penggunaan SMP v1.
+ [Peningkatan kinerja baru di perpustakaan paralelisme model Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/), *Blog AWS Machine Learning* (16 Desember 2022)
+ [Latih model raksasa dengan penskalaan hampir linier menggunakan paralelisme data sharded di Amazon AI SageMaker ,](https://aws.amazon.com/blogs/machine-learning/train-gigantic-models-with-near-linear-scaling-using-sharded-data-parallelism-on-amazon-sagemaker/) Machine *AWS Learning* Blog (31 Oktober 2022)
## Notebook contoh
Contoh notebook disediakan di [ GitHub repositori contoh SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/). Untuk mengunduh contoh, jalankan perintah berikut untuk mengkloning repositori dan pergi ke. `training/distributed_training/pytorch/model_parallel`
**catatan**
Kloning dan jalankan contoh notebook di SageMaker AI ML berikut. IDEs
[SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(tersedia di [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) yang dibuat setelah Desember 2023)
[SageMaker Editor Kode](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (tersedia di [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) yang dibuat setelah Desember 2023)
[Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (tersedia sebagai aplikasi di [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) yang dibuat setelah Desember 2023)
[SageMaker Instans Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html)
```
git clone https://github.com/aws/amazon-sagemaker-examples.git
cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel
```
**Notebook contoh SMP v1 untuk PyTorch**
+ [Latih GPT-2 dengan penskalaan linier dekat menggunakan teknik paralelisme data sharded di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-train-gpt-sharded-data-parallel.ipynb)
+ [Sempurnakan GPT-2 dengan penskalaan hampir linier menggunakan teknik paralelisme data sharded di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-fine-tune-gpt-sharded-data-parallel.ipynb)
+ [Latih GPT-Neox-20b dengan penskalaan linier dekat menggunakan teknik paralelisme data sharded di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-neox/smp-train-gpt-neox-sharded-data-parallel.ipynb)
+ [Latih GPT-J 6B menggunakan paralelisme data sharded dan teknik paralelisme tensor di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-j/smp-train-gptj-sharded-data-parallel-tp.ipynb)
+ [Latih FLAN-T5 dengan penskalaan linier dekat menggunakan teknik paralelisme data sharded di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/flan-t5/smp-train-t5-sharded-data-parallel.ipynb)
+ [Latih Falcon dengan penskalaan hampir linier menggunakan teknik paralelisme data sharded di perpustakaan paralelisme model SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/falcon/smp-train-falcon-sharded-data-parallel.ipynb)
**Notebook contoh SMP v1 untuk TensorFlow**
+ [CNN dengan TensorFlow 2.3.1 dan perpustakaan paralelisme SageMaker model](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/model_parallel/mnist/tensorflow_smmodelparallel_mnist.html)
+ [HuggingFace dengan Perpustakaan paralelisme model TensorFlow terdistribusi Pelatihan tentang AI SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb)
# SageMaker Praktik Terbaik Paralelisme Model Terdistribusi
Gunakan panduan berikut saat Anda menjalankan pekerjaan pelatihan terdistribusi dengan pustaka paralel SageMaker model.
## Menyiapkan Konfigurasi yang Tepat untuk Model yang Diberikan
Saat meningkatkan model, kami sarankan Anda untuk memeriksa daftar berikut secara berurutan. Setiap item daftar membahas keuntungan menggunakan teknik perpustakaan bersama dengan pengorbanan yang mungkin muncul.
**Tip**
Jika model dapat cocok dengan baik menggunakan subset fitur perpustakaan, menambahkan lebih banyak paralelisme model atau fitur penyimpanan memori biasanya tidak meningkatkan kinerja.
**Menggunakan tipe instans GPU yang besar**
+ Dalam bidang paralelisme model, yang terbaik adalah menggunakan instance yang kuat dengan memori GPU besar untuk menangani overhead dari operasi paralelisme model seperti mempartisi model di beberapa model. GPUs Kami merekomendasikan penggunaan `ml.p4d` atau `ml.p3dn` contoh untuk melatih model DL besar. Instans ini juga dilengkapi dengan Elastic Fabric Adapter (EFA), yang menyediakan bandwidth jaringan yang lebih tinggi dan memungkinkan pelatihan skala besar dengan paralelisme model.
**Status pengoptimal sharding**
+ Dampak status sharding optimizer tergantung pada jumlah peringkat paralel data. Biasanya, tingkat paralelisme data yang lebih tinggi (sebanding dengan ukuran node komputasi) dapat meningkatkan efisiensi penggunaan memori.
Saat Anda ingin mengurangi ukuran cluster, pastikan Anda memeriksa konfigurasi sharding status pengoptimal. Misalnya, model DL besar dengan sharding status pengoptimal yang cocok pada cluster komputasi dengan 16 GPUs (misalnya, dua instance P4d atau P4DE) mungkin tidak selalu cocok pada node dengan 8 GPUs (misalnya, satu contoh P4d atau P4DE). Ini karena memori gabungan 8 GPUs lebih rendah dari memori gabungan 16 GPUs, dan memori yang diperlukan per GPU untuk sharding lebih dari 8 GPUs juga lebih tinggi daripada memori per GPU untuk sharding selama skenario 16-GPU. Akibatnya, peningkatan kebutuhan memori mungkin tidak cocok dengan cluster yang lebih kecil.
Untuk informasi selengkapnya, lihat [Sharding Status Optimizer](model-parallel-extended-features-pytorch-optimizer-state-sharding.md).
**Pos pemeriksaan aktivasi**
+ Efisiensi memori dapat ditingkatkan dengan menggunakan checkpointing aktivasi untuk sekelompok modul. Semakin banyak Anda mengelompokkan modul, semakin efisien penggunaan memori. Saat memeriksa modul sekuensial untuk lapisan, `strategy` argumen `smp.set_activation_checkpointing` fungsi mengelompokkan lapisan bersama-sama untuk pemeriksaan. Misalnya, mengelompokkan dua atau lebih lapisan bersama-sama untuk checkpointing lebih efisien memori daripada checkpointing satu lapisan pada satu waktu, dan ini memperdagangkan waktu komputasi ekstra untuk mengurangi penggunaan memori.
Untuk informasi selengkapnya, lihat [Aktivasi Checkpointing](model-parallel-extended-features-pytorch-activation-checkpointing.md).
**Paralelisme tensor**
+ Derajat paralelisme tensor harus berupa kekuatan dua (2, 4, 8,..., 2 n), di mana derajat maksimum harus sama dengan jumlah GPUs per node. Misalnya, jika Anda menggunakan simpul dengan 8 GPUs, angka yang mungkin untuk derajat paralelisme tensor adalah 2, 4, dan 8. Kami tidak merekomendasikan angka arbitrer (seperti 3, 5, 6, dan 7) untuk tingkat paralelisme tensor. Saat Anda menggunakan beberapa node, salah mengonfigurasi tingkat paralelisme tensor dapat mengakibatkan menjalankan paralelisme tensor di seluruh node; ini menambahkan overhead yang signifikan dari komunikasi aktivasi di seluruh node dan dapat menjadi mahal secara komputasi.
Untuk informasi selengkapnya, lihat [Paralelisme Tensor](model-parallel-extended-features-pytorch-tensor-parallelism.md).
**Paralelisme pipa di seluruh node**
+ Anda dapat menjalankan paralelisme pipeline baik dalam satu node maupun di beberapa node. Saat Anda menggunakan paralelisme pipeline dalam kombinasi dengan paralelisme tensor, kami merekomendasikan menjalankan paralelisme pipeline di beberapa node dan menjaga paralelisme tensor dalam masing-masing node.
+ Paralelisme pipa dilengkapi dengan tiga tombol berikut:`microbatches`,, `active_microbatches` dan. `prescaled_batch`
+ Saat Anda menggunakan paralelisme tensor dengan paralelisme pipa, kami sarankan untuk mengaktifkan `prescaled_batch` sehingga ukuran batch per grup paralel model dapat ditingkatkan untuk pipelining yang efisien. Dengan `prescaled_batch` diaktifkan, ukuran batch yang ditetapkan dalam skrip pelatihan menjadi `tp_size` kali ukuran batch yang ditetapkan untuk setiap peringkat tanpa`prescaled_batch`.
+ Meningkatkan jumlah `microbatches` membantu mencapai pipelining yang efisien dan kinerja yang lebih baik. Perhatikan bahwa ukuran microbatch efektif adalah ukuran batch dibagi dengan jumlah microbatch. Jika Anda menambah jumlah microbatch sambil menjaga ukuran batch tetap konstan, setiap microbatch memproses lebih sedikit sampel.
+ Jumlah `active_microbatches` adalah jumlah maksimum microbatch yang secara bersamaan dalam proses selama pipelining. Untuk setiap microbatch aktif dalam proses, aktivasi dan gradiennya mengambil memori GPU. Oleh karena itu, peningkatan `active_microbatches` membutuhkan lebih banyak memori GPU.
+ Jika memori GPU dan GPU kurang dimanfaatkan, tingkatkan paralelisasi yang lebih baik `active_microbatches` selama pipelining.
+ Untuk informasi lebih lanjut tentang cara menggunakan paralelisme tensor dengan paralelisme pipa, lihat. [Paralelisme tensor dikombinasikan dengan paralelisme pipa](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
+ Untuk menemukan deskripsi parameter yang disebutkan di atas, lihat [Parameter untuk `smdistributed` dalam dokumentasi SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) *Python* SDK.
**Bongkar aktivasi ke CPU**
+ Pastikan bahwa ini digunakan dalam kombinasi dengan checkpointing aktivasi dan paralelisme pipa. Untuk memastikan bahwa pembongkaran dan pramuat terjadi di latar belakang, tentukan nilai yang lebih besar dari 1 ke parameter microbatches.
+ Saat membongkar aktivasi, Anda mungkin dapat meningkatkan `active_microbatches` dan terkadang cocok dengan jumlah total microbatch. Ini tergantung pada modul mana yang diperiksa dan bagaimana model dipartisi.
Untuk informasi selengkapnya, lihat [Pembongkaran Aktivasi](model-parallel-extended-features-pytorch-activation-offloading.md).
### Konfigurasi referensi
Tim pelatihan paralelisme SageMaker model menyediakan titik referensi berikut berdasarkan eksperimen dengan model GPT-2, panjang urutan 512, dan ukuran kosakata 50.000.
| Jumlah parameter model | Tipe instans | Paralelisme pipa | Paralelisme tensor | Sharding status pengoptimal | Pos pemeriksaan aktivasi | Batch berskala | Ukuran batch |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 10 miliar | 16 ml.p4d.24xlarge | 1 | 4 | True | Setiap lapisan transformator | True | batch\$1size=40 |
| 30 miliar | 16 ml.p4d.24xlarge | 1 | 8 | True | Setiap lapisan transformator | True | batch\$1size=32 |
| 60 miliar | 32 ml.p4d.24xlarge | 2 | 8 | True | Setiap lapisan transformator | True | batch\$1size=56, microbatches=4, active\$1microbatches=2 |
Anda dapat mengekstrapolasi dari konfigurasi sebelumnya untuk memperkirakan penggunaan memori GPU untuk konfigurasi model Anda. Misalnya, jika Anda menambah panjang urutan untuk model 10 miliar parameter atau meningkatkan ukuran model menjadi 20 miliar, Anda mungkin ingin menurunkan ukuran batch terlebih dahulu. Jika model masih tidak cocok, coba tingkatkan derajat paralelisme tensor.
## Memodifikasi Skrip Pelatihan Anda
+ Sebelum Anda menggunakan fitur pustaka paralel SageMaker model dalam skrip pelatihan Anda, tinjau[Tips dan Jebakan Konfigurasi Perpustakaan Paralelisme Model SageMaker Terdistribusi](model-parallel-customize-tips-pitfalls.md).
+ Untuk meluncurkan pekerjaan pelatihan lebih cepat, gunakan [mode lokal SageMaker AI](https://sagemaker.readthedocs.io/en/v2.199.0/overview.html?highlight=local%20mode#local-mode). Ini membantu Anda dengan cepat menjalankan pekerjaan pelatihan secara lokal pada instance SageMaker notebook. Bergantung pada skala instans ML tempat instance SageMaker notebook Anda berjalan, Anda mungkin perlu menyesuaikan ukuran model Anda dengan mengubah konfigurasi model, seperti lebar tersembunyi, jumlah lapisan transformator, dan kepala perhatian. Validasi jika model yang dikurangi berjalan dengan baik pada instance notebook sebelum menggunakan cluster besar untuk melatih model lengkap.
## Memantau dan Mencatat Pekerjaan Pelatihan Menggunakan Konsol SageMaker AI dan Amazon CloudWatch
[Untuk memantau metrik tingkat sistem seperti pemanfaatan memori CPU, pemanfaatan memori GPU, dan pemanfaatan GPU, gunakan visualisasi yang disediakan melalui konsol AI. SageMaker ](https://console.aws.amazon.com/sagemaker/)
1. Di panel navigasi kiri, pilih **Pelatihan**.
1. Pilih **pekerjaan Pelatihan**.
1. Di panel utama, pilih nama pekerjaan pelatihan yang ingin Anda lihat lebih jelasnya.
1. Jelajahi panel utama dan temukan bagian **Monitor** untuk melihat visualisasi otomatis.
1. Untuk melihat log pekerjaan pelatihan, pilih **Lihat log** di bagian **Monitor**. Anda dapat mengakses log pekerjaan pelatihan terdistribusi dari pekerjaan pelatihan di CloudWatch. **Jika Anda meluncurkan pelatihan terdistribusi multi-node, Anda akan melihat beberapa aliran log dengan tag dalam format algo-n-1234567890.** Aliran log **algo-1** melacak log pelatihan dari simpul utama (ke-0).
Untuk informasi selengkapnya, lihat [CloudWatch Metrik Amazon untuk Memantau dan Menganalisis Pekerjaan Pelatihan](training-metrics.md).
## Izin
Untuk menjalankan pekerjaan SageMaker pelatihan dengan paralelisme model atau [buku catatan contoh pelatihan SageMaker terdistribusi](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/index.html), pastikan Anda memiliki izin yang tepat dalam peran IAM Anda, seperti berikut ini:
+ Untuk digunakan [FSx untuk Lustre, tambahkan](https://aws.amazon.com/fsx/). [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess)
+ Untuk menggunakan Amazon S3 sebagai saluran data, tambahkan. [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess)
+ Untuk menggunakan Docker, buat wadah Anda sendiri, dan dorong ke Amazon ECR, tambahkan. [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess)
+ Untuk memiliki akses penuh untuk menggunakan seluruh rangkaian fitur SageMaker AI, tambahkan [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess).
# Tips dan Jebakan Konfigurasi Perpustakaan Paralelisme Model SageMaker Terdistribusi
Tinjau tips dan jebakan berikut sebelum menggunakan perpustakaan paralelisme model Amazon SageMaker AI. Daftar ini mencakup tips yang berlaku di seluruh kerangka kerja. Untuk TensorFlow dan tips PyTorch khusus, lihat [Memodifikasi skrip TensorFlow pelatihan](model-parallel-customize-training-script-tf.md) dan[Memodifikasi Skrip PyTorch Pelatihan](model-parallel-customize-training-script-pt.md), masing-masing.
## Ukuran Batch dan Jumlah Microbatch
+ Pustaka paling efisien ketika ukuran batch ditingkatkan. Untuk kasus penggunaan di mana model cocok dalam satu perangkat, tetapi hanya dapat dilatih dengan ukuran batch kecil, ukuran batch dapat dan harus ditingkatkan setelah perpustakaan terintegrasi. Paralelisme model menghemat memori untuk model besar, memungkinkan Anda berlatih menggunakan ukuran batch yang sebelumnya tidak sesuai dengan memori.
+ Memilih sejumlah microbatch yang terlalu kecil atau terlalu besar dapat menurunkan kinerja. Pustaka mengeksekusi setiap microbatch secara berurutan di setiap perangkat, sehingga ukuran microbatch (ukuran batch dibagi dengan jumlah microbatch) harus cukup besar untuk sepenuhnya memanfaatkan setiap GPU. Pada saat yang sama, efisiensi pipa meningkat dengan jumlah microbatch, jadi penting untuk mencapai keseimbangan yang tepat. Biasanya, titik awal yang baik adalah mencoba 2 atau 4 microbatch, meningkatkan ukuran batch ke batas memori, dan kemudian bereksperimen dengan ukuran batch yang lebih besar dan jumlah microbatch. Karena jumlah microbatch meningkat, ukuran batch yang lebih besar mungkin menjadi layak jika pipa interleaved digunakan.
+ Ukuran batch Anda harus selalu habis dibagi dengan jumlah microbatch. Perhatikan bahwa tergantung pada ukuran kumpulan data, terkadang batch terakhir dari setiap epoch dapat berukuran lebih kecil daripada yang lain, dan batch yang lebih kecil ini perlu dibagi dengan jumlah microbatch juga. Jika tidak, Anda dapat mengatur `drop_remainder=True` `tf.Dataset.batch()` panggilan (in TensorFlow), atau mengatur `DataLoader` (`drop_last=True`in PyTorch), sehingga batch kecil terakhir ini tidak digunakan. Jika Anda menggunakan API yang berbeda untuk pipeline data, Anda mungkin perlu melewati batch terakhir secara manual setiap kali tidak habis dibagi dengan jumlah microbatch.
## Partisi Manual
+ Jika Anda menggunakan partisi manual, perhatikan parameter yang digunakan oleh beberapa operasi dan modul dalam model Anda, seperti tabel penyematan dalam arsitektur transformator. Modul yang berbagi parameter yang sama harus ditempatkan di perangkat yang sama untuk kebenaran. Saat partisi otomatis digunakan, pustaka secara otomatis memberlakukan batasan ini.
## Persiapan Data
+ Jika model mengambil beberapa input, pastikan Anda menyemai operasi acak dalam pipeline data Anda (misalnya, pengocokan) dengan. `smp.dp_rank()` Jika kumpulan data sedang dipecah secara deterministik di seluruh perangkat paralel data, pastikan pecahan diindeks oleh. `smp.dp_rank()` Ini untuk memastikan bahwa urutan data yang terlihat pada semua peringkat yang membentuk partisi model konsisten.
## Mengembalikan Tensor dari `smp.DistributedModel`
+ Setiap tensor yang dikembalikan dari fungsi `smp.DistributedModel.call` (for TensorFlow) atau `smp.DistributedModel.forward` (for PyTorch) disiarkan ke semua peringkat lain, dari peringkat yang menghitung tensor tertentu. Akibatnya, tensor apa pun yang tidak diperlukan di luar metode panggilan dan penerusan (aktivasi menengah, misalnya) tidak boleh dikembalikan, karena ini menyebabkan komunikasi yang tidak perlu dan overhead memori dan merusak kinerja.
## `@smp.step`Dekorator
+ Jika fungsi `smp.step` -decorated memiliki argumen tensor yang tidak memiliki dimensi batch, nama argumen harus disediakan dalam `non_split_inputs` daftar saat memanggil. `smp.step` Ini mencegah perpustakaan mencoba membagi tensor menjadi microbatch. Untuk informasi selengkapnya lihat [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html)di dokumentasi API.
## Menunda Inisialisasi Parameter
Untuk model yang sangat besar lebih dari 100 miliar parameter, inisialisasi bobot melalui memori CPU dapat mengakibatkan out-of-memory kesalahan. Untuk menyiasatinya, perpustakaan menawarkan manajer `smp.delay_param_initialization` konteks. Ini menunda alokasi fisik parameter sampai mereka pindah ke GPU selama eksekusi pertama dari fungsi -decorated. `smp.step` Ini menghindari penggunaan memori CPU yang tidak perlu selama inisialisasi pelatihan. Gunakan manajer konteks saat Anda membuat objek model seperti yang ditunjukkan dalam kode berikut.
```
with smp.delay_param_initialization(enabled=True):
model = MyModel()
```
## Paralelisme Tensor untuk PyTorch
+ Jika Anda menggunakan benih untuk hasil deterministik, atur benih berdasarkan `smp.dp_rank()` (misalnya,`torch.manual_seed(42 + smp.dp_rank())`). Jika Anda tidak melakukan ini, partisi yang berbeda dari an `nn.Parameter` diinisialisasi dengan cara yang sama, memengaruhi konvergensi.
+ SageMakerperpustakaan paralelisme model menggunakan NCCL untuk mengimplementasikan kolektif yang diperlukan untuk distribusi modul. Khusus untuk model yang lebih kecil, jika terlalu banyak panggilan NCCL dijadwalkan pada GPU pada saat yang sama, penggunaan memori mungkin meningkat karena ruang tambahan yang digunakan oleh NCCL. Untuk mengatasi hal ini, `smp` membatasi panggilan NCCL sehingga jumlah operasi NCCL yang sedang berlangsung pada waktu tertentu kurang dari atau sama dengan batas yang diberikan. Batas defaultnya adalah 8, tetapi ini dapat disesuaikan menggunakan variabel lingkungan`SMP_NCCL_THROTTLE_LIMIT`. Jika Anda mengamati lebih banyak penggunaan memori daripada yang Anda harapkan saat menggunakan paralelisme tensor, Anda dapat mencoba mengurangi batas ini. Namun, memilih batas yang terlalu kecil dapat menyebabkan kerugian throughput. Untuk menonaktifkan throttling sama sekali, Anda dapat mengatur. `SMP_NCCL_THROTTLE_LIMIT=-1`
+ Identitas berikut, yang berlaku ketika derajat paralelisme tensor adalah 1, tidak berlaku ketika derajat paralelisme tensor lebih besar dari 1:. `smp.mp_size() * smp.dp_size() == smp.size()` Ini karena gugus paralel tensor merupakan bagian dari kelompok paralelisme model dan kelompok paralelisme data. Jika kode Anda memiliki referensi ke`mp_rank`,`mp_size`,`MP_GROUP`, dan sebagainya, dan jika Anda ingin bekerja hanya dengan grup paralel pipeline, Anda mungkin perlu mengganti referensi dengan`smp.pp_size()`. Identitas berikut selalu benar:
+ `smp.mp_size() * smp.rdp_size() == smp.size()`
+ `smp.pp_size() * smp.dp_size() == smp.size()`
+ `smp.pp_size() * smp.tp_size() * smp.rdp_size() == smp.size()`
+ Karena `smp.DistributedModel` pembungkus memodifikasi parameter model saat paralelisme tensor diaktifkan, pengoptimal harus dibuat setelah memanggil`smp.DistributedModel`, dengan parameter terdistribusi. Misalnya, berikut ini tidak berfungsi:
```
## WRONG
model = MyModel()
optimizer = SomeOptimizer(model.parameters())
model = smp.DistributedModel(model) # optimizer now has outdated parameters!
```
Sebagai gantinya, pengoptimal harus dibuat dengan parameter `smp.DistributedModel` sebagai berikut:
```
## CORRECT
model = smp.DistributedModel(MyModel())
optimizer = SomeOptimizer(model.optimizers())
```
+ Ketika modul diganti dengan mitra terdistribusi melalui paralelisme tensor, modul terdistribusi tidak mewarisi bobotnya dari modul asli, dan menginisialisasi bobot baru. Ini berarti bahwa, misalnya, jika bobot perlu diinisialisasi dalam panggilan tertentu (misalnya, melalui `load_state_dict` panggilan), ini perlu terjadi setelah `smp.DistributedModel` panggilan, setelah distribusi modul berlangsung.
+ Saat mengakses parameter modul terdistribusi secara langsung, perhatikan bahwa bobotnya tidak memiliki bentuk yang sama dengan modul aslinya. Sebagai contoh,
```
with smp.tensor_parallelism():
linear = nn.Linear(60, 60)
# will pass
assert tuple(linear.weight.shape) == (60, 60)
distributed_linear = smp.DistributedModel(linear)
# will fail. the number of input channels will have been divided by smp.tp_size()
assert tuple(distributed_linear.module.weight.shape) == (60, 60)
```
+ Penggunaan sangat `torch.utils.data.distributed.DistributedSampler` disarankan untuk paralelisme tensor. Ini memastikan bahwa setiap peringkat paralel data menerima jumlah sampel data yang sama, yang mencegah hang yang mungkin dihasilkan dari `dp_rank` s yang berbeda mengambil sejumlah langkah yang berbeda.
+ Jika Anda menggunakan `join` API `DistributedDataParallel` kelas untuk menangani kasus di mana peringkat paralel data yang berbeda memiliki jumlah batch yang berbeda, Anda masih perlu memastikan bahwa peringkat yang sama `TP_GROUP` memiliki jumlah batch yang sama; jika tidak, kolektif komunikasi yang digunakan dalam eksekusi terdistribusi modul dapat hang. PyTorch Peringkat yang berada di `TP_GROUP` s berbeda dapat memiliki jumlah batch yang berbeda, selama `join` API digunakan.
+ Jika Anda ingin memeriksa model Anda dan menggunakan paralelisme tensor, pertimbangkan hal berikut:
+ Untuk menghindari kondisi macet dan balapan saat menyimpan dan memuat model saat Anda menggunakan paralelisme tensor, pastikan Anda memanggil fungsi yang sesuai dari model berikut dan status pengoptimal di dalam peringkat paralelisme data yang dikurangi.
+ Jika Anda mentransisikan skrip paralel pipeline yang ada dan mengaktifkan tensor parallel untuk skrip, pastikan Anda memodifikasi `if smp.dp_rank() == 0` blok apa pun yang digunakan untuk menyimpan dan memuat dengan blok. `if smp.rdp_rank() == 0` Jika tidak, itu mungkin menyebabkan pekerjaan pelatihan Anda terhenti.
Untuk informasi lebih lanjut tentang checkpointing model dengan paralelisme tensor, lihat. [Checkpointing model terdistribusi](distributed-model-parallel-checkpointing-and-finetuning.md#distributed-model-parallel-checkpoint)
# Pemecahan Masalah Paralel Model
Jika Anda mengalami kesalahan, Anda dapat menggunakan daftar berikut untuk mencoba memecahkan masalah pekerjaan pelatihan Anda. Jika masalah berlanjut, hubungi [AWS Support](https://aws.amazon.com/premiumsupport).
**Topics**
+ [Pertimbangan untuk Menggunakan SageMaker Debugger dengan Model Parallelism Library SageMaker](#distributed-ts-model-parallel-debugger)
+ [Menyimpan Pos Pemeriksaan](#distributed-ts-model-parallel-checkpoints)
+ [Konvergensi Menggunakan Model Paralel dan TensorFlow](#distributed-ts-model-parallel-tf-convergence)
+ [Menghentikan atau Menghancurkan Pekerjaan Pelatihan Terdistribusi](#distributed-ts-model-parallel-training-issues)
+ [Menerima Kesalahan NCCL untuk Training Job PyTorch](#distributed-ts-model-parallel-nccl-error)
+ [Menerima `RecursionError` PyTorch Training Job](#distributed-ts-model-parallel-super-forward-not-supported)
## Pertimbangan untuk Menggunakan SageMaker Debugger dengan Model Parallelism Library SageMaker
SageMaker Debugger tidak tersedia untuk pustaka SageMaker paralelisme model. Debugger diaktifkan secara default untuk semua pekerjaan SageMaker TensorFlow dan PyTorch pelatihan, dan Anda mungkin melihat kesalahan yang terlihat seperti berikut:
```
FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/checkpoints/metadata.json.sagemaker-uploading
```
Untuk memperbaiki masalah ini, nonaktifkan Debugger dengan meneruskan `debugger_hook_config=False` saat membuat kerangka kerja `estimator` seperti yang ditunjukkan pada contoh berikut.
```
bucket=sagemaker.Session().default_bucket()
base_job_name="sagemaker-checkpoint-test"
checkpoint_in_bucket="checkpoints"
# The S3 URI to store the checkpoints
checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket)
estimator = TensorFlow(
...
distribution={"smdistributed": {"modelparallel": { "enabled": True }}},
checkpoint_s3_uri=checkpoint_s3_bucket,
checkpoint_local_path="/opt/ml/checkpoints",
debugger_hook_config=False
)
```
## Menyimpan Pos Pemeriksaan
Anda mungkin mengalami kesalahan berikut saat menyimpan pos pemeriksaan model besar di SageMaker AI:
```
InternalServerError: We encountered an internal error. Please try again
```
Ini bisa disebabkan oleh keterbatasan SageMaker AI saat mengunggah pos pemeriksaan lokal ke Amazon S3 selama pelatihan. Untuk menonaktifkan pos pemeriksaan di SageMaker AI, gunakan contoh berikut untuk mengunggah pos pemeriksaan secara eksplisit.
Jika Anda mengalami kesalahan sebelumnya, jangan gunakan `checkpoint_s3_uri` dengan panggilan. SageMaker `estimator` Saat menyimpan pos pemeriksaan untuk model yang lebih besar, kami sarankan untuk menyimpan pos pemeriksaan ke direktori khusus dan meneruskan yang sama ke fungsi pembantu (sebagai `local_path` argumen).
```
import os
def aws_s3_sync(source, destination):
"""aws s3 sync in quiet mode and time profile"""
import time, subprocess
cmd = ["aws", "s3", "sync", "--quiet", source, destination]
print(f"Syncing files from {source} to {destination}")
start_time = time.time()
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
end_time = time.time()
print("Time Taken to Sync: ", (end_time-start_time))
return
def sync_local_checkpoints_to_s3(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from local path to s3 """
import boto3
#check if local path exists
if not os.path.exists(local_path):
raise RuntimeError("Provided local path {local_path} does not exist. Please check")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(local_path, s3_uri)
return
def sync_s3_checkpoints_to_local(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from s3 to local path """
import boto3
#try to create local path if it does not exist
if not os.path.exists(local_path):
print(f"Provided local path {local_path} does not exist. Creating...")
try:
os.makedirs(local_path)
except Exception as e:
raise RuntimeError(f"Failed to create {local_path}")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(s3_uri, local_path)
return
```
Penggunaan fungsi pembantu:
```
#base_s3_uri - user input s3 uri or save to model directory (default)
#curr_host - to save checkpoints of current host
#iteration - current step/epoch during which checkpoint is saved
# save checkpoints on every node using local_rank
if smp.local_rank() == 0:
base_s3_uri = os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))
curr_host = os.environ['SM_CURRENT_HOST']
full_s3_uri = f'{base_s3_uri}/checkpoints/{curr_host}/{iteration}'
sync_local_checkpoints_to_s3(local_path=checkpoint_dir, s3_uri=full_s3_uri)
```
## Konvergensi Menggunakan Model Paralel dan TensorFlow
Saat Anda menggunakan pelatihan multi-node SageMaker AI dengan TensorFlow dan pustaka paralelisme model, kerugian mungkin tidak menyatu seperti yang diharapkan karena urutan file input pelatihan mungkin berbeda pada setiap node. Ini dapat menyebabkan peringkat yang berbeda dalam grup paralel model yang sama bekerja pada file input yang berbeda, menyebabkan inkonsistensi. Untuk mencegah hal ini, pastikan file input diurutkan dengan cara yang sama di semua peringkat sebelum dikonversi ke TensorFlow kumpulan data. Salah satu cara untuk mencapai ini adalah dengan mengurutkan nama file input dalam skrip pelatihan.
## Menghentikan atau Menghancurkan Pekerjaan Pelatihan Terdistribusi
Jika pekerjaan pelatihan Anda mengalami masalah macet, mogok, atau tidak merespons, baca item pemecahan masalah berikut untuk mengidentifikasi penyebab masalah tersebut. Jika Anda membutuhkan dukungan lebih lanjut, hubungi tim pelatihan SageMaker terdistribusi melalui [AWS Support](https://aws.amazon.com/premiumsupport).
+ Jika Anda melihat **pekerjaan pelatihan terdistribusi terhenti pada langkah inisialisasi NCCL**, pertimbangkan hal berikut:
+ Jika Anda menggunakan salah satu instans (`ml.p4d`atau `ml.p3dn` instance) yang mendukung EFA dengan VPC kustom dan subnetnya, pastikan bahwa grup keamanan yang digunakan memiliki koneksi masuk dan keluar untuk semua port ke dan dari SG yang sama. Anda juga umumnya memerlukan koneksi keluar ke IP apa pun sebagai aturan terpisah (untuk akses internet). Untuk menemukan petunjuk tentang cara menambahkan aturan masuk dan keluar untuk komunikasi EFA, lihat. [SageMaker AI mendistribusikan pekerjaan pelatihan yang terhenti selama inisialisasi](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-efa-sg)
+ Jika Anda melihat **pekerjaan pelatihan terdistribusi terhenti saat memeriksa** model lengkap, ini mungkin karena `state_dict()` panggilan pada model atau pengoptimal tidak dilakukan di semua peringkat dengan `rdp_rank()==0` (saat menggunakan paralelisme tensor) atau `dp_rank()==0` (saat hanya menggunakan paralelisme pipa). Peringkat ini perlu berkomunikasi untuk membangun pos pemeriksaan untuk diselamatkan. Masalah penghentian serupa juga dapat terjadi saat checkpointing pengoptimal sebagian jika diaktifkan. `shard_optimizer_state`
Untuk informasi selengkapnya tentang checkpointing model dengan paralelisme model, lihat [Instruksi Umum untuk Menyimpan](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) dan Memuat dan. [Checkpointing PyTorch model terdistribusi (untuk pustaka paralelisme SageMaker model antara v1.6.0 dan v1.9.0)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-saving-loading-checkpoints)
+ Jika pekerjaan pelatihan macet dengan **kesalahan CUDA Out of Memory**, ini berarti bahwa konfigurasi pelatihan terdistribusi perlu disesuaikan agar sesuai dengan model pada cluster GPU. Untuk informasi lebih lanjut dan praktik terbaik, lihat[Menyiapkan Konfigurasi yang Tepat untuk Model yang Diberikan](model-parallel-best-practices.md#model-parallel-best-practices-configuration).
+ Jika pekerjaan pelatihan macet dengan **[kesalahan ECC](https://docs.nvidia.com/deploy/a100-gpu-mem-error-mgmt/index.html) yang tidak dapat diperbaiki**, ini berarti bahwa salah satu GPUs di cluster menjadi buruk. Jika Anda memerlukan dukungan teknis, bagikan pekerjaan ARN dengan AWS tim dan mulai ulang pekerjaan pelatihan Anda dari pos pemeriksaan jika memungkinkan.
+ Dalam kasus yang jarang terjadi, konfigurasi pekerjaan yang bekerja sebelumnya tetapi mendekati batas memori GPU mungkin gagal nanti dengan cluster yang berbeda karena kesalahan **CUDA Out of Memory**. Ini bisa jadi karena beberapa GPU memiliki memori yang tersedia lebih rendah dari biasanya karena kesalahan ECC.
+ **Kerusakan batas waktu jaringan** mungkin terjadi saat menjalankan pekerjaan multinode yang tidak menggunakan semua GPUs di node. Untuk menyiasatinya, gunakan semua GPUs pada node dengan memastikan bahwa `processes_per_host` parameter diatur ke jumlah GPUs dalam setiap instance. Misalnya, ini `processes_per_host=8` untuk`ml.p3.16xlarge`,`ml.p3dn.24xlarge`, dan `ml.p4d.24xlarge` contoh.
+ Jika Anda menemukan bahwa pekerjaan pelatihan Anda membutuhkan waktu lama selama tahap pengunduhan data, pastikan jalur Amazon S3 yang Anda berikan `checkpoint_s3_uri` untuk SageMaker `Estimator` kelas tersebut unik untuk pekerjaan pelatihan saat ini. Jika jalur ini digunakan kembali di beberapa pekerjaan pelatihan yang berjalan secara bersamaan, semua pos pemeriksaan tersebut diunggah dan diunduh ke jalur Amazon S3 yang sama dan mungkin secara signifikan meningkatkan waktu pemuatan pos pemeriksaan.
+ Gunakan FSx untuk Lustre ketika Anda berurusan dengan data besar dan model.
+ [Jika kumpulan data Anda besar dan mengambilnya membutuhkan waktu lama, kami sarankan untuk menyimpan kumpulan data Anda untuk Lustre. FSx ](https://aws.amazon.com/fsx/lustre/)
+ Ketika model pelatihan melebihi 10 miliar parameter, kami sarankan menggunakan Lustre FSx untuk pos pemeriksaan.
+ Setelah Anda membuat sistem file, pastikan untuk menunggu status **tersedia** sebelum memulai pekerjaan pelatihan menggunakannya.
## Menerima Kesalahan NCCL untuk Training Job PyTorch
Jika Anda mengalami kesalahan berikut, mungkin karena proses kehabisan memori GPU.
```
NCCL error in: ../torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8
ncclSystemError: System call (socket, malloc, munmap, etc) failed.
```
Anda dapat mengatasi ini dengan mengurangi ukuran batch atau`active_microbatches`. Jika partisi otomatis tidak menghasilkan partisi yang seimbang, Anda mungkin harus mempertimbangkan partisi manual. Untuk informasi selengkapnya, lihat [Paralelisme pipa di seluruh node](model-parallel-best-practices.md#model-parallel-best-practices-configuration-pipeline-across-nodes).
## Menerima `RecursionError` PyTorch Training Job
Pustaka tidak mendukung pemanggilan `super.forward()` di dalam panggilan penerusan modul. Jika Anda menggunakan`super.forward()`, Anda mungkin menerima pesan galat berikut.
```
RecursionError: maximum recursion depth exceeded
```
Untuk memperbaiki kesalahan, alih-alih menelepon`super.forward()`, Anda harus menelepon`super()._orig_forward()`.