Pengakuan ucapan otomatis

Automatic speech recognition (ASR) mengubah sinyal suara menjadi teks, memetakan urutan input audio ke output teks. Asisten virtual seperti Siri dan Alexa menggunakan model ASR untuk membantu pengguna setiap hari, dan terdapat banyak aplikasi lain yang berguna bagi pengguna, seperti live captioning dan pencatatan selama rapat.

Panduan ini akan menunjukkan cara Anda untuk:

Lakukan fine-tuning Wav2Vec2 pada dataset MInDS-14 untuk mentranskripsi audio menjadi teks.
Gunakan model yang telah Anda fine-tune untuk inferensi.

Untuk melihat semua arsitektur dan checkpoint yang kompatibel dengan tugas ini, kami menyarankan untuk memeriksa halaman tugas

Sebelum memulai, pastikan Anda telah menginstal semua pustaka yang diperlukan:

pip install transformers datasets evaluate jiwer soundfile librosa torchcodec

Kami menyarankan Anda untuk masuk ke akun Hugging Face Anda agar dapat mengunggah dan membagikan model Anda kepada komunitas. Saat diminta, masukkan token Anda untuk masuk:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Muat dataset MInDS-14

Mulai dengan memuat subset yang lebih kecil dari dataset MInDS-14 dari pustaka 🤗 Datasets. Hal ini memberi Anda kesempatan untuk bereksperimen dan memastikan semuanya berfungsi dengan baik sebelum menghabiskan lebih banyak waktu untuk pelatihan pada dataset lengkap.

>>> from datasets import load_dataset, Audio

>>> minds = load_dataset("PolyAI/minds14", name="en-US", split="train[:100]")

Bagi split train dari dataset menjadi set train dan test dengan metode ~Dataset.train_test_split:

>>> minds = minds.train_test_split(test_size=0.2)

Lalu, lihatlah dataset-nya:

>>> minds
DatasetDict({
    train: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 16
    })
    test: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 4
    })
})

Meskipun dataset ini mengandung banyak informasi yang berguna, seperti lang_id dan english_transcription, panduan ini berfokus pada audio dan transcription. Hapus kolom lainnya dengan metode remove_columns:

>>> minds = minds.remove_columns(["english_transcription", "intent_class", "lang_id"])

Ulangi meninjau contoh tersebut:

>>> minds["train"][0]
{'audio': {'array': array([-0.00024414,  0.        ,  0.        , ...,  0.00024414,
          0.00024414,  0.00024414], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
  'sampling_rate': 8000},
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
 'transcription': "hi I'm trying to use the banking app on my phone and currently my checking and savings account balance is not refreshing"}

Ada dua bidang:

audio: array satu dimensi dari sinyal suara yang harus dipanggil untuk memuat dan melakukan resampling file audio.
transcription: teks target.

Pra-pemrosesan

Langkah selanjutnya adalah memuat Wav2Vec2 processor untuk memproses sinyal audio:

>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base")

Dataset MInDS-14 memiliki laju sampling 8000Hz (Anda dapat menemukan informasi ini di kartu dataset-nya), yang berarti Anda perlu melakukan resampling dataset ke 16000Hz untuk menggunakan model Wav2Vec2 yang telah dilatih sebelumnya:

>>> minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
>>> minds["train"][0]
{'audio': {'array': array([-2.38064706e-04, -1.58618059e-04, -5.43987835e-06, ...,
          2.78103951e-04,  2.38446111e-04,  1.18740834e-04], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
  'sampling_rate': 16000},
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
 'transcription': "hi I'm trying to use the banking app on my phone and currently my checking and savings account balance is not refreshing"}

Seperti yang dapat Anda lihat pada transcription di atas, teks tersebut mengandung campuran huruf besar dan huruf kecil. Tokenizer Wav2Vec2 hanya dilatih pada karakter huruf besar, sehingga Anda perlu memastikan bahwa teks tersebut sesuai dengan kosakata tokenizer:

>>> def uppercase(example):
...     return {"transcription": example["transcription"].upper()}


>>> minds = minds.map(uppercase)

Sekarang buat fungsi pra-pemrosesan yang:

Memanggil kolom audio untuk memuat dan melakukan resampling file audio.
Ekstrak input_values dari file audio dan tokenisasi kolom transcription dengan processor.

>>> def prepare_dataset(batch):
...     audio = batch["audio"]
...     batch = processor(audio["array"], sampling_rate=audio["sampling_rate"], text=batch["transcription"])
...     batch["input_length"] = len(batch["input_values"][0])
...     return batch

Untuk menerapkan fungsi prapemrosesan ke seluruh dataset, gunakan fungsi map dari 🤗 Datasets. Anda dapat mempercepat map dengan meningkatkan jumlah proses melalui parameter num_proc. Hapus kolom yang tidak Anda butuhkan dengan metode remove_columns:

>>> encoded_minds = minds.map(prepare_dataset, remove_columns=minds.column_names["train"], num_proc=4)

🤗 Transformers tidak memiliki data collator untuk ASR, sehingga Anda perlu mengadaptasi DataCollatorWithPadding untuk membuat batch contoh. Collator ini juga akan melakukan padding secara dinamis pada teks dan label Anda hingga panjang elemen terpanjang dalam batch-nya (bukan seluruh dataset) agar panjangnya seragam. Meskipun Anda bisa melakukan padding pada teks di fungsi tokenizer dengan mengatur padding=True, padding dinamis lebih efisien.

Berbeda dengan data collator lainnya, data collator tertentu ini perlu menerapkan metode padding yang berbeda untuk input_values dan labels:

>>> import torch

>>> from dataclasses import dataclass, field
>>> from typing import Any, Dict, List, Optional, Union


>>> @dataclass
... class DataCollatorCTCWithPadding:
...     processor: AutoProcessor
...     padding: Union[bool, str] = "longest"

...     def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
...         # split inputs and labels since they have to be of different lengths and need
...         # different padding methods
...         input_features = [{"input_values": feature["input_values"][0]} for feature in features]
...         label_features = [{"input_ids": feature["labels"]} for feature in features]

...         batch = self.processor.pad(input_features, padding=self.padding, return_tensors="pt")

...         labels_batch = self.processor.pad(labels=label_features, padding=self.padding, return_tensors="pt")

...         # replace padding with -100 to ignore loss correctly
...         labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)

...         batch["labels"] = labels

...         return batch

Sekarang instansiasi DataCollatorCTCWithPadding Anda:

>>> data_collator = DataCollatorCTCWithPadding(processor=processor, padding="longest")

Evaluasi

Menambahkan metrik selama pelatihan sering kali membantu untuk mengevaluasi kinerja model Anda. Anda dapat dengan cepat memuat metode evaluasi dengan pustaka 🤗 Evaluate. Untuk tugas ini, muat metrik word error rate (WER) (lihat quick tour 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

>>> import evaluate

>>> wer = evaluate.load("wer")

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke compute untuk menghitung WER:

>>> import numpy as np


>>> def compute_metrics(pred):
...     pred_logits = pred.predictions
...     pred_ids = np.argmax(pred_logits, axis=-1)

...     pred.label_ids[pred.label_ids == -100] = processor.tokenizer.pad_token_id

...     pred_str = processor.batch_decode(pred_ids)
...     label_str = processor.batch_decode(pred.label_ids, group_tokens=False)

...     wer_score = wer.compute(predictions=pred_str, references=label_str)

...     return {"wer": wer_score}

Fungsi compute_metrics Anda sudah siap digunakan, dan Anda akan kembali ke fungsi ini saat menyiapkan pelatihan.

Latih

Jika Anda belum familiar dengan finetuning model menggunakan Trainer, silakan lihat tutorial dasar di sini!

Anda sekarang siap untuk mulai melatih model Anda! Muat Wav2Vec2 dengan AutoModelForCTC. Tentukan reduksi yang akan diterapkan dengan parameter ctc_loss_reduction. Seringkali lebih baik menggunakan rata-rata daripada penjumlahan bawaan:

>>> from transformers import AutoModelForCTC, TrainingArguments, Trainer

>>> model = AutoModelForCTC.from_pretrained(
...     "facebook/wav2vec2-base",
...     ctc_loss_reduction="mean",
...     pad_token_id=processor.tokenizer.pad_token_id,
... )

Pada titik ini, hanya tersisa tiga langkah:

Definisikan hiperparameter pelatihan Anda di TrainingArguments. Satu-satunya parameter yang wajib diisi adalah output_dir yang menentukan lokasi penyimpanan model Anda. Anda akan mendorong model ini ke Hub dengan mengatur push_to_hub=True (Anda harus masuk ke Hugging Face untuk mengunggah model Anda). Di akhir setiap epoch, Trainer akan mengevaluasi WER dan menyimpan checkpoint pelatihan.
Lewatkan argumen pelatihan ke Trainer bersama dengan model, dataset, tokenizer, data collator, dan fungsi compute_metrics.
Panggil train() untuk melakukan fine-tuning pada model Anda.

>>> training_args = TrainingArguments(
...     output_dir="my_awesome_asr_mind_model",
...     per_device_train_batch_size=8,
...     gradient_accumulation_steps=2,
...     learning_rate=1e-5,
...     warmup_steps=500,
...     max_steps=2000,
...     gradient_checkpointing=True,
...     fp16=True,
...     train_sampling_strategy="group_by_length",
...     eval_strategy="steps",
...     per_device_eval_batch_size=8,
...     save_steps=1000,
...     eval_steps=1000,
...     logging_steps=25,
...     load_best_model_at_end=True,
...     metric_for_best_model="wer",
...     greater_is_better=False,
...     push_to_hub=True,
...     report_to="trackio",
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=encoded_minds["train"],
...     eval_dataset=encoded_minds["test"],
...     processing_class=processor,
...     data_collator=data_collator,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()

Setelah pelatihan selesai, bagikan model Anda ke Hub dengan metode push_to_hub() agar dapat diakses oleh semua orang:

>>> trainer.push_to_hub()

Untuk contoh yang lebih mendalam tentang cara fine-tune model untuk automatic speech recognition, lihat postingan ini untuk ASR bahasa Inggris dan postingan ini untuk ASR multibahasa.

Inferensi

Bagus, sekarang setelah Anda melakukan fine-tuning pada model, Anda dapat menggunakannya untuk inferensi!

Muat file audio yang ingin Anda jalankan inferensinya. Ingatlah untuk melakukan resampling pada laju sampling file audio agar sesuai dengan laju sampling model jika diperlukan!

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> audio_file = dataset[0]["audio"]["path"]

Cara termudah untuk mencoba model fine-tuned Anda untuk inferensi adalah dengan menggunakannya dalam pipeline(). Buat instans pipeline untuk automatic speech recognition dengan model Anda, lalu berikan file audio Anda ke dalamnya:

>>> from transformers import pipeline

>>> transcriber = pipeline("automatic-speech-recognition", model="stevhliu/my_awesome_asr_minds_model")
>>> transcriber(audio_file)
{'text': 'I WOUD LIKE O SET UP JOINT ACOUNT WTH Y PARTNER'}

Transkripsinya cukup baik, tetapi bisa lebih baik lagi! Coba lakukan finetuning model Anda dengan lebih banyak contoh untuk mendapatkan hasil yang lebih baik lagi!

Anda juga dapat mereplikasi hasil dari pipeline secara manual jika Anda mau:

Muat processor untuk memproses praproses file audio dan transkripsi, lalu kembalikan input sebagai tensor PyTorch:

>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("stevhliu/my_awesome_asr_mind_model")
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

Lewatkan input Anda ke model dan kembalikan logits:

>>> from transformers import AutoModelForCTC

>>> model = AutoModelForCTC.from_pretrained("stevhliu/my_awesome_asr_mind_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits

Dapatkan input_ids prediksi dengan probabilitas tertinggi, lalu gunakan processor untuk mendekode input_ids prediksi kembali menjadi teks:

>>> import torch

>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription
['I WOUL LIKE O SET UP JOINT ACOUNT WTH Y PARTNER']

Update on GitHub