Penyesuaian terdistribusi model BERT Large untuk Tugas Menjawab Pertanyaan menggunakan Hugging Face Transformers di Amazon SageMaker

Dari melatih model baru hingga menerapkannya dalam produksi, Amazon SageMaker menawarkan seperangkat alat terlengkap untuk startup dan perusahaan untuk memanfaatkan kekuatan pembelajaran mesin (ML) dan Pembelajaran Mendalam.

Dengan perpustakaan sumber terbuka Transformers dan platform ML, Hugging Face membuat pembelajaran transfer dan model ML terbaru dapat diakses oleh komunitas AI global, mengurangi waktu yang dibutuhkan ilmuwan data dan insinyur ML di perusahaan di seluruh dunia untuk memanfaatkan setiap ilmu pengetahuan baru kemajuan.

Menerapkan Transformers ke tugas atau domain NLP baru memerlukan penyempurnaan model bahasa besar, sebuah teknik yang memanfaatkan akumulasi pengetahuan model pra-pelatihan untuk mengadaptasinya ke tugas baru atau jenis dokumen tertentu dalam proses pelatihan tambahan yang efisien.

Menyempurnakan model untuk menghasilkan prediksi yang akurat untuk masalah bisnis yang ada memerlukan pelatihan model Transformer besar, misalnya, BERT, BART, RoBERTa, T5, yang dapat menantang untuk dilakukan dengan cara yang dapat diskalakan.

Hugging Face telah bekerja sama dengan SageMaker untuk mewujudkannya Wadah Pembelajaran Mendalam siap pakai (DLC) yang membuat pelatihan dan penerapan model Transformers terbaru menjadi lebih mudah dan lebih cepat dari sebelumnya. Karena fitur seperti SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), mode pipa S3, diintegrasikan ke dalam container, penggunaan ini secara drastis mengurangi waktu bagi perusahaan untuk membuat solusi ML berbasis Transformers seperti menjawab pertanyaan, menghasilkan teks dan gambar, mengoptimalkan hasil pencarian, dan meningkatkan otomatisasi dukungan pelanggan, antarmuka percakapan, pencarian semantik, analisis dokumen, dan banyak lagi aplikasi.

Dalam postingan ini, kami berfokus pada integrasi mendalam pustaka terdistribusi SageMaker dengan Hugging Face, yang memungkinkan ilmuwan data mempercepat pelatihan dan penyempurnaan model Transformers dari hari ke jam, semuanya di SageMaker.

Tinjauan tentang pelatihan yang didistribusikan

Praktisi ML dan ilmuwan data menghadapi dua tantangan penskalaan saat melatih model: menskalakan ukuran model (jumlah parameter dan lapisan) dan menskalakan data pelatihan. Menskalakan ukuran model atau data pelatihan dapat menghasilkan akurasi yang lebih baik, tetapi ada kasus dalam pembelajaran mendalam di mana jumlah memori pada akselerator (CPU atau GPU) membatasi kombinasi ukuran data pelatihan dan ukuran data pelatihan. model. Misalnya, saat melatih model bahasa yang besar, ukuran batch sering kali terbatas pada sejumlah kecil sampel, yang dapat menghasilkan model yang kurang akurat.

Pelatihan terdistribusi dapat membagi beban kerja untuk melatih model di antara beberapa prosesor, disebut pekerja. Para pekerja ini beroperasi secara paralel untuk mempercepat pelatihan model.

Berdasarkan skala yang ingin kami ukur (model atau data), ada dua pendekatan untuk pelatihan terdistribusi: data paralel dan model paralel.

Paralel data adalah pendekatan yang paling umum untuk pelatihan terdistribusi. Paralelisme data memerlukan pembuatan salinan arsitektur model dan bobot pada akselerator yang berbeda. Kemudian, daripada meneruskan seluruh set pelatihan ke satu akselerator, kita dapat mempartisi set pelatihan di berbagai akselerator, dan melewati set pelatihan lebih cepat. Meskipun ini menambah langkah akselerator yang perlu mengkomunikasikan informasi gradien mereka kembali ke server parameter, kali ini lebih dari diimbangi dengan peningkatan kecepatan iterasi pada sebagian kecil dari seluruh kumpulan data per akselerator. Oleh karena itu, paralelisme data dapat membantu mengurangi waktu pelatihan secara signifikan. Misalnya, melatih satu model tanpa paralelisasi membutuhkan waktu 4 jam. Menggunakan pelatihan terdistribusi dapat menguranginya menjadi 24 menit. Pelatihan terdistribusi SageMaker juga menerapkan teknik mutakhir dalam pembaruan gradien.

