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

Paralelisme Data Terpecah-pecah

Paralelisme data tersharded adalah teknik pelatihan terdistribusi hemat memori yang membagi keadaan model (parameter model, gradien, dan status pengoptimal) di seluruh GPU dalam grup paralel data.

Saat meningkatkan pekerjaan pelatihan Anda ke cluster GPU besar, Anda dapat mengurangi jejak memori per GPU model dengan memecah status pelatihan model melalui beberapa GPU. 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 GPU dalam grup paralel data, dan melakukan agregasi gradien berdasarkan operasi. AllReduce Paralelisme data terpecah-pecah memodifikasi prosedur pelatihan terdistribusi data-paralel standar untuk memperhitungkan sifat terpecah-pecah dari status pengoptimal. Sekelompok peringkat di mana status model dan pengoptimal dipecah disebut grup sharding. Teknik paralelisme data terpecah-pecah memecah parameter model yang dapat dilatih dan gradien yang sesuai serta status pengoptimal di seluruh GPU dalam grup sharding.

SageMaker AI mencapai paralelisme data terpecah-pecah melalui implementasi MIC, yang dibahas dalam Near-linear penskalaan posting AWS blog pelatihan model raksasa. AWS Dalam implementasi ini, Anda dapat mengatur derajat sharding sebagai parameter yang dapat dikonfigurasi, yang harus kurang dari derajat paralelisme data. Selama setiap lintasan maju dan mundur, MIC untuk sementara menggabungkan kembali parameter model di semua GPU melalui operasi. AllGather Setelah melewati maju atau mundur dari setiap lapisan, MIC memecah parameter lagi untuk menghemat memori GPU. Selama lintasan mundur, MIC mengurangi gradien dan secara bersamaan memecahnya di seluruh GPU melalui operasi. ReduceScatter Akhirnya, MIC menerapkan gradien tereduksi dan terpecah-pecah lokal ke pecahan parameter lokal yang sesuai, menggunakan pecahan lokal status pengoptimal. Untuk menurunkan overhead komunikasi, pustaka paralelisme SageMaker model mengambil terlebih dahulu lapisan yang akan datang dalam lintasan maju atau mundur, dan tumpang tindih komunikasi jaringan dengan komputasi.

Status pelatihan model direplikasi di seluruh kelompok sharding. Ini berarti bahwa sebelum gradien diterapkan ke parameter, AllReduce operasi harus dilakukan di seluruh grup sharding, selain ReduceScatter operasi yang terjadi di dalam grup sharding.

Akibatnya, paralelisme data sharded memperkenalkan pertukaran 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 derajat paralelisme data sharded, sehingga model yang lebih besar dapat muat dalam cluster GPU.

Memilih tingkat paralelisme data terpecah-pecah

Ketika Anda memilih nilai untuk tingkat paralelisme data terpecah-pecah, nilainya harus secara merata membagi tingkat paralelisme data. Misalnya, untuk pekerjaan paralelisme data 8 arah, pilih 2, 4, atau 8 untuk derajat paralelisme data sharded. Saat memilih derajat paralelisme data sharded, kami sarankan Anda mulai dengan jumlah kecil, dan secara bertahap meningkatkannya sampai model cocok dengan memori bersama dengan ukuran batch yang diinginkan.

Memilih ukuran batch

Setelah menyiapkan paralelisme data sharded, pastikan Anda menemukan konfigurasi pelatihan paling optimal yang dapat berhasil dijalankan pada cluster GPU. Untuk melatih model bahasa besar (LLM), mulailah dari ukuran batch 1, dan tingkatkan secara bertahap hingga Anda mencapai titik untuk menerima kesalahan out memory (OOM). Jika Anda mengalami kesalahan OOM bahkan dengan ukuran batch terkecil, terapkan tingkat paralelisme data sharded yang lebih tinggi atau kombinasi paralelisme data sharded dan paralelisme tensor.

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 ModelTrainer dengan parameter spesifik sharded-data-parallelism-. Juga pertimbangkan untuk mengambil nilai referensi dan contoh buku catatan sebagai titik awal.

Sesuaikan skrip PyTorch pelatihan Anda

