Otomatik konuşma tanıma

Otomatik konuşma tanıma (ASR), bir ses sinyalini metne dönüştürür ve ses girişleri dizisini metin çıktılarına eşler. Siri ve Alexa gibi sanlı asistanlar, kullanıcıların her gün faydalanması için ASR modellerini kullanır; ayrıca canlı altyazı oluşturma ve toplantılarda not alma gibi birçok başka faydalı kullanıcıya yönelik uygulama da mevcuttur.

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

Wav2Vec2 modelini MInDS-14 veri seti üzerinde ince ayarlayarak ses dosyalarını metne dönüştürün.
İ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ı kontrol etmenizi öneririz.

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

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

>>> from huggingface_hub import notebook_login

>>> notebook_login()

MInDS-14 veri setini yükle

Önce 🤗 Datasets kütüphanesinden MInDS-14 veri setinin daha küçük bir alt kümesini yükleyerek başlayın. Bu, tam veri setinde eğitim için daha fazla zaman harcamadan önce deneyler yapmanıza ve her şeyin çalıştığını doğrulamanıza olanak tanır.

>>> from datasets import load_dataset, Audio

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

Veri setinin train bölümünü, ~Dataset.train_test_split yöntemiyle eğitim ve test kümesine ayırın:

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

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

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

Veri seti lang_id ve english_transcription gibi birçok faydalı bilgi içerse de bu kılavuz audio ve transcription sütunlarına odaklanmaktadır. Diğer sütunları remove_columns yöntemiyle kaldırın:

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

Örneği bir kez daha inceleyin:

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

İ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.
transcription: hedef metin.

Ön işleme

Sonraki adım, ses sinyalini işlemek için bir Wav2Vec2 işlemcisini yüklemektir:

>>> from transformers import AutoProcessor

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

MInDS-14 veri setinin örneklem hızı 8000Hz'dir (bu bilgiyi veri seti kartında bulabilirsiniz). Bu nedenle, önceden eğitilmiş Wav2Vec2 modelini kullanmak için veri setini 16000Hz'e yeniden örneklemeniz gerekir:

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

Yukarıdaki transcription bölümünde de görebileceğiniz gibi metin, büyük ve küçük harflerin karışımını içeriyor. Wav2Vec2 tokenizer’ı yalnızca büyük harfler üzerinde eğitildiğinden, metnin tokenizer’ın sözlüğüyle eşleştiğinden emin olmanız gerekir:

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


>>> minds = minds.map(uppercase)

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

Ses dosyasını yüklemek ve yeniden örneklemek için audio sütununu çağırır.
Ses dosyasından input_values değerlerini çıkarır ve transcription sütununu işlemci ile tokenlere ayırır.

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

Tüm veri setine ön işleme fonksiyonunu uygulamak için 🤗 Datasets map fonksiyonunu kullanın. map işlemini num_proc parametresiyle süreç sayısını artırarak hızlandırabilirsiniz. İhtiyacınız olmayan sütunları remove_columns metoduyla kaldırın:

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

🤗 Transformers'ta ASR için bir veri toplayıcı (data collator) bulunmadığından, örneklerden bir batch oluşturmak için DataCollatorWithPadding sınıfını uyarlamanız gerekir. Bu sınıf, metin ve etiketleri dinamik olarak batch içindeki en uzun öğenin uzunluğuna (tüm veri setinin uzunluğuna değil) göre doldurarak (padding) hepsinin aynı uzunlukta olmasını sağlar. tokenizer fonksiyonunda padding=True ayarlayarak metinleri doldurmak mümkün olsa da, dinamik doldurma daha verimlidir.

Diğer veri toplayıcılardan farklı olarak, bu özel veri toplayıcı input_values ve labels için farklı bir dolgu yöntemi uygulamalıdır:

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

Şimdi DataCollatorCTCWithPadding sınıfınızı örnekleyin:

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

Değerlendir

Eğitim sırasında bir metrik kullanmak, model performansınızı değerlendirmek için genellikle faydalıdır. 🤗 Evaluate kütüphanesiyle bir değerlendirme yöntemini hızla yükleyebilirsiniz. Bu görev için word error rate (WER) metrik yükleyin (metriklerin yüklenmesi ve hesaplanması hakkında daha fazla bilgi için 🤗 Evaluate quick tour sayfasına bakın):

>>> import evaluate

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

Ardından, tahminlerinizi ve etiketlerinizi compute fonksiyonuna ileterek WER değerini hesaplayan bir fonksiyon oluşturun:

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

compute_metrics fonksiyonunuz artık hazır ve eğitiminizi kurarken ona geri döneceksiniz.

Eğit

Trainer ile bir modeli ince ayar yapma konusunda deneyiminiz yoksa, temel öğreticiyi burada inceleyebilirsiniz!

Artık modelinizi eğitmeye hazırsınız! Wav2Vec2'yi AutoModelForCTC ile yükleyin. Uygulanacak indirgemeyi ctc_loss_reduction parametresiyle belirtin. Varsayılan toplama yerine ortalama kullanmak genellikle daha iyidir:

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

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

Eğitim hiperparametrelerinizi TrainingArguments içinde tanımlayın. Tek zorunlu parametre, modelin nereye kaydedileceğini belirleyen output_dir'dir. Modeli 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, WER değerini değerlendirir ve eğitim checkpoint'ini kaydeder.
Eğitim argümanlarını, model, veri seti, tokenizer, veri toplayıcı ve compute_metrics fonksiyonuyla birlikte Trainer'a iletin.
Modelinizi ince ayarlamak için train() çağrın.

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

Eğitim tamamlandıktan sonra, modelinizi herkesin erişimine açık olması için push_to_hub() yöntemiyle Hub'a paylaşın:

>>> trainer.push_to_hub()

Otomatik konuşma tanıma için bir modelin nasıl ince ayar yapılacağına dair daha ayrıntılı bir örnek için, İngilizce ASR için bu blog yazısına ve çok dilli ASR için bu yazıya göz atın.

Çıkarım

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

Çıkarım (inference) yapmak istediğiniz bir ses dosyasını yükleyin. Gerekirse, ses dosyasının örneklem hızını modelin örneklem hızıyla eşleştirmek için yeniden örneklemeyi (resample) unutmayın!

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

İnce ayarını yaptığınız modeli çıkarım için denemenin en basit yolu, onu bir pipeline() içinde kullanmaktır. Modelinizle otomatik konuşma tanıma için bir pipeline örneği oluşturun ve ses dosyanızı ona iletin:

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

Transkripsiyon oldukça iyi, ama daha da iyileştirilebilir! Daha iyi sonuçlar almak için modelinizi daha fazla örnek üzerinde ince ayar yapmayı deneyin!

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

Ses dosyasını ve transkripsiyonu ön işlemek için bir işlemci yükleyin ve input değerini PyTorch tensörleri olarak döndürün:

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

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

>>> from transformers import AutoModelForCTC

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

En yüksek olasılığa sahip tahmini input_ids değerini alın ve işlemciyi kullanarak tahmini input_ids değerini metne geri dönüştürün:

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