Pendekatan paralel model digunakan dengan model besar yang terlalu besar untuk muat pada satu akselerator (GPU). Pendekatan ini mengimplementasikan strategi paralelisasi di mana arsitektur model dibagi menjadi pecahan dan ditempatkan pada akselerator yang berbeda. Konfigurasi masing-masing shard ini bergantung pada arsitektur jaringan saraf, dan biasanya mencakup beberapa lapisan. Komunikasi antara akselerator terjadi setiap kali data pelatihan berpindah dari satu pecahan ke pecahan berikutnya.

Singkatnya, Anda harus menggunakan paralelisme data pelatihan terdistribusi untuk tugas intensif waktu karena kumpulan data yang besar atau saat Anda ingin mempercepat eksperimen pelatihan. Anda harus menggunakan paralelisme model saat model Anda tidak dapat masuk ke satu akselerator.

Prasyarat

Untuk melakukan pelatihan terdistribusi model Hugging Face Transformers di SageMaker, Anda harus menyelesaikan prasyarat berikut:

Melaksanakan pelatihan terdistribusi

Pustaka Hugging Face Transformers menyediakan Trainer API yang dioptimalkan untuk melatih atau menyempurnakan model yang disediakan pustaka. Anda juga dapat menggunakannya pada model Anda sendiri jika bekerja dengan cara yang sama seperti model Transformers; melihat Pelatih untuk lebih jelasnya. API ini digunakan di kami contoh script, yang menunjukkan cara memproses data untuk berbagai tugas NLP, yang dapat Anda ambil sebagai model untuk menulis skrip yang memecahkan masalah kustom Anda sendiri. Janji Trainer API adalah bahwa skrip ini dapat digunakan di semua pengaturan terdistribusi, termasuk SageMaker.

API Pelatih mengambil semua yang diperlukan untuk pelatihan. Ini termasuk kumpulan data Anda, model Anda (atau fungsi yang mengembalikan model Anda), a compute_metrics fungsi yang mengembalikan metrik yang ingin Anda lacak dari larik predikasi dan label, pengoptimal dan penjadwal kecepatan pembelajaran Anda (disediakan default yang baik), serta semua hyperparameter yang dapat Anda atur untuk pelatihan Anda yang dikelompokkan dalam kelas data yang disebut TrainingArguments. Dengan semua itu, ini menampilkan tiga metode—melatih, mengevaluasi, dan memprediksi—untuk melatih model Anda, mendapatkan hasil metrik pada set data apa pun, atau mendapatkan prediksi pada set data apa pun. Untuk mempelajari lebih lanjut tentang objek Pelatih, lihat Menyempurnakan model dengan Trainer API dan videonya API Pelatih, yang memandu Anda melalui contoh sederhana.

Di balik layar, API Pelatih dimulai dengan menganalisis lingkungan tempat Anda meluncurkan skrip saat Anda membuatnya TrainingArguments. Misalnya, jika Anda meluncurkan pelatihan dengan SageMaker, ini akan terlihat pada SM_FRAMEWORK_PARAMS variabel di lingkungan untuk mendeteksi apakah Anda mengaktifkan paralelisme data atau paralelisme model SageMaker. Kemudian mendapatkan variabel yang relevan (seperti peringkat proses atau ukuran dunia) dari lingkungan sebelum melakukan langkah inisialisasi yang diperlukan (seperti smdistributed.dataparallel.torch.distributed.init_process_group()).