Ikuti petunjuk pada Langkah 1: Ubah Skrip Pel PyTorch atihan untuk membungkus objek model dan pengoptimal dengan pem smdistributed.modelparallel.torch bungkus modul torch.nn.parallel dantorch.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 agar SMP mengumpulkan parameter lengkap sementara. Untuk mendaftarkan parameter ke modul, gunakansmp.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 ModelTrainer

Saat mengonfigurasi SageMaker PyTorch ModelTrainer inLangkah 2: Luncurkan Pekerjaan Pelatihan Menggunakan SageMaker Python SDK, tambahkan parameter untuk paralelisme data sharded.

Untuk mengaktifkan paralelisme data sharded, tambahkan sharded_data_parallel_degree parameter ke. SageMaker PyTorch ModelTrainer Parameter ini menentukan jumlah GPU 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 perpustakaan secara otomatis mendeteksi jumlah GPU sehingga tingkat data paralel. Parameter tambahan berikut tersedia untuk mengonfigurasi paralelisme data sharded.

Kode berikut menunjukkan contoh bagaimana mengkonfigurasi paralelisme data sharded.

import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.train.configs import SourceCode, Compute, InputData
from sagemaker.core import image_uris
from sagemaker.core.helper.session_helper import get_execution_role

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
}

# Retrieve the training image for the desired PyTorch version
training_image = image_uris.retrieve(
    framework="pytorch",
    region="us-west-2",
    version='1.13.1',
    py_version='py3',
    instance_type='ml.p3.16xlarge',
    image_scope="training"
)

smp_model_trainer = ModelTrainer(
    training_image=training_image,
    source_code=SourceCode(entry_script="your_training_script.py"),
    role=get_execution_role(),
    compute=Compute(
        instance_type='ml.p3.16xlarge',
        instance_count=1
    ),
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-job"
)

smp_model_trainer.train(input_data_config=[
    InputData(channel_name="training", data_source='s3://my_bucket/my_training_data/')
])

Konfigurasi referensi

Tim pelatihan ter SageMaker distribusi 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 terpecah-pecah dengan Kolektif SMDDP

Misalnya, jika Anda meningkatkan panjang urutan untuk model parameter 20 miliar atau meningkatkan 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 tingkat paralelisme model.

Paralelisme data terpecah-pecah dengan paralelisme tensor dan Kolektif NCCL

Penggunaan gabungan paralelisme data sharded dan paralelisme tensor berguna ketika Anda ingin menyesuaikan 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 LLM terhadap urutan teks yang lebih panjang. Untuk mempelajari selengkapnya, lihat Paralelisme data terpecah-pecah dengan paralelisme tensor.

Untuk studi kasus, tolok ukur, dan contoh konfigurasi lainnya, lihat posting blog Pen ingkatan kinerja baru di pust SageMaker aka paralel model Amazon AI.

Paralelisme data terpecah-pecah dengan Kolektif SMDDP

Pust SageMaker aka paralelisme data menawarkan primitif komunikasi kolektif (kolektif SMDDP) yang dioptimalkan untuk infrastruktur. AWS Ini mencapai pengoptimalan dengan mengadopsi pola komunikasi all-to-all-to-all-type dengan memanfaatkan Elastic Fabric Adapter (EFA), menghasilkan kolektif throughput tinggi dan kurang sensitif latensi, menurunkan pemrosesan terkait komunikasi ke CPU, dan membebaskan siklus GPU untuk komputasi. Pada cluster besar, Kolektif SMDDP dapat menawarkan peningkatan kinerja pelatihan terdistribusi hingga 40% dibandingkan dengan NCCL. Untuk studi kasus dan hasil benchmark, lihat blog Peningkatan kinerja baru di pustaka paralelisme model Amazon SageMaker AI.

Dalam paralelisme data sharded, yang merupakan teknik yang umum digunakan dalam pelatihan terdistribusi skala besar, AllGather kolektif digunakan untuk menyusun kembali parameter lapisan tersharded untuk perhitungan pass maju dan mundur, secara paralel dengan komputasi GPU. Untuk model besar, melakukan AllGather operasi secara efisien sangat penting untuk menghindari masalah hambatan GPU dan memperlambat kecepatan pelatihan. Ketika paralelisme data sharded diaktifkan, Kolektif SMDDP masuk ke kolektif penting kinerja ini, meningkatkan throughput pelatihan. AllGather

