# Ses sınıflandırma

Ses sınıflandırma - metinde olduğu gibi - girdi verisinden bir sınıf etiketi çıktısı olarak atar. Tek fark, metin girdileri yerine ham ses dalgalarının kullanılmasıdır. Ses sınıflandırmanın bazı pratik uygulamaları arasında konuşmacı niyetini belirleme, dil sınıflandırma ve hatta hayvan türlerini seslerinden tanımlama yer alır.

Bu kılavuz size şunları gösterecektir:

1. [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) modelini konuşmacı niyetini sınıflandırmak için [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) veri setinde ince ayarlayın.
2. İnce ayarladığınız modeli çıkarım için kullanın.

Bu görevle uyumlu tüm mimarileri ve denetim noktalarını görmek için [görev sayfasını](https://huggingface.co/tasks/audio-classification) kontrol etmenizi öneririz.

Başlamadan önce, gerekli tüm kütüphanelerin yüklendiğinden emin olun:

```bash
pip install transformers datasets evaluate soundfile torchcodec
```

Modelinizi yükleyip toplulukla paylaşabilmeniz için Hugging Face hesabınıza giriş yapmanızı öneririz. İstendiğinde giriş yapmak için token'ınızı girin:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## MInDS-14 veri setini yükle

datasets kütüphanesinden MInDS-14 veri setini yükleyerek başlayın:

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

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

Veri setinin `train` bölümünü, [train_test_split](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.train_test_split) yöntemiyle daha küçük bir eğitim ve test setine ayırın. Bu, tam veri setinde daha fazla zaman harcamadan önce deneyler yapmanıza ve her şeyin çalıştığını doğrulamanıza olanak tanır.

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

Ardından veri setine bir göz atın:

```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
    })
})
```

Veri seti `lang_id` ve `english_transcription` gibi birçok faydalı bilgi içerse de, bu kılavuzda `audio` ve `intent_class` sütunlarına odaklanacaksınız. Diğer sütunları [remove_columns](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.remove_columns) yöntemiyle kaldırın:

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

İşte bir örnek:

```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}
```

İki alan vardır:

- `audio`: Ses dosyasını yüklemek ve yeniden örneklemesi için çağrılması gereken ses sinyalini içeren 1 boyutlu `array`.
- `intent_class`: konuşmacının niyetinin sınıf kimliğini temsil eder.

Modelin etiket adını etiket kimliğinden almasını kolaylaştırmak için, etiket adını bir tam sayıya ve tam sayıyı etiket adına eşleyen bir sözlük oluşturun:

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

Şimdi etiket kimliğini etiket adına dönüştürebilirsiniz:

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

## Ön işleme

Bir sonraki adım, ses sinyalini işlemek için bir Wav2Vec2 özellik çıkarıcısı yüklemektir:

```py
>>> from transformers import AutoFeatureExtractor

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

MInDS-14 veri setinin örneklem hızı 8kHz'dir (bu bilgiyi [veri seti kartında](https://huggingface.co/datasets/PolyAI/minds14) bulabilirsiniz), bu nedenle önceden eğitilmiş Wav2Vec2 modelini kullanmak için veri setini 16kHz'e yeniden örneklemeniz gerekir:

```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}
```

Şimdi şu işlevi gören bir ön işleme fonksiyonu oluşturun:

1. Yüklenmesi gereken `audio` sütununu çağırır ve gerekirse ses dosyasını yeniden örnekler.
2. Ses dosyasının örneklem hızının, bir modelin ön eğitimi sırasında kullanılan ses verisinin örneklem hızıyla eşleşip eşleşmediğini kontrol eder. Bu bilgiyi Wav2Vec2 [model kartında](https://huggingface.co/facebook/wav2vec2-base) bulabilirsiniz.
3. Daha uzun girdileri kısaltmadan toplu işlemek için bir maksimum girdi uzunluğu ayarlayın.

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

Tüm veri setine ön işleme fonksiyonunu uygulamak için 🤗 Datasets [map](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.map) fonksiyonunu kullanın. `map` işlemini hızlandırmak için `batched=True` ayarlayarak veri setinin birden çok öğesini aynı anda işleyebilirsiniz. Modelin gerektirdiği gibi gereksiz sütunları kaldırın ve `intent_class` sütununu `label` olarak yeniden adlandırın:

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

## Değerlendir

Eğitim sırasında bir metrik kullanmak, modelinizin performansını değerlendirmek için genellikle faydalıdır. 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) kütüphanesiyle bir değerlendirme yöntemini hızla yükleyebilirsiniz. Bu görev için [accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) metrikini yükleyin (bir metriğin nasıl yükleneceğini ve hesaplanacağını öğrenmek için 🤗 Evaluate [hızlı turuna](https://huggingface.co/docs/evaluate/a_quick_tour) bakın):

```py
>>> import evaluate

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

