Latih model raksasa dengan penskalaan hampir linier menggunakan paralelisme data sharded di Amazon SageMaker

Dalam mengejar akurasi yang unggul, model pembelajaran mendalam di berbagai bidang seperti pemrosesan bahasa alami dan visi komputer telah berkembang secara signifikan dalam beberapa tahun terakhir, sering dihitung dalam puluhan hingga ratusan miliar parameter. Pelatihan model raksasa ini menantang dan membutuhkan strategi distribusi yang kompleks. Ilmuwan data dan insinyur pembelajaran mesin terus mencari cara terbaik untuk mengoptimalkan komputasi pelatihan mereka, namun berjuang dengan overhead komunikasi yang dapat meningkat seiring dengan ukuran cluster secara keseluruhan.

Inilah sebabnya kami baru-baru ini meluncurkan sparalelisme data yang dikeraskan on Amazon SageMaker, teknik pelatihan terdistribusi hemat memori baru di Pustaka paralel model SageMaker (SMP). Paralelisme data sharded dibuat khusus untuk model skala ekstrem dan menggunakan Amazon internal MiCS teknologi di bawah tenda, upaya sains untuk meminimalkan skala komunikasi dengan menurunkan overhead komunikasi yang mahal yang berakar pada pengumpulan parameter dan sinkronisasi gradien. Dengan model GPT-30 parameter 2B dengan panjang urutan 2048, fitur baru ini mencapai 141 TFLOP, peningkatan 39.7% dibandingkan dengan DeepSpeed ​​ZeRO-3. Untuk model 10B GPT-2 dengan panjang urutan 512, fitur baru ini juga mencapai 564 sampel per detik, 13.9% lebih cepat dibandingkan dengan Fully Sharded Data Parallel (FSDP) dari PyTorch. Ingatlah bahwa dalam pelatihan model raksasa, setiap persentase percepatan berarti penghematan dolar dan produktivitas yang diperoleh dalam tim Anda.

Dalam posting blog ini, pertama-tama kita akan melihat lebih dekat pembeda utama paralelisme data sharded dan kapan menggunakannya. Kemudian, Anda akan mempelajari cara melatih model GPT-30 parameter 2B di SageMaker dengan mudah dengan fitur baru ini. Terakhir, kami akan membandingkan kinerjanya dengan opsi open source lainnya, terutama mengungguli DeepSpeed ​​ZeRO hingga 39.7% pada 256 GPU.

Cara kerja paralelisme data sharding dan kapan menggunakannya

Sebelum kita memperkenalkan paralelisme data sharded, mari kita lihat keluarga tekniknya yang lebih luas. Pendekatan pelatihan terdistribusi terbaru untuk model besar telah pindah ke paradigma di mana parameter model, gradien, dan status pengoptimal dibagikan di seluruh node paralel data. Tidak seperti Pipeline Parallelism yang memiliki kompleksitas bawaan dalam memilih lapisan untuk dipartisi di seluruh perangkat terutama ketika kerangka kerja Anda tidak mendukung pemisahan model otomatis, paradigma ini secara elegan mempertahankan kesederhanaan paralelisme data, sekaligus menghilangkan batasan paralelisme data di mana model harus masuk ke dalam satu GPU.

Dalam kerangka kerja yang ada yang termasuk dalam paradigma ini, terutama DeepSpeed ​​ZeRO-3 dan FSDP PyTorch yang di-upstream dari FairScale, status model dibagi semua GPU, strategi yang menurunkan konsumsi memori pada setiap GPU dengan biaya overhead komunikasi yang besar yang meningkat seiring dengan ukuran cluster dan oleh karena itu menyebabkan skalabilitas menurun secara signifikan pada skala. Sebaliknya, paralelisme data sharded dalam model partisi perpustakaan SMP menyatakan dalam a sadar skala cara dengan mempartisi setiap replika status model hanya di dalam subset dari GPU.

