Sempurnakan model Whisper di Amazon SageMaker dengan LoRA | Layanan Web Amazon

Whisper adalah model Pengenalan Ucapan Otomatis (ASR) yang telah dilatih menggunakan 680,000 jam data yang diawasi dari web, yang mencakup berbagai bahasa dan tugas. Salah satu keterbatasannya adalah rendahnya performa pada bahasa dengan sumber daya rendah seperti bahasa Marathi dan bahasa Dravida, yang dapat diatasi dengan penyesuaian. Namun, menyempurnakan model Whisper telah menjadi tantangan besar, baik dari segi sumber daya komputasi dan kebutuhan penyimpanan. Lima hingga sepuluh proses penyempurnaan penuh untuk model Whisper memerlukan sekitar 100 jam GPU A100 (40 GB SXM4) (bervariasi berdasarkan ukuran model dan parameter model), dan setiap pos pemeriksaan yang disempurnakan memerlukan ruang penyimpanan sekitar 7 GB. Kombinasi tuntutan komputasi dan penyimpanan yang tinggi ini dapat menimbulkan hambatan yang signifikan, terutama di lingkungan dengan sumber daya terbatas, yang sering kali mempersulit pencapaian hasil yang berarti.

Adaptasi Tingkat Rendah, juga dikenal sebagai LoRA, mengambil pendekatan unik untuk menyempurnakan model. Ini mempertahankan bobot model yang telah dilatih sebelumnya dalam keadaan statis dan memperkenalkan matriks dekomposisi peringkat yang dapat dilatih ke dalam setiap lapisan struktur Transformer. Metode ini dapat mengurangi jumlah parameter yang dapat dilatih yang diperlukan untuk tugas hilir sebanyak 10,000 kali lipat dan mengurangi kebutuhan memori GPU sebanyak 3 kali lipat. Dalam hal kualitas model, LoRA telah terbukti menyamai atau bahkan melampaui kinerja metode penyesuaian tradisional, meskipun beroperasi dengan lebih sedikit parameter yang dapat dilatih (lihat hasil dari metode asli kertas LoRA). Hal ini juga menawarkan manfaat peningkatan hasil pelatihan. tidak seperti adaptor metode, LoRA tidak menimbulkan latensi tambahan selama inferensi, sehingga menjaga efisiensi model selama fase penerapan. Penyempurnaan Whisper menggunakan LoRA telah menunjukkan hasil yang menjanjikan. Ambil Whisper-Large-v2, misalnya: menjalankan 3-epoch dengan kumpulan data suara umum 12 jam pada memori 8 GB GPU memerlukan waktu 6–8 jam, yang 5 kali lebih cepat dibandingkan penyempurnaan penuh dengan kinerja sebanding.

Amazon SageMaker adalah platform yang ideal untuk mengimplementasikan penyempurnaan LoRA pada Whisper. Amazon SageMaker memungkinkan Anda membangun, melatih, dan menerapkan model pembelajaran mesin untuk setiap kasus penggunaan dengan infrastruktur, alat, dan alur kerja yang terkelola sepenuhnya. Manfaat pelatihan model tambahan dapat mencakup biaya pelatihan yang lebih rendah dengan Pelatihan Spot Terkelola, perpustakaan pelatihan terdistribusi untuk membagi model dan kumpulan data pelatihan di seluruh instans GPU AWS, dan lebih. Model SageMaker yang terlatih dapat dengan mudah diterapkan untuk inferensi langsung di SageMaker. Dalam postingan ini, kami menyajikan panduan langkah demi langkah untuk mengimplementasikan penyempurnaan LoRA di SageMaker. Kode sumber yang terkait dengan implementasi ini dapat ditemukan di GitHub.

Siapkan kumpulan data untuk penyesuaian

Kami menggunakan bahasa Marathi dengan sumber daya rendah untuk tugas penyesuaian. Menggunakan Kumpulan data Memeluk Wajah perpustakaan, Anda dapat mengunduh dan membagi kumpulan data Common Voice menjadi kumpulan data pelatihan dan pengujian. Lihat kode berikut:

from datasets import load_dataset, DatasetDict language = "Marathi"
language_abbr = "mr"
task = "transcribe"
dataset_name = "mozilla-foundation/common_voice_11_0" common_voice = DatasetDict()
common_voice["train"] = load_dataset(dataset_name, language_abbr, split="train+validation", use_auth_token=True)
common_voice["test"] = load_dataset(dataset_name, language_abbr, split="test", use_auth_token=True)

Model pengenalan ucapan Whisper memerlukan input audio File WAV integer bertanda 16kHz mono 16-bit. Karena himpunan data Common Voice memiliki laju pengambilan sampel 48K, Anda perlu melakukan downsample file audio terlebih dahulu. Kemudian Anda perlu menerapkan ekstraktor fitur Whisper ke audio untuk mengekstrak fitur spektogram log-mel, dan menerapkan tokenizer Whisper ke fitur berbingkai untuk mengubah setiap kalimat dalam transkrip menjadi ID token. Lihat kode berikut:

