# Klasifikasi audio

Klasifikasi audio - sama seperti pada teks - menetapkan label kelas sebagai keluaran dari data masukan. Satu-satunya perbedaannya adalah, alih-alih masukan teks, Anda memiliki bentuk gelombang audio mentah. Beberapa aplikasi praktis dari klasifikasi audio meliputi identifikasi niat pembicara, klasifikasi bahasa, dan bahkan spesies hewan berdasarkan suaranya.

Panduan ini akan menunjukkan cara Anda untuk:

1. Lakukan fine-tuning pada [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) menggunakan dataset [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) untuk mengklasifikasikan niat pembicara.
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/audio-classification)

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

```bash
pip install transformers datasets evaluate 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 dataset MInDS-14 dari pustaka 🤗 Datasets:

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

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

Pisahkan split `train` dari dataset menjadi set train dan test yang lebih kecil dengan metode [train_test_split](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split). Hal ini akan memberi Anda kesempatan untuk bereksperimen dan memastikan semuanya berfungsi sebelum menghabiskan lebih banyak waktu pada dataset lengkap.

```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: 450
    })
    test: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 113
    })
})
```

Meskipun dataset ini mengandung banyak informasi yang berguna, seperti `lang_id` dan `english_transcription`, Anda akan berfokus pada `audio` dan `intent_class` dalam panduan ini. 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(["path", "transcription", "english_transcription", "lang_id"])
```

Berikut adalah contohnya:

```py
>>> minds["train"][0]
{'audio': {'array': array([ 0.        ,  0.        ,  0.        , ..., -0.00048828,
         -0.00024414, -0.00024414], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602b9a5fbb1e6d0fbce91f52.wav',
  'sampling_rate': 8000},
 'intent_class': 2}
```

Ada dua bidang:

- `audio`: `array` satu dimensi dari sinyal suara yang harus dipanggil untuk memuat dan melakukan resampling file audio.
- `intent_class`: mewakili id kelas dari niat pembicara.

Untuk memudahkan model mendapatkan nama label dari id label, buat kamus yang memetakan nama label ke bilangan bulat dan sebaliknya:

```py
>>> labels = minds["train"].features["intent_class"].names
>>> label2id, id2label = dict(), dict()
>>> for i, label in enumerate(labels):
...     label2id[label] = str(i)
...     id2label[str(i)] = label
```

Sekarang Anda dapat mengonversi id label menjadi nama label:

```py
>>> id2label[str(2)]
'app_error'
```

## Pra-pemrosesan

Langkah selanjutnya adalah memuat Wav2Vec2 feature extractor untuk memproses sinyal audio:

```py
>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
```

Dataset MInDS-14 memiliki laju sampling 8kHz (Anda dapat menemukan informasi ini di [kartu dataset](https://huggingface.co/datasets/PolyAI/minds14)-nya), yang berarti Anda perlu melakukan resampling dataset ke 16kHz 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.2098757e-05,  4.6582241e-05, -2.2803260e-05, ...,
         -2.8419291e-04, -2.3305941e-04, -1.1425107e-04], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602b9a5fbb1e6d0fbce91f52.wav',
  'sampling_rate': 16000},
 'intent_class': 2}
```

Sekarang buat fungsi pra-pemrosesan yang:

1. Memanggil kolom `audio` untuk dimuat, dan jika diperlukan, melakukan resampling pada file audio.
2. Memeriksa apakah laju sampling file audio sesuai dengan laju sampling data audio yang digunakan saat prapelatihan model. Anda dapat menemukan informasi ini di [model card](https://huggingface.co/facebook/wav2vec2-base) Wav2Vec2.
3. Atur panjang input maksimum untuk mem-batch input yang lebih panjang tanpa memotongnya.

```py
>>> def preprocess_function(examples):
...     audio_arrays = [x["array"] for x in examples["audio"]]
...     inputs = feature_extractor(
...         audio_arrays, sampling_rate=feature_extractor.sampling_rate, max_length=16000, truncation=True
...     )
...     return inputs
```

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 mengatur `batched=True` untuk memproses beberapa elemen dataset sekaligus. Hapus kolom yang tidak diperlukan dan ganti nama `intent_class` menjadi `label`, sesuai yang dibutuhkan oleh model:

```py
>>> encoded_minds = minds.map(preprocess_function, remove_columns="audio", batched=True)
>>> encoded_minds = encoded_minds.rename_column("intent_class", "label")
```

## Evaluasi

Termasuk 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 [accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) (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

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

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

```py
>>> import numpy as np

>>> def compute_metrics(eval_pred):
...     predictions = np.argmax(eval_pred.predictions, axis=1)
...     return accuracy.compute(predictions=predictions, references=eval_pred.label_ids)
```

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 siap untuk mulai melatih model Anda sekarang! Muat Wav2Vec2 dengan [AutoModelForAudioClassification](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModelForAudioClassification) beserta jumlah label yang diharapkan, dan pemetaan label:

```py
>>> from transformers import AutoModelForAudioClassification, TrainingArguments, Trainer

>>> num_labels = len(id2label)
>>> model = AutoModelForAudioClassification.from_pretrained(
...     "facebook/wav2vec2-base", num_labels=num_labels, label2id=label2id, id2label=id2label
... )
```

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 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](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) akan mengevaluasi akurasi 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_mind_model",
...     eval_strategy="epoch",
...     save_strategy="epoch",
...     learning_rate=3e-5,
...     per_device_train_batch_size=32,
...     gradient_accumulation_steps=4,
...     per_device_eval_batch_size=32,
...     num_train_epochs=10,
...     warmup_steps=0.1,
...     logging_steps=10,
...     load_best_model_at_end=True,
...     metric_for_best_model="accuracy",
...     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=feature_extractor,
...     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 semua orang dapat menggunakan model Anda:

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

Untuk contoh yang lebih mendalam tentang cara fine-tune model untuk klasifikasi audio, lihat [notebook PyTorch](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb) yang sesuai.

## Inferensi

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

Muat file audio untuk inferensi. 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", name="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 klasifikasi audio dengan model Anda, lalu berikan file audio Anda ke dalamnya:

```py
>>> from transformers import pipeline

>>> classifier = pipeline("audio-classification", model="stevhliu/my_awesome_minds_model")
>>> classifier(audio_file)
[
    {'score': 0.09766869246959686, 'label': 'cash_deposit'},
    {'score': 0.07998877018690109, 'label': 'app_error'},
    {'score': 0.0781070664525032, 'label': 'joint_account'},
    {'score': 0.07667109370231628, 'label': 'pay_bill'},
    {'score': 0.0755252093076706, 'label': 'balance'}
]
```

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

Muat feature extractor untuk memproses praproses file audio dan mengembalikan `input` sebagai tensor PyTorch:

```py
>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("stevhliu/my_awesome_minds_model")
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
```

Lewatkan input Anda ke model dan kembalikan logits:

```py
>>> from transformers import AutoModelForAudioClassification

>>> model = AutoModelForAudioClassification.from_pretrained("stevhliu/my_awesome_minds_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
```

Dapatkan kelas dengan probabilitas tertinggi, dan gunakan pemetaan `id2label` model untuk mengubahnya menjadi label:

```py
>>> import torch

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'cash_deposit'
```

