Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # 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.