Ardından, tahminlerinizi ve etiketlerinizi [compute](https://huggingface.co/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute) işlevine geçirerek doğruluğu hesaplayan bir işlev oluşturun:

```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)
```

`compute_metrics` fonksiyonunuz artık hazır ve eğitiminizi yapılandırırken ona geri döneceksiniz.

## Eğit

[Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer) ile bir modelin ince ayarını yapma konusunda deneyiminiz yoksa, temel öğreticiyi [burada](../training) inceleyebilirsiniz!

Artık modelinizi eğitmeye başlamak için hazırsınız! [AutoModelForAudioClassification](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModelForAudioClassification) ile Wav2Vec2'yi beklenen etiket sayısı ve etiket eşlemeleriyle birlikte yükleyin:

```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
... )
```

Bu noktada yalnızca üç adım kaldı:

1. Eğitim hiperparametrelerinizi [TrainingArguments](/docs/transformers/main/tr/main_classes/trainer#transformers.TrainingArguments) içinde tanımlayın. Tek zorunlu parametre, modelinizi nereye kaydedeceğinizi belirleyen `output_dir`'dir. Modelinizi Hub'a `push_to_hub=True` ayarlayarak yükleyeceksiniz (modelinizi yüklemek için Hugging Face'e giriş yapmış olmanız gerekir). Her epoch'un sonunda [Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer), doğruluğu değerlendirir ve eğitim checkpoint'ini kaydeder.
2. Eğitim argümanlarını, model, veri seti, tokenizer, veri toplayıcı ve `compute_metrics` fonksiyonuyla birlikte [Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer)'a iletin.
3. Modelinizi ince ayarlamak için [train()](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer.train) çağrın.

```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()
```

Eğitim tamamlandıktan sonra, modelinizi herkesin kullanabilmesi için [push_to_hub()](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer.push_to_hub) yöntemiyle Hub'a paylaşın:

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

Ses sınıflandırma için bir modelin nasıl ince ayar yapılacağına dair daha ayrıntılı bir örnek için ilgili [PyTorch defterine](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb) göz atın.

## Çıkarım

Harika, bir model ayarladıktan sonra artık çıkarım için kullanabilirsiniz!

Çıkarım için bir ses dosyası yükleyin. Gerekirse, ses dosyasının örneklem hızını modelin örneklem hızıyla eşleşecek şekilde yeniden örneklemeyi unutmayın.

```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"]
```

İnce ayarını yaptığınız modeli çıkarım için denemenin en basit yolu, onu bir [pipeline()](/docs/transformers/main/tr/main_classes/pipelines#transformers.pipeline) içinde kullanmaktır. Modelinizle ses sınıflandırma için bir `pipeline` örneği oluşturun ve ses dosyanızı ona iletin:

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

İsterseniz `pipeline` sonuçlarını manuel olarak da yeniden üretebilirsiniz:

Ses dosyasını ön işlemek ve `input` değerlerini PyTorch tensörleri olarak döndürmek için bir özellik çıkarıcı yükleyin:

```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")
```

Girdilerinizi modele iletin ve logitleri döndürün:

```py
>>> from transformers import AutoModelForAudioClassification

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

En yüksek olasılığa sahip sınıfı alın ve modelin `id2label` eşlemesini kullanarak bunu bir etikete dönüştürün:

```py
>>> import torch

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