Berlatih dengan Kolektif SMDDP

Ketika pekerjaan pelatihan Anda telah mengaktifkan paralelisme data sharded dan memenuhi persyaratanSupported configurations, Kolektif SMDDP secara otomatis diaktifkan. Secara internal, Kolektif SMDDP mengoptimalkan AllGather kolektif agar berkinerja pada AWS infrastruktur dan kembali ke NCCL untuk semua kolektif lainnya. Selanjutnya, di bawah konfigurasi yang tidak didukung, semua kolektif, termasukAllGather, secara otomatis menggunakan backend NCCL.

Sejak pust SageMaker aka model paralelisme versi 1.13.0, "ddp_dist_backend" parameter ditambahkan ke opsi. modelparallel Nilai default untuk parameter konfigurasi ini adalah"auto", yang menggunakan Kolektif SMDDP bila memungkinkan, dan kembali ke NCCL jika tidak. Untuk memaksa perpustakaan untuk selalu menggunakan NCCL, tentukan "nccl" ke parameter "ddp_dist_backend" konfigurasi.

Contoh kode berikut menunjukkan cara mengatur PyTorch ModelTrainer menggunakan paralelisme data sharded dengan "ddp_dist_backend" parameter, yang diatur secara default dan, "auto" oleh karena itu, opsional untuk ditambahkan.

import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.train.configs import SourceCode, Compute, InputData
from sagemaker.core import image_uris
from sagemaker.core.helper.session_helper import get_execution_role

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
}

# Retrieve the training image for the desired PyTorch version
training_image = image_uris.retrieve(
    framework="pytorch",
    region="us-west-2",
    version='1.13.1',
    py_version='py3',
    instance_type='ml.p4d.24xlarge',
    image_scope="training"
)

smd_mp_model_trainer = ModelTrainer(
    training_image=training_image,
    source_code=SourceCode(
        source_dir="location_to_your_script",
        entry_script="your_training_script.py"
    ),
    role=get_execution_role(),
    compute=Compute(
        instance_type='ml.p4d.24xlarge',
        instance_count=8
    ),
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-demo",
)

smd_mp_model_trainer.train(input_data_config=[
    InputData(channel_name="training", data_source='s3://my_bucket/my_training_data/')
])

Konfigurasi yang didukung

AllGatherOperasi dengan Kolektif SMDDP diaktifkan dalam pekerjaan pelatihan ketika semua persyaratan konfigurasi berikut terpenuhi.

Penyetelan kinerja dan memori

Kolektif SMDDP menggunakan memori GPU tambahan. Ada dua variabel lingkungan untuk mengkonfigurasi penggunaan memori GPU tergantung pada kasus penggunaan pelatihan model yang berbeda.

Panduan penyetelan pada variabel ukuran buffer

Nilai default untuk variabel lingkungan harus bekerja dengan baik untuk sebagian besar kasus penggunaan. Kami merekomendasikan penyetelan variabel ini hanya jika pelatihan mengalami kesalahan kehabisan memori (OOM).

Daftar berikut membahas beberapa tips penyetelan untuk mengurangi jejak memori GPU dari Kolektif SMDDP sambil mempertahankan peningkatan kinerja darinya.

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 mendapatkan manfaat dari peningkatan kinerja.

Kode berikut menunjukkan bagaimana Anda dapat mengkonfigurasi variabel lingkungan dengan menambahkannya ke mpi_options dalam parameter distribusi untuk. PyTorch ModelTrainer

import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.core.helper.session_helper import get_execution_role

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"

# Retrieve the training image for the desired PyTorch version
training_image = image_uris.retrieve(
    framework="pytorch",
    region="us-west-2",
    version='1.13.1',
    py_version='py3',
    instance_type='ml.p4d.24xlarge',
    image_scope="training"
)