Pelatih berisi seluruh loop pelatihan, sehingga dapat menyesuaikan langkah-langkah yang diperlukan untuk memastikannya smdistributed.dataparallel backend digunakan bila diperlukan tanpa Anda harus mengubah baris kode dalam skrip Anda. Itu masih bisa berjalan (walaupun jauh lebih lambat) di mesin lokal Anda untuk debugging. Ini menangani sharding dataset Anda sedemikian rupa sehingga setiap proses melihat sampel yang berbeda secara otomatis, dengan perombakan di setiap zaman, menyinkronkan gradien Anda sebelum langkah pengoptimalan, pelatihan presisi campuran jika Anda mengaktifkannya, akumulasi gradien jika Anda tidak dapat memasukkan ukuran batch yang besar. GPU Anda, dan banyak pengoptimalan lainnya.

Jika Anda mengaktifkan paralelisme model, itu memastikan proses yang harus melihat data yang sama (jika mereka dp_rank adalah sama) mendapatkan batch yang sama, dan proses dengan berbeda dp_rank tidak melihat sampel yang sama, lagi dengan perombakan di setiap zaman. Itu memastikan kamus status model atau pengoptimal disinkronkan dengan benar saat checkpoint, dan sekali lagi menangani semua pengoptimalan seperti presisi campuran dan akumulasi gradien.

Saat menggunakan metode evaluasi dan prediksi, Pelatih melakukan evaluasi terdistribusi, untuk memanfaatkan semua GPU Anda. Ini menangani pemisahan data Anda dengan benar untuk setiap proses (proses yang sama dp_rank jika paralelisme model diaktifkan) dan memastikan bahwa prediksi dikumpulkan dengan benar dalam urutan yang sama dengan kumpulan data yang Anda gunakan sebelum dikirim ke compute_metrics berfungsi atau baru saja dikembalikan. Menggunakan Trainer API tidak wajib. Pengguna masih dapat menggunakan Keras atau PyTorch di dalam Hugging Face. Namun, Trainer API dapat memberikan lapisan abstraksi yang berguna.

Latih model menggunakan SageMaker Hugging Face Estimators

An Estimator adalah antarmuka tingkat tinggi untuk pelatihan SageMaker dan menangani tugas penerapan dan pelatihan SageMaker end-to-end. Pelatihan skrip Anda dipanggil saat Anda menelepon fit pada HuggingFace Penaksir. Di Estimator, Anda menentukan skrip fine-tuning mana yang akan digunakan entry_point, yang instance_type untuk digunakan, dan hyperparameter mana yang diteruskan. Untuk informasi lebih lanjut tentang HuggingFace parameter, lihat Memeluk Pengukur Wajah.

Pelatihan terdistribusi: Data paralel

Dalam contoh ini, kami menggunakan DLC Hugging Face baru dan SageMaker SDK untuk melatih model transformator Seq2Seq terdistribusi pada tugas tanya jawab menggunakan pustaka Transformers dan kumpulan data. Itu bert-besar-uncased-seluruh-kata-masking model fine-tuned pada regu Himpunan data.

Contoh kode berikut menunjukkan kepada Anda langkah-langkah membuat a HuggingFace estimator untuk pelatihan terdistribusi dengan paralelisme data.

1. Pilih skrip Transformers Wajah Memeluk:

   # git configuration to download our fine-tuning script
   git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

Saat Anda membuat file HuggingFace Estimator, Anda dapat menentukan skrip pelatihan yang disimpan di repositori GitHub sebagai titik masuk untuk Estimator, sehingga Anda tidak perlu mengunduh skrip secara lokal. Anda dapat gunakan git_config untuk menjalankan skrip contoh Transformers Wajah Memeluk dan 'cabang' kanan jika Anda transformers_version perlu dikonfigurasi. Misalnya, jika Anda menggunakan transformers_version 4.6.1, Anda harus menggunakan 'branch':'v4.6.1'.

2. Konfigurasikan hyperparameter pelatihan yang diteruskan ke tugas pelatihan:

   # hyperparameters, which are passed into the training job
   hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
   }

Sebagai hyperparameter, kita dapat mendefinisikan apa saja Seq2SeqTrainingArgumen dan yang ditentukan dalam skrip pelatihan.