Mari kita lihat lebih dekat pada partisi model skala-sadar di MiCS, teknologi inti di balik paralel data sharded. Intuisi di balik desain ini adalah bahwa status pelatihan partisi di seluruh grup paralel data mungkin tidak diperlukan untuk melatih model dengan puluhan miliar parameter. Misalnya, 8 GPU V100 (masing-masing 32 GB) cukup untuk menampung replika status model dari model parameter 10B yang membutuhkan memori sekitar 200 GB saat berlatih dengan Adam optimizer menggunakan presisi campuran. Dengan membatasi replika lengkap status model di terkecil subset GPU, kami dapat secara efektif mengurangi skala overhead komunikasi dibandingkan dengan DeepSpeed ​​dan PyTorch FSDP. Paralel data sharding juga memanfaatkan teknik lain dalam MiCS seperti Hierarchical Communication dan 2-hop Gradient Synchronization. Untuk informasi lebih lanjut, periksa Penskalaan hampir linier dari pelatihan model raksasa di AWS or MiCS: Penskalaan Near-linear untuk Melatih Model Raksasa di Cloud Publik.

Sekarang, bagaimana Anda tahu kapan harus memilih paralel data sharding daripada teknik pelatihan terdistribusi lainnya? Aturan umumnya adalah jika model Anda memiliki kurang dari 1 miliar parameter dan dapat masuk ke memori GPU, Pustaka paralel data SageMaker or Kompiler pelatihan SageMaker bisa cukup untuk Anda. Jika Anda memiliki model bahasa atau visi komputer yang lebih besar, saran kami adalah melatihnya dengan teknik paralelisme data sharded yang dikombinasikan dengan pos pemeriksaan aktivasi dan pembongkaran aktivasi di perpustakaan paralel model SageMaker terlebih dahulu, sebelum teknik lain seperti paralelisme tensor atau paralelisme pipa.

Menggunakan paralelisme data sharding untuk melatih GPT-2 di Amazon SageMaker

Sekarang mari pelajari cara melatih model GPT-2 dengan paralel data sharded, dengan SMP yang merangkum kerumitannya untuk Anda. Ini buku catatan tutorial lengkap memandu Anda melalui seluruh proses, mulai dari pemrosesan data, penetapan dan pengiriman tugas pelatihan, hingga pemantauan log pelatihan. Berikut ini adalah ikhtisar singkat yang menyoroti langkah-langkah utama untuk menggunakan fitur ini.

1. Mulai

Paralelisme data sharded tersedia di PyTorch v1.12.0+ dan berfungsi dengan FP16 dan BF16. Cara termudah untuk menggunakan perpustakaan SMP adalah melalui AWS Deep Learning Container untuk PyTorch. Namun, jika Anda ingin membawa wadah Docker sendiri, Anda dapat merujuk ke Buat Wadah Docker Anda Sendiri dengan Pustaka Paralel Model Terdistribusi SageMaker. Untuk memulai, ikuti Memodifikasi Skrip Pelatihan PyTorch untuk mengadaptasi API SMP dalam skrip pelatihan Anda. Di bagian ini, kami hanya menyebutkan beberapa langkah utama dengan cuplikan kode dari skrip pelatihan yang siap digunakan train_gpt_simple.py. Anda dapat mengikuti komentar di skrip dan Dokumen API untuk mempelajari lebih lanjut tentang di mana API SMP digunakan.

Pertama, impor dan inisialisasi perpustakaan dengan memanggil smdistributed.modelparallel.torch.init() di awal skrip pelatihan:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

Kedua, bungkus model yang akan dipartisi dengan smdistributed.modelparallel.torch.DistributedModel dan gunakan yang dikembalikan DistributedModel objek ke depan:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_config(model_config)
model = smp.DistributedModel(model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation)

Bungkus pengoptimal dengan smdistributed.modelparallel.torch.DistributedOptimizer untuk menyimpan dan memuat status pengoptimal.

from torch import optim

optimizer = optim.Adam(
    param_groups, betas=(args.beta1, args.beta2), lr=args.lr, weight_decay=args.weight_decay
)

optimizer = smp.DistributedOptimizer(
        optimizer, 
        static_loss_scale=None, 
        dynamic_loss_scale=True,
        dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
        )

Letakkan logika maju dan mundur dalam fungsi langkah dan hiasi dengan smdistributed.modelparallel.torch.step.  Setiap perhitungan yang didefinisikan di dalam smp.step-decorated fungsi dijalankan secara terdistribusi.

@smp.step
def train_step(model, optimizer, input_ids, attention_mask, args):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    model.backward(loss)

    return loss

@smp.step
def test_step(model, input_ids, attention_mask):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    
    return loss