smd_mp_model_trainer = ModelTrainer(
    training_image=training_image,
    source_code=SourceCode(
        source_dir="location_to_your_script",
        entry_script="your_training_script.py"
    ),
    role=get_execution_role(),
    compute=Compute(
        instance_type='ml.p4d.24xlarge',
        instance_count=8
    ),
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-demo-with-tuning",
)

smd_mp_model_trainer.train(input_data_config=[
    InputData(channel_name="training", data_source='s3://my_bucket/my_training_data/')
])

Pelatihan presisi campuran dengan paralelisme data terpecah-pecah

Untuk lebih menghemat memori GPU dengan angka float point setengah presisi dan paralelisme data sharded, Anda dapat mengaktifkan format titik mengambang 16-bit (FP16) atau format titik mengambang otak (BF16) dengan menambahkan satu parameter tambahan ke konfigurasi pelatihan terdistribusi.

Untuk Pelatihan FP16 dengan Paralelisme Data Sharded

Untuk menjalankan pelatihan FP16 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 Pelatihan FP16 dengan Model Paralelisme.

smp_options = {
    "enabled": True,
    "parameters": {
        "ddp": True,
        "sharded_data_parallel_degree": 2,
        "fp16": True
    }
}

Untuk Pelatihan BF16 dengan Paralelisme Data Sharded

Fitur paralelisme data sharded dari SageMaker AI mendukung pelatihan dalam tipe data BF16. Tipe data BF16 menggunakan 8 bit untuk mewakili eksponen angka float point, sedangkan tipe data FP16 menggunakan 5 bit. Mempertahankan 8 bit untuk eksponen memungkinkan untuk mempertahankan representasi yang sama dari eksponen nomor titik mengambang presisi tunggal 32-bit (FP32). Hal ini membuat konversi antara FP32 dan BF16 lebih sederhana dan secara signifikan kurang rentan menyebabkan masalah luapan dan luapan yang sering muncul dalam pelatihan FP16, terutama ketika melatih model yang lebih besar. Sementara kedua tipe data menggunakan total 16 bit, peningkatan rentang representasi untuk eksponen dalam format BF16 ini mengorbankan presisi yang berkurang. Untuk melatih model besar, presisi yang berkurang ini sering dianggap sebagai pertukaran yang dapat diterima untuk jangkauan dan stabilitas pelatihan.

Untuk menjalankan pelatihan BF16 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 terpecah-pecah dengan paralelisme tensor

Jika Anda menggunakan paralelisme data sharded dan juga perlu mengurangi ukuran batch global, pertimbangkan untuk menggunakan paralelisme tensor dengan paralel isme data sharded. Saat melatih model besar dengan paralelisme data terpecah-pecah 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 rendah. Mengurangi ukuran batch per GPU terkadang tidak mungkin dilakukan 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 derajat paralel data sharded dan paralel tensor yang optimal tergantung pada skala model, jenis instance, dan ukuran batch global yang masuk akal bagi model untuk konvergen. Kami menyarankan Anda memulai dari derajat paralel tensor rendah agar sesuai dengan ukuran batch global ke dalam cluster komputasi untuk menyelesaikan kesalahan kehabisan memori 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 GPU untuk paralelisme model, menghasilkan jumlah replika model yang lebih rendah dan ukuran batch global yang lebih kecil.

Contoh 1

Asumsikan bahwa kita ingin melatih model di atas cluster 1536 GPU (192 node dengan 8 GPU di masing-masing), 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 ke 4. Ini membentuk 192 kelompok paralel tensor atau 192 replika model, di mana setiap replika model didistribusikan di 8 GPU. Ukuran batch 4 adalah jumlah data pelatihan per iterasi dan per kelompok paralel tensor; Artinya, 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 terpecah-pecah 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 GPU dengan derajat paralel tensor 4 (membentuk kelompok 4 GPU), tingkat paralel data terpecah-pecah 4, berakhir dengan tingkat replikasi 2. Tugas 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 GPU membentuk satu kelompok paralel tensor. Dalam hal ini, grup paralel data yang dikurangi untuk GPU peringkat 0 dari kelompok paralel tensor adalah. (0,4,8,12,16,20,24,28) Grup paralel data yang dikurangi dipecah berdasarkan derajat paralel data terpecah-pecah sebesar 4, menghasilkan dua grup replikasi untuk paralelisme data. GPU (0,4,8,12) membentuk satu grup sharding, yang secara kolektif menyimpan salinan lengkap dari semua parameter untuk peringkat paralel tensor ke-0, dan GPU (16,20,24,28) membentuk grup lain seperti itu. Peringkat paralel tensor lainnya juga memiliki kelompok sharding dan replikasi yang serupa.