from transformers import WhisperFeatureExtractor
from transformers import WhisperTokenizer feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name_or_path)
tokenizer = WhisperTokenizer.from_pretrained(model_name_or_path, language=language, task=task) def prepare_dataset(batch):
# load and resample audio data from 48 to 16kHz
audio = batch["audio"] # compute log-Mel input features from input audio array
batch["input_features"] = feature_extractor(audio["array"], sampling_rate=audio["sampling_rate"]).input_features[0] # encode target text to label ids
batch["labels"] = tokenizer(batch["sentence"]).input_ids
return batch #apply the data preparation function to all of our fine-tuning dataset samples using dataset's .map method.
common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names["train"], num_proc=2)
common_voice.save_to_disk("marathi-common-voice-processed")
!aws s3 cp --recursive "marathi-common-voice-processed" s3://<Your-S3-Bucket>

Setelah Anda memproses semua sampel pelatihan, unggah data yang telah diproses ke Amazon S3, sehingga saat menggunakan data pelatihan yang telah diproses dalam tahap penyesuaian, Anda dapat menggunakan File Cepat untuk memasang file S3 secara langsung alih-alih menyalinnya ke disk lokal:

from sagemaker.inputs import TrainingInput
training_input_path=s3uri
training = TrainingInput(
s3_data_type='S3Prefix', # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
s3_data=training_input_path,
distribution='FullyReplicated', # Available Options: FullyReplicated | ShardedByS3Key
input_mode='FastFile'
)

Latih modelnya

Untuk demonstrasi, kami menggunakan berbisik-besar-v2 sebagai model terlatih (whisper v3 sekarang tersedia), yang dapat diimpor melalui perpustakaan transformator Hugging Face. Anda dapat gunakan Kuantisasi 8-bit untuk lebih meningkatkan efisiensi pelatihan. Kuantisasi 8-bit menawarkan optimalisasi memori dengan pembulatan dari floating point ke bilangan bulat 8-bit. Ini adalah teknik kompresi model yang umum digunakan untuk menghemat pengurangan memori tanpa terlalu mengorbankan presisi selama inferensi.

Untuk memuat model terlatih dalam format terkuantisasi 8-bit, kita cukup menambahkan argumen load_in_8bit=True saat membuat instance model, seperti yang ditunjukkan dalam kode berikut. Ini akan memuat bobot model yang dikuantisasi menjadi 8 bit, sehingga mengurangi jejak memori.

from transformers import WhisperForConditionalGeneration model = WhisperForConditionalGeneration.from_pretrained(model_name_or_path, load_in_8bit=True, device_map="auto")

Kami menggunakan implementasi LoRA dari Hugging Face's peft kemasan. Ada empat langkah untuk menyempurnakan model menggunakan LoRA:

1. Buat instance model dasar (seperti yang kita lakukan pada langkah terakhir).
2. Buat konfigurasi (LoraConfig) di mana parameter spesifik LoRA ditentukan.
3. Bungkus model dasar dengan get_peft_model() untuk mendapatkan pelatihan PeftModel.
4. Latih PeftModel sebagai model dasar.

Lihat kode berikut:

from peft import LoraConfig, get_peft_model config = LoraConfig(r=32, lora_alpha=64, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none")
model = get_peft_model(model, config) training_args = Seq2SeqTrainingArguments(
output_dir=args.model_dir,
per_device_train_batch_size=int(args.train_batch_size),
gradient_accumulation_steps=1,
learning_rate=float(args.learning_rate),
warmup_steps=args.warmup_steps,
num_train_epochs=args.num_train_epochs,
evaluation_strategy="epoch",
fp16=True,
per_device_eval_batch_size=args.eval_batch_size,
generation_max_length=128,
logging_steps=25,
remove_unused_columns=False,
label_names=["labels"],
)
trainer = Seq2SeqTrainer(
args=training_args,
model=model,
train_dataset=train_dataset["train"],
eval_dataset=train_dataset.get("test", train_dataset["test"]),
data_collator=data_collator,
tokenizer=processor.feature_extractor,
)

Untuk menjalankan file Pelatihan SageMaker pekerjaan, kami membawa wadah Docker kami sendiri. Anda dapat mengunduh image Docker dari GitHub, di mana ffmpeg4 dan git-lfs dikemas bersama dengan persyaratan Python lainnya. Untuk mempelajari selengkapnya tentang cara mengadaptasi kontainer Docker Anda sendiri agar berfungsi dengan SageMaker, lihat Menyesuaikan wadah pelatihan Anda sendiri. Kemudian Anda dapat menggunakan Hugging Face Estimator dan memulai tugas pelatihan SageMaker:

OUTPUT_PATH= f's3://{BUCKET}/{PREFIX}/{TRAINING_JOB_NAME}/output/' huggingface_estimator = HuggingFace(entry_point='train.sh',
source_dir='./src',
output_path= OUTPUT_PATH,
instance_type=instance_type,
instance_count=1,
# transformers_version='4.17.0',
# pytorch_version='1.10.2',
py_version='py310',
image_uri=<ECR-PATH>,
role=ROLE,
metric_definitions = metric_definitions,
volume_size=200,
distribution=distribution,
keep_alive_period_in_seconds=1800,
environment=environment,
) huggingface_estimator.fit(job_name=TRAINING_JOB_NAME, wait=False)

Penerapan LoRA memungkinkan kami menjalankan tugas penyempurnaan besar Whisper pada satu instans GPU (misalnya, ml.g5.2xlarge). Sebagai perbandingan, tugas penyempurnaan penuh Whisper yang besar memerlukan banyak GPU (misalnya, ml.p4d.24xlarge) dan waktu pelatihan yang lebih lama. Lebih khusus lagi, eksperimen kami menunjukkan bahwa tugas penyempurnaan penuh memerlukan jam GPU 24 kali lebih banyak dibandingkan dengan pendekatan LoRA.

Evaluasi kinerja model

Untuk mengevaluasi performa model Whisper yang telah disempurnakan, kami menghitung tingkat kesalahan kata (WER) pada set pengujian yang diadakan. WER mengukur perbedaan antara transkrip prediksi dan transkrip kebenaran dasar. WER yang lebih rendah menunjukkan kinerja yang lebih baik. Anda dapat menjalankan skrip berikut terhadap model terlatih dan model yang telah disempurnakan serta membandingkan perbedaan WER-nya:

metric = evaluate.load("wer") eval_dataloader = DataLoader(common_voice["test"], batch_size=8, collate_fn=data_collator) model.eval()
for step, batch in enumerate(tqdm(eval_dataloader)):
with torch.cuda.amp.autocast():
with torch.no_grad():
generated_tokens = (
model.generate(
input_features=batch["input_features"].to("cuda"),
decoder_input_ids=batch["labels"][:, :4].to("cuda"),
max_new_tokens=255,
)
.cpu()
.numpy()
)
labels = batch["labels"].cpu().numpy()
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
metric.add_batch(
predictions=decoded_preds,
references=decoded_labels,
)
del generated_tokens, labels, batch
gc.collect()
wer = 100 * metric.compute()
print(f"{wer=}")

Kesimpulan

Dalam postingan ini, kami mendemonstrasikan penyempurnaan Whisper, model pengenalan suara yang canggih. Secara khusus, kami menggunakan PEFT LoRA Hugging Face dan mengaktifkan kuantisasi 8-bit untuk pelatihan yang efisien. Kami juga mendemonstrasikan cara menjalankan tugas pelatihan di SageMaker.

Meskipun ini merupakan langkah pertama yang penting, ada beberapa cara yang dapat Anda lakukan untuk melanjutkan pekerjaan ini untuk lebih menyempurnakan model bisikan. Ke depannya, pertimbangkan untuk menggunakan pelatihan terdistribusi SageMaker untuk menskalakan pelatihan pada kumpulan data yang jauh lebih besar. Hal ini akan memungkinkan model untuk melatih data yang lebih bervariasi dan komprehensif, sehingga meningkatkan akurasi. Anda juga dapat mengoptimalkan latensi saat menyajikan model Whisper, untuk mengaktifkan pengenalan ucapan secara real-time. Selain itu, Anda dapat memperluas pekerjaan untuk menangani transkripsi audio yang lebih panjang, yang memerlukan perubahan pada arsitektur model dan skema pelatihan.

Pengakuan

Penulis mengucapkan terima kasih kepada Paras Mehra, John Sol, dan Evandro Franco atas masukan dan ulasan mendalam mereka terhadap postingan tersebut.

Tentang Penulis

Juni Shi adalah Arsitek Solusi Senior di Amazon Web Services (AWS). Area fokusnya saat ini adalah infrastruktur dan aplikasi AI/ML. Dia memiliki pengalaman lebih dari satu dekade di industri FinTech sebagai insinyur perangkat lunak.

Dr Changsa Ma adalah Spesialis AI/ML di AWS. Dia adalah seorang teknolog dengan gelar PhD di bidang Ilmu Komputer, gelar master di bidang Psikologi Pendidikan, dan pengalaman bertahun-tahun di bidang ilmu data dan konsultasi independen di bidang AI/ML. Dia bersemangat meneliti pendekatan metodologis untuk kecerdasan mesin dan manusia. Di luar pekerjaan, dia suka hiking, memasak, berburu makanan, dan menghabiskan waktu bersama teman dan keluarga.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/fine-tune-whisper-models-on-amazon-sagemaker-with-lora/