2. Siapkan kumpulan data

Kami menggunakan teks web terbuka adalah dataset yang kita gunakan dalam contoh ini. Buku catatan menggunakan skrip data_prep_512.py untuk mengunduh dan memproses dataset terlebih dahulu. Anda juga dapat berlatih dengan kumpulan data lain dengan memodifikasi data_pipeline.py. Saat berurusan dengan kumpulan data dan model yang besar, Anda dapat mempercepat pekerjaan pelatihan dengan menggunakan data yang disimpan di Amazon FSx untuk Lustre, yang menyediakan sistem file berkinerja tinggi yang terintegrasi secara native dengan Layanan Penyimpanan Sederhana Amazon (S3). Silakan lihat instruksi dari Konfigurasikan Saluran Input Data untuk Menggunakan Amazon FSx for Lustre untuk panduan tentang pengaturan sistem file FSx Lustre sebagai saluran input data.

3. Mulai pekerjaan pelatihan

Langkah ini mengasumsikan Anda sudah memodifikasi skrip pelatihan Anda dan menyiapkan dataset seperti yang disebutkan di bagian sebelumnya. Ke aktifkan paralelisme data sharded, cukup atur sharded_data_parallel_degree dalam Pengukur PyTorch. Dalam tutorial ini, kami mengatur sharded_data_parallel_degree=128 dan instace_count=32 untuk node p4d.24xlarge, yang menunjukkan bahwa status model akan di-sharding di 128 GPU di antara total 256 GPU. Berdasarkan nilai yang dipilih ini, SMP kemudian akan secara otomatis menyetel derajat paralel data ke 2 (karena 256/128=2), artinya kita akan memiliki dua replika untuk paralelisme data. Aturan umum untuk memilih nilai ideal untuk sharded_data_parallel_degree adalah menambahkan satu simpul lagi ke grup berbagi per setiap 3B parameter model. Dalam tutorial ini, ukuran model kita adalah 30B, jadi kita harus menggunakan setidaknya 10 node untuk sharding. Dan karena 16 node (128 GPU) adalah power-of-2 terkecil di atas ambang batas, kami menetapkan sharded_data_parallel_degree=128.

Untuk pos pemeriksaan, kami juga menyediakan seperangkat utilitas pos pemeriksaan di sharded_data_parallel_checkpoint.py , termasuk utilitas untuk merekonstruksi keseluruhan state_dict untuk kasus penggunaan lanjutan. Terakhir, kita dapat meluncurkan tugas pelatihan terdistribusi dengan memanggil fit() pada Estimator.

smp_estimator = PyTorch(
    entry_point="train_gpt_simple.py",
    instance_type="ml.p4d.24xlarge",
    source_dir=os.getcwd(),
    volume_size=500,
    instance_count=32,
    distribution={
        "mpi": {
            "enabled": True,
            "processes_per_host": processes_per_host,
            "custom_mpi_options": mpioptions,
        },
        "smdistributed": {
            "modelparallel": {
                "enabled": True,
                "parameters": {
                    "ddp": True,
                    "skip_tracing": True,
                    "delayed_parameter_initialization": True,
                    "offload_activations": True,
                    "activation_loading_horizon": 4,
                    # To enable sharded data parallelism.
                    # Here we shard model states across 128 GPUs. 
                    "sharded_data_parallel_degree": 128, 
                    "fp16": False,
                    "bf16": True,
                    # This is to disable pipeline parallelism.
                    "partitions": 1,
                },
            }
        },
    },
    framework_version="1.12",
    py_version="py38",
    hyperparameters=hyperparameters,
    checkpoint_s3_uri=checkpoint_s3_uri if not use_fsx else None,
    checkpoint_local_path=hyperparameters["checkpoint-dir"] if use_fsx else None,
    ...
)

smp_estimator.fit(inputs=data_channels)

4. Pantau pekerjaan pelatihan

Anda dapat mengakses log pelatihan dan melacak penggunaan GPU dan memori di amazoncloudwatch. Pastikan untuk melihat log dari "algo-1" karena itu adalah node utama yang aliran outputnya memiliki log tugas pelatihan dari semua instance.

Performa pembandingan

Kami membandingkan paralelisme data sharded di perpustakaan SMP pada node 16 dan 32 p4d.24xlarge masing-masing untuk panjang urutan 512 dan 2048. Model GPT30 parameter 2B dikonfigurasi untuk menggunakan lebar tersembunyi 7168, 48 lapisan, dan 64 kepala. Anda dapat mengadopsi konfigurasi yang sama persis di mana panjang urutan adalah 2048 dengan menyetel model_config = "gpt2-30b" dalam buku catatan tutorial. Dengan pengaturan ini, SMP mencapai 73.52 sampel per detik, lebih cepat 39.7% dibandingkan dengan DeepSpeed ​​ZeRO-3. Jika ukuran token Anda adalah 500 miliar, kecepatan ini berarti penghematan hampir 367 jam pada node p4d.24xlarge, setara dengan penghematan anggaran lebih dari $12,000 per pelatihan! Tabel berikut merangkum hasil benchmark kami.

1/ Untuk setiap konfigurasi model, kami menguji berbagai fitur, tahapan, dan konfigurasi di DeepSpeed ​​ZeRO dan memilih salah satu yang memberikan throughput terbaik sebagai baseline DeepSpeed. Benchmark dijalankan pada Cloud komputasi elastis Amazon (Amazon EC2). 2/ Hasil ini bergantung pada peningkatan komunikasi kolektif yang dioptimalkan untuk AWS yang akan segera tersedia. 3/ Waktu untuk berlatih diproyeksikan dari kecepatan berdasarkan jumlah token yang diproses.

Singkatnya, kami mengamati throughput yang lebih tinggi secara konsisten dengan paralelisme data sharded di SMP jika dibandingkan dengan DeepSpeed ​​di berbagai model dan konfigurasi. Fitur baru ini juga menunjukkan efisiensi memori yang lebih baik dibandingkan dengan DeepSpeed, memungkinkan SMP untuk menyesuaikan ukuran batch yang lebih besar dan mengurangi tingkat akumulasi gradien yang diperlukan agar sesuai dengan ukuran batch global tertentu.

Kesimpulan

Dalam postingan ini, kami memperkenalkan teknik pelatihan terdistribusi baru — paralelisme data sharded — dan bagaimana teknik ini mempercepat pelatihan model raksasa dengan penskalaan hampir linier di Amazon SageMaker. Kami juga membahas cara melatih model GPT-2 dengan teknik baru berikut ini contoh lengkap. Anda dapat mengikuti Contoh Amazon SageMaker repo GitHub untuk melacak semua contoh paralel model SageMaker atau hadiri kami berikutnya lokakarya pelatihan yang didistribusikan. Untuk mempelajari lebih lanjut tentang paralelisme data sharding, silakan lihat dokumentasi.

Tentang penulis

Emily Webber bergabung dengan AWS tepat setelah SageMaker diluncurkan, dan telah mencoba memberi tahu dunia tentang hal itu sejak saat itu! Di luar membangun pengalaman ML baru untuk pelanggan, Emily menikmati bermeditasi dan mempelajari Buddhisme Tibet.

Bisakah Karakus adalah Ilmuwan Terapan Senior di AWS, yang mengoptimalkan pembelajaran mendalam terdistribusi skala besar di AWS. Minat penelitiannya meliputi pembelajaran mendalam, optimasi terdistribusi, sistem terdistribusi, dan teori informasi. Di luar pekerjaan, ia senang bersepeda, jalan-jalan, membaca, dan belajar.

Rahul Huilgol adalah Insinyur Perangkat Lunak Senior di AWS. Dia bekerja pada sistem pembelajaran mendalam terdistribusi, untuk membuatnya mudah dan berkinerja tinggi untuk melatih model pembelajaran mendalam yang besar di cloud. Di waktu luangnya, ia menikmati fotografi, bersepeda, dan berkebun.

Suhit Kodgule adalah Insinyur Pengembangan Perangkat Lunak dengan grup Kecerdasan Buatan AWS yang mengerjakan kerangka kerja pembelajaran mendalam. Di waktu luangnya, ia menikmati hiking, bepergian, dan memasak.

Erin Ho adalah Manajer Produk untuk AWS Deep Learning. Dia mengerjakan produk yang memudahkan pelanggan untuk melatih model pembelajaran mendalam di AWS. Untuk bersenang-senang di luar pekerjaan, dia menikmati hiking dan ski.