Gambar 1: Kelompok paralelisme tensor untuk (node, derajat paralel data terpecah-pecah, derajat paralel tensor) = (4, 4, 4), di mana setiap persegi panjang mewakili GPU dengan indeks dari 0 hingga 31. GPU membentuk kelompok paralelisme tensor dari TPG ke TPG. _{0 7} Grup replikasi adalah ({TPG₀, TPG₄}, {TPG, TPG}₁, {TPG, TPG₅} dan {TPG ₂₃, TPG ₆₇}); setiap pasangan grup replikasi berbagi warna yang sama tetapi diisi secara berbeda.

Gambar 2: Grup paralelisme data terpecah untuk (node, derajat paralel data terpecah-pecah, derajat paralel tensor) = (4, 4, 4), di mana setiap persegi panjang mewakili GPU dengan indeks dari 0 hingga 31. GPU membentuk kelompok paralelisme data terpecah-pecah dari SDPG ke SDPG. _{0 7} Grup replikasi adalah ({SDPG₀, SDPG₄}, {SDPG, SDPG}₁, {SDPG, SDPG₅} dan {SDPG ₂₃, SDPG ₆₇}); 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 untuk distribution saat membuat objek kelas. SageMaker PyTorch ModelTrainer

Anda juga perlu mengaktifkanprescaled_batch. Ini berarti bahwa, alih-alih setiap GPU membaca kumpulan datanya sendiri, setiap grup paralel tensor secara kolektif membaca batch gabungan dari ukuran batch yang dipilih. Secara efektif, alih-alih membagi dataset menjadi beberapa bagian yang sama dengan jumlah GPU (atau ukuran paralel data,smp.dp_size()), ia membagi menjadi beberapa bagian yang sama dengan jumlah GPU dibagi dengan tensor_parallel_degree (juga disebut ukuran paralel data yang dikurangi,smp.rdp_size()). Untuk detail selengkapnya tentang batch prescaled, lihat Prescaled Batch di dokumentasi Python SDK. SageMaker Lihat juga contoh skrip pelatihan train_gpt_simple.py untuk GPT-2 di GitHub repositori Contoh SageMaker AI.

Cuplikan kode berikut menunjukkan contoh pembuatan PyTorch ModelTrainer objek berdasarkan skenario yang disebutkan di atas diContoh 2.

from sagemaker.train.configs import SourceCode, Compute
from sagemaker.core import image_uris

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
}

# Retrieve the training image for the desired PyTorch version
training_image = image_uris.retrieve(
    framework="pytorch",
    region="us-west-2",
    version="1.13.1",
    py_version="py3",
    instance_type="ml.p4d.24xlarge",
    image_scope="training"
)

pytorch_model_trainer = ModelTrainer(
    training_image=training_image,
    source_code=SourceCode(
        source_dir="source_directory_of_your_code",
        entry_script="your_training_script.py"
    ),
    role=role,
    compute=Compute(
        instance_type="ml.p4d.24xlarge",
        instance_count=4,
        volume_size_in_gb=200
    ),
    sagemaker_session=sagemaker_session,
    distribution={
        "smdistributed": {
            "modelparallel": {
                "enabled": True, 
                "parameters": smp_parameters,
            }
        },
        "mpi": {
            "enabled": True,
            "processes_per_host": 8,
            "custom_mpi_options": mpi_options,
        },
    },
    output_path=s3_output_location
)

Kiat dan pertimbangan untuk menggunakan paralelisme data terpecah-pecah

Pertimbangkan hal berikut saat menggunakan paralelisme data sharded library SageMaker model paralelism.