3. Tentukan parameter distribusi di HuggingFace Penaksir:

   # configuration for running training on smdistributed Data Parallel
   distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Anda dapat menggunakan Pustaka paralelisme data SageMaker out of the box untuk pelatihan terdistribusi. Kami menambahkan fungsionalitas paralelisme data langsung ke dalam Pelatih. Untuk mengaktifkan paralelisme data, Anda cukup menambahkan satu parameter ke HuggingFace Pengukur agar kode berbasis Pelatih Anda menggunakannya secara otomatis.

4. Membuat HuggingFace Estimator termasuk parameter yang ditentukan pada langkah sebelumnya dan memulai pelatihan:

from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

Grafik Gudang Transformers Memeluk Wajah berisi beberapa contoh dan skrip untuk menyempurnakan model pada tugas dari pemodelan bahasa hingga klasifikasi token. Dalam kasus kami, kami menggunakan run_qa.py dari examples/pytorch/question-answering contoh.

smdistributed.dataparallel mendukung pelatihan model di SageMaker dengan jenis instans berikut saja. Untuk kinerja terbaik, sebaiknya gunakan jenis instans yang mendukung Adaptor Kain Elastis (EFA):

• ml.p3.16xbesar
• ml.p3dn.24xlarge (Disarankan)
• ml.p4d.24xlarge (Disarankan)

Untuk mendapatkan kinerja terbaik dan maksimal SMDataParallel, Anda harus menggunakan setidaknya dua contoh, tetapi Anda juga dapat menggunakan satu contoh untuk menguji contoh ini.

Berikut ini contoh notebook memberikan panduan langkah demi langkah yang lebih rinci.

Pelatihan terdistribusi: Model paralel

Untuk pelatihan terdistribusi dengan paralelisme model, kami menggunakan Hugging Face Transformers dan pustaka kumpulan data bersama dengan SageMaker SDK untuk klasifikasi urutan pada Evaluasi Pemahaman Bahasa Umum (GLUE) benchmark pada multi-node, multi-GPU cluster menggunakan Pustaka paralelisme model SageMaker.

Seperti paralelisme data, pertama-tama kita atur konfigurasi git, hyperparameter pelatihan, dan parameter distribusi di HuggingFace Penaksir:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

Pustaka paralelisme model secara internal menggunakan MPI, jadi untuk menggunakan paralelisme model, MPI harus diaktifkan menggunakan parameter distribusi. “processes_per_host” dalam kode sebelumnya menentukan jumlah proses yang harus diluncurkan MPI pada setiap host. Kami menyarankan ini untuk pengembangan dan pengujian. Pada waktu produksi, Anda dapat menghubungi Dukungan AWS jika meminta kapasitas GPU yang besar. Untuk informasi lebih lanjut, lihat Menjalankan Tugas Pelatihan Paralel Model Terdistribusi SageMaker.

Berikut ini contoh notebook berisi skrip kode lengkap.

Instans Spot

Dengan ekstensi framework Hugging Face untuk SageMaker Python SDK, kita juga dapat memanfaatkan sepenuhnya terkelola Cloud komputasi elastis Amazon (Amazon EC2) Instans Spot dan hemat hingga 90% dari biaya pelatihan kami.

Kecuali pekerjaan pelatihan Anda akan selesai dengan cepat, kami sarankan Anda menggunakan pos pemeriksaan dengan pelatihan tempat yang dikelola, oleh karena itu Anda perlu menentukan checkpoint_s3_uri.

Untuk menggunakan Instans Spot dengan HuggingFace Penaksir, kita harus mengatur use_spot_instances parameter ke True dan tentukan Anda max_wait dan max_run waktu. Untuk informasi selengkapnya tentang siklus pelatihan spot terkelola, lihat Pelatihan Spot Terkelola di Amazon SageMaker.

Berikut ini adalah cuplikan kode untuk menyiapkan Estimator pelatihan spot:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

Berikut ini buku catatan berisi skrip kode lengkap.

Kesimpulan

