# 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:

1. Lakukan fine-tuning [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) pada dataset [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) untuk mentranskripsi audio menjadi teks.
2. 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](https://huggingface.co/tasks/automatic-speech-recognition)

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

```bash
pip install transformers datasets evaluate jiwer soundfile 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:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Muat dataset MInDS-14

Mulai dengan memuat subset yang lebih kecil dari dataset [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) 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.

```py
>>> from datasets import load_dataset, Audio

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

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

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

Lalu, lihatlah dataset-nya:

```py
>>> 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](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.remove_columns):

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

Ulangi meninjau contoh tersebut:

```py
>>> 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:

```py
>>> 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](https://huggingface.co/datasets/PolyAI/minds14)-nya), yang berarti Anda perlu melakukan resampling dataset ke 16000Hz untuk menggunakan model Wav2Vec2 yang telah dilatih sebelumnya:

```py
>>> 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 berisi campuran huruf kapital dan huruf kecil. Tokenizer Wav2Vec2 hanya dilatih pada karakter kapital, jadi Anda perlu memastikan bahwa teks tersebut sesuai dengan kosakata tokenizer:

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

>>> minds = minds.map(uppercase)
```

Sekarang buat fungsi pra-pemrosesan yang:

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

```py
>>> 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 pra-pemrosesan ke seluruh dataset, gunakan fungsi [map](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.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](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.remove_columns):

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

🤗 Transformers tidak memiliki data collator untuk ASR, jadi Anda perlu mengadaptasi [DataCollatorWithPadding](/docs/transformers/v5.23.0/id/main_classes/data_collator#transformers.DataCollatorWithPadding) untuk membuat batch contoh. Collator ini juga akan secara dinamis melakukan padding pada teks dan label Anda hingga panjang elemen terpanjang dalam batch-nya (bukan seluruh dataset) sehingga panjangnya seragam. Meskipun Anda dapat 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`:

```py
>>> 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:

```py
>>> 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](https://huggingface.co/docs/evaluate/index). Untuk tugas ini, muat metrik [word error rate](https://huggingface.co/spaces/evaluate-metric/wer) (WER) (lihat [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

```py
>>> import evaluate

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) untuk menghitung WER:

```py
>>> 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](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer), silakan lihat tutorial dasar [di sini](../training)!

Anda sekarang siap untuk mulai melatih model Anda! Muat Wav2Vec2 dengan [AutoModelForCTC](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModelForCTC). Tentukan reduksi yang akan diterapkan dengan parameter `ctc_loss_reduction`. Seringkali lebih baik menggunakan rata-rata daripada penjumlahan bawaan:

```py
>>> 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:

1. Definisikan hiperparameter pelatihan Anda di [TrainingArguments](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.TrainingArguments). Satu-satunya parameter yang wajib diisi adalah `output_dir` yang menentukan di mana model Anda akan disimpan. 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](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) akan mengevaluasi WER dan menyimpan checkpoint pelatihan.
2. Lewatkan argumen pelatihan ke [Trainer](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) bersama dengan model, dataset, tokenizer, data collator, dan fungsi `compute_metrics`.
3. Panggil [train()](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer.train) untuk melakukan fine-tuning pada model Anda.

```py
>>> 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()](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer.push_to_hub) agar dapat diakses oleh semua orang:

```py
>>> trainer.push_to_hub()
```

Untuk contoh yang lebih mendalam tentang cara fine-tune model untuk automatic speech recognition, lihat [postingan](https://huggingface.co/blog/fine-tune-wav2vec2-english) ini untuk ASR bahasa Inggris dan [postingan](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2) 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!

```py
>>> 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()](/docs/transformers/v5.23.0/id/main_classes/pipelines#transformers.pipeline). Buat instans `pipeline` untuk automatic speech recognition dengan model Anda, lalu berikan file audio Anda ke dalamnya:

```py
>>> 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:

```py
>>> 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:

```py
>>> 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:

```py
>>> 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']
```