Dalam postingan ini, kami membahas pelatihan terdistribusi dari Hugging Face Transformers menggunakan SageMaker. Kami pertama kali meninjau kasus penggunaan untuk paralelisme data vs. paralelisme model. Paralelisme data biasanya lebih sesuai tetapi tidak harus terbatas pada saat pelatihan terhambat oleh komputasi, sedangkan Anda dapat menggunakan paralelisme model saat model tidak dapat masuk ke dalam memori yang disediakan pada akselerator tunggal. Kami kemudian menunjukkan cara berlatih dengan kedua metode tersebut.

Dalam kasus penggunaan paralelisme data yang telah kita diskusikan, melatih model pada satu instans p3.2xlarge (dengan satu GPU) membutuhkan waktu 4 jam dan biaya sekitar $15 pada saat penulisan ini. Dengan paralelisme data, kita dapat melatih model yang sama dalam 24 menit dengan biaya $28. Meskipun biayanya berlipat ganda, hal ini telah mengurangi waktu pelatihan hingga 10 kali lipat. Untuk situasi di mana Anda perlu melatih banyak model dalam waktu singkat, paralelisme data dapat memungkinkan hal ini dengan peningkatan biaya yang relatif rendah. Adapun kasus penggunaan paralelisme model, ini menambah kemampuan untuk melatih model yang sebelumnya tidak dapat dilatih sama sekali karena keterbatasan perangkat keras. Kedua fitur memungkinkan alur kerja baru bagi praktisi ML, dan mudah diakses melalui HuggingFace Estimator sebagai bagian dari SageMaker Python SDK. Menerapkan model ini ke titik akhir yang dihosting mengikuti prosedur yang sama dengan Estimator lainnya.

Integrasi ini mengaktifkan fitur lain yang merupakan bagian dari ekosistem SageMaker. Misalnya, Anda dapat menggunakan Instans Spot dengan menambahkan bendera sederhana ke Estimator untuk pengoptimalan biaya tambahan. Sebagai langkah selanjutnya, Anda dapat menemukan dan menjalankan file demo pelatihan dan contoh notebook.

Tentang Penulis

Archis Joglekar adalah Arsitek Solusi Mitra AI/ML di tim Emerging Technologies. Dia tertarik pada pembelajaran mendalam yang berkinerja, dapat diskalakan, dan komputasi ilmiah menggunakan blok pembangun di AWS. Pengalaman masa lalunya berkisar dari penelitian fisika komputasi hingga pengembangan platform pembelajaran mesin di akademisi, laboratorium nasional, dan perusahaan rintisan. Waktunya jauh dari komputer dihabiskan bermain sepak bola dan dengan teman-teman dan keluarga.

James Yi adalah Sr. AI/ML Partner Solutions Architect di tim Emerging Technologies di Amazon Web Services. Dia bersemangat bekerja dengan pelanggan dan mitra perusahaan untuk merancang, menerapkan, dan menskalakan aplikasi AI/ML untuk mendapatkan nilai bisnis mereka. Di luar pekerjaan, ia menikmati bermain sepak bola, bepergian, dan menghabiskan waktu bersama keluarganya.

Phillip Schmid adalah Insinyur Pembelajaran Mesin dan Pemimpin Teknologi di Hugging Face, di mana dia memimpin kolaborasi dengan tim Amazon SageMaker. Dia bersemangat dalam mendemokrasikan, mengoptimalkan, dan memproduksi model NLP mutakhir dan meningkatkan kemudahan penggunaan untuk Pembelajaran Mendalam.

Sylvain Gugger adalah Insinyur Riset di Hugging Face dan salah satu pengelola utama perpustakaan Transformers. Dia menyukai perangkat lunak sumber terbuka dan membantu komunitas menggunakannya.

Jeff Boudier membangun produk di Hugging Face, pembuat Transformers, pustaka ML sumber terbuka terkemuka. Sebelumnya Jeff adalah salah satu pendiri Stupeflix, diakuisisi oleh GoPro, di mana dia menjabat sebagai direktur Manajemen Produk, Pemasaran Produk, Pengembangan Bisnis, dan Pengembangan Perusahaan.

Sumber: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- transformer-on-amazon-sagemaker/