# VibeVoice ASR

## Genel Bakış

VibeVoice ASR, Microsoft tarafından geliştirilen ve akustik ile semantik ses tokenleştiricilerini, sağlam ses-metne dönüştürme transkripsiyonu için nedensel bir dil modeliyle birleştiren otomatik konuşma tanıma modelidir. Model, 24kHz'de ses işleyen VibeVoice'un akustik ve semantik tokenleştiricilerini, transkripsiyon üretmek için Qwen2 tabanlı bir dil çözücüyle eşleştirir. Daha fazla ayrıntı için [teknik raporu](https://huggingface.co/papers/2601.18184)na bakın.

Model kontrol noktası şu adreste kullanılabilir: [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF)

Öne çıkanlar:

- **🕒 60 dakikalık Tek Geçişli İşleme**: Sesli parçaları kısa dilimlere bölen (genellikle küresel bağlamı kaybeden) geleneksel ASR modellerinin aksine, VibeVoice ASR, 64K token uzunluğu içinde **60 dakikaya** kadar kesintisiz ses girdisi kabul eder. Bu, tüm saat boyunca tutarlı konuşmacı takibi ve anlamsal bütünlük sağlar.

- **👤 Özelleştirilmiş Sıcak Kelimeler**: Kullanıcılar, tanıma sürecini yönlendirmek için özelleştirilmiş sıcak kelimeler (ör. belirli isimler, teknik terimler veya arka plan bilgisi) sağlayabilir; bu, alanına özgü içeriklerde doğruluğu önemli ölçüde artırır.

- **📝 Zengin Transkripsiyon (Kim, Ne Zaman, Ne)**: Model, ASR, konuşmacı ayrımı ve zaman damgalama işlemlerini birlikte gerçekleştirir; *kim*in *neyi* ve *ne zaman* söylediğini gösteren yapılandırılmış bir çıktı üretir.
  
- **🌍 Çok Dilli ve Dil Karışımı (Code-Switching) Desteği**: 50'den fazla dili destekler, açık bir dil ayarı gerektirmez ve cümle içi ile cümleler arası dil karışımını yerel olarak işler.

Bu model [Eric Bezzam](https://huggingface.co/bezzam) tarafından katkıda bulunmuştur.

## Kullanım

Model, çeşitli otomatik konuşma tanıma işlevlerini destekler.

### Konuşmacı zaman damgalı transkripsiyon

VibeVoice ASR'nin dikkat çekici bir özelliği, çok konuşmacılı içerikleri kimin ne zaman konuştuğunu belirterek transkribe edebilmesidir.

```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")
print(f"Model loaded on {model.device} with dtype {model.dtype}")

# Prepare inputs using `apply_transcription_request`
inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav",
).to(model.device, model.dtype)

# Apply model
output_ids = model.generate(**inputs)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids)[0]
print("\n" + "=" * 60)
print("RAW OUTPUT")
print("=" * 60)
print(transcription)

transcription = processor.decode(generated_ids, return_format="parsed")[0]
print("\n" + "=" * 60)
print("TRANSCRIPTION (list of dicts)")
print("=" * 60)
for speaker_transcription in transcription:
    print(speaker_transcription)

# Remove speaker labels, only get raw transcription
transcription = processor.decode(generated_ids, return_format="transcription_only")[0]
print("\n" + "=" * 60)
print("TRANSCRIPTION ONLY")
print("=" * 60)
print(transcription)

"""
============================================================
RAW OUTPUT
============================================================
<|im_start|>assistant
[{"Start":0,"End":15.43,"Speaker":0,"Content":"Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me."},{"Start":15.43,"End":21.05,"Speaker":1,"Content":"Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings."},{"Start":21.05,"End":31.66,"Speaker":0,"Content":"Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible."},{"Start":31.66,"End":40.93,"Speaker":1,"Content":"Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."}]<|im_end|>
<|endoftext|>

============================================================
TRANSCRIPTION (list of dicts)
============================================================
{'Start': 0, 'End': 15.43, 'Speaker': 0, 'Content': "Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me."}
{'Start': 15.43, 'End': 21.05, 'Speaker': 1, 'Content': "Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings."}
{'Start': 21.05, 'End': 31.66, 'Speaker': 0, 'Content': "Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible."}
{'Start': 31.66, 'End': 40.93, 'Speaker': 1, 'Content': "Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."}

============================================================
TRANSCRIPTION ONLY
============================================================
Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me. Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings. Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible. Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it.
"""
```

VibeVoice ASR modeli, JSON yapısına benzeyen bir dize üretmek üzere eğitilmiştir. `return_format="parsed"` bayrağı, üretilen çıktıyı sözlük listesi olarak döndürmeye çalışırken `return_format="transcription_only"` yalnızca transkribe edilen sesi çıkarmaya çalışır. Başarısız olurlarsa, üretilen çıktı olduğu gibi döndürülür.

### Bağlam sağlama

Bağlam sağlamak da mümkündür. Bu, özellikle isimler gibi bazı kelimelerin doğru şekilde transkribe edilemediği durumlarda faydalı olabilir.

Aşağıda, konuşmacının (Alman aksanıyla) VibeVoice hakkında, "About VibeVoice" bağlamı ile ve olmadan karşılaştırarak konuştuğu bir ses kaydının transkripsiyonu yer almaktadır.

```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")
print(f"Model loaded on {model.device} with dtype {model.dtype}")

# Without context
inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
).to(model.device, model.dtype)
output_ids = model.generate(**inputs)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids, return_format="transcription_only")[0]
print(f"WITHOUT CONTEXT: {transcription}")

# With context
inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
    prompt="About VibeVoice",
).to(model.device, model.dtype)
output_ids = model.generate(**inputs)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids, return_format="transcription_only")[0]
print(f"WITH CONTEXT   : {transcription}")

"""
WITHOUT CONTEXT: Revevoices is a novel framework designed for generating expressive, long-form, multi-speaker conversational audio.
WITH CONTEXT   : VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio.
"""
```

### Toplu çıkarım

`None` değeri, belirli bir ses için gerekmediğinde prompt için bir giriş olarak ayarlanabilir. Ses girişleri ve promptların sayısı eşleşmelidir. Bir ses listesi ve, varsa, bir prompt listesi geçirilerek toplu çıkarım (batch inference) yapılabilir.

```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"
audio = [
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav"
]
prompts = ["About VibeVoice", None]

processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")
print(f"Model loaded on {model.device} with dtype {model.dtype}")

inputs = processor.apply_transcription_request(audio, prompt=prompts).to(model.device, model.dtype)
output_ids = model.generate(**inputs)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids, return_format="transcription_only")

print(transcription)
```

### Tokenizer parçasını ayarlama (ör. bellek hatası durumunda)

VibeVoice ASR'nin temel özelliklerinden biri, 60 dakikaya kadar kesintisiz sesin transkripsiyonunu yapabilmesidir. Bu, sesin 60 saniyelik segmentlere (24 kHz'de 1440000 örnek) bölünmesi ve segmentler arasında konvolüsyon durumlarının önbelleğe alınmasıyla gerçekleştirilir.

Ancak, 60 saniyelik parçalar cihazınız için çok büyükse, `generate` fonksiyonuna iletilen `acoustic_tokenizer_chunk_size` argümanı ayarlanabilir. *Hop uzunluğunun (orijinal akustik tokenizer için 3200) katı olması gerektiğini unutmayın.*

```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

acoustic_tokenizer_chunk_size = 64000    # default is 1440000 (60s @ 24kHz)
model_id = "microsoft/VibeVoice-ASR-HF"
audio = [
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav"
]
prompts = ["About VibeVoice", None]

processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")
print(f"Model loaded on {model.device} with dtype {model.dtype}")

inputs = processor.apply_transcription_request(audio, prompt=prompts).to(model.device, model.dtype)
output_ids = model.generate(**inputs, acoustic_tokenizer_chunk_size=acoustic_tokenizer_chunk_size)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids, return_format="transcription_only")
print(transcription)
```

### Sohbet şablonu

VibeVoice ASR, sohbet şablonu girdilerini de kabul eder (`apply_transcription_request`, pratiklik için `apply_chat_template` için bir sarmalayıcıdır):
```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")

chat_template = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "About VibeVoice"},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
                },
            ],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav",
                },
            ],
        }
    ],
]

inputs = processor.apply_chat_template(
    chat_template,
    tokenize=True,
    return_dict=True,
).to(model.device, model.dtype)

output_ids = model.generate(**inputs)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
transcription = processor.decode(generated_ids, return_format="transcription_only")
print(transcription)
```

### Eğitim

VibeVoice ASR, modelin ürettiği kayıpla eğitilebilir.

```python
from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()

# Prepare batch of 2
# -- NOTE: the original model is trained to output transcription, speaker ID, and timestamps in JSON-like format. Below we are only using the transcription text as the label
chat_template = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio."},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
                },
            ],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Hello everyone and welcome to the VibeVoice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me. Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings. Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible. Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav",
                },
            ],
        }
    ],
]
inputs = processor.apply_chat_template(
    chat_template,
    tokenize=True,
    return_dict=True,
    output_labels=True,
).to(model.device, model.dtype)

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()
```

### Torch derleme

Model, daha hızlı çıkarım/eğitim için derlenebilir.
```python
import time

import torch

from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration

model_id = "microsoft/VibeVoice-ASR-HF"

num_warmup = 5
num_runs = 20

# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto")

# Prepare static inputs
chat_template = [
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio.",
                },
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
                },
            ],
        }
    ],
] * 4  # batch size 4
inputs = processor.apply_chat_template(
    chat_template,
    tokenize=True,
    return_dict=True,
).to(model.device, torch.bfloat16)

# Benchmark without compile
print("Warming up without compile...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking without torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
no_compile_time = (time.time() - start) / num_runs
print(f"Average time without compile: {no_compile_time:.4f}s")

# Benchmark with compile
print("\nCompiling model...")
model = torch.compile(model)

print("Warming up with compile (includes graph capture)...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking with torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
compile_time = (time.time() - start) / num_runs
print(f"Average time with compile: {compile_time:.4f}s")

speedup = no_compile_time / compile_time
print(f"\nSpeedup: {speedup:.2f}x")
```

### Pipeline kullanımı

Model bir pipeline olarak kullanılabilir ancak ham çıktıyı ayrıştırmak için kendi yöntemlerinizi tanımlamanız gerekir.

```python
from transformers import pipeline

model_id = "microsoft/VibeVoice-ASR-HF"
pipe = pipeline("any-to-any", model=model_id, device_map="auto")
chat_template = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "About VibeVoice"},
            {
                "type": "audio",
                "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
            },
        ],
    }
]
outputs = pipe(text=chat_template, return_full_text=False)

print("\n" + "=" * 60)
print("RAW PIPELINE OUTPUT")
print("=" * 60)
print(outputs[0]["generated_text"])

print("\n" + "=" * 60)
print("DICT OUTPUT")
print("=" * 60)
dict_output = pipe.processor.extract_speaker_dict(outputs[0]["generated_text"])
print(dict_output)

print("\n" + "=" * 60)
print("TRANSCRIPT OUTPUT")
print("=" * 60)
transcription = pipe.processor.extract_transcription(outputs[0]["generated_text"])
print(transcription)
```

## VibeVoiceAsrConfig[[transformers.VibeVoiceAsrConfig]]

#### transformers.VibeVoiceAsrConfig[[transformers.VibeVoiceAsrConfig]]

```python
transformers.VibeVoiceAsrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, acoustic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151648, audio_bos_token_id: int = 151646, audio_eos_token_id: int = 151647, acoustic_tokenizer_chunk_size: int = 1440000)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py#L31)

**Parametreler:**

acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *isteğe bağlı*) : Akustik belirteç ayrıştırıcısının yapılandırma nesnesi veya sözlüğü. Bu belirteç ayrıştırıcısı, seslerden akustik özellikleri çıkarır.

semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *isteğe bağlı*) : Semantik belirteç ayrıştırıcısının yapılandırma nesnesi veya sözlüğü. Bu belirteç ayrıştırıcısı, seslerden semantik özellikleri çıkarır.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Metin omurgasının yapılandırma nesnesi veya sözlüğü.

audio_token_id (`int`, *isteğe bağlı*, varsayılan `151648`) : Girdi sesinin yer tutucusu olarak kullanılan ses jetonu indeksi.

audio_bos_token_id (`int`, *isteğe bağlı*, varsayılan 151646) : Ses dizisi başlangıç tokeni indeksi.

audio_eos_token_id (`int`, *isteğe bağlı*, varsayılan 151647) : Ses dizin sonu (end-of-sequence) belirteç dizini.

acoustic_tokenizer_chunk_size (`int`, *opsiyonel*, varsayılan 1440000) : Sözcükleştiricinin (tokenizer) ses girdilerini işlerken kullanacağı parça boyutu (örnek sayısı cinsinden). Varsayılan değer, 24kHz'de 60 saniyeye karşılık gelir.

Bu, bir VibeVoiceAsrModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Vibevoice Asr modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import VibeVoiceAsrForConditionalGeneration, VibeVoiceAsrConfig, VibeVoiceAcousticTokenizerEncoderConfig, Qwen2Config

>>> # Initializing VibeVoice acoustic and semantic encoder configs
>>> acoustic_config = VibeVoiceAcousticTokenizerEncoderConfig()
>>> semantic_config = VibeVoiceAcousticTokenizerEncoderConfig(hidden_size=128)

>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()

>>> # Initializing a VibeVoice ASR configuration
>>> configuration = VibeVoiceAsrConfig(acoustic_config, semantic_config, text_config)

>>> # Initializing a model from the vibevoice_asr style configuration
>>> model = VibeVoiceAsrForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## VibeVoiceAsrProcessor[[transformers.VibeVoiceAsrProcessor]]

#### transformers.VibeVoiceAsrProcessor[[transformers.VibeVoiceAsrProcessor]]

```python
transformers.VibeVoiceAsrProcessor(feature_extractor, tokenizer, chat_template = None, audio_token = '<|box_start|>', audio_bos_token = '<|object_ref_start|>', audio_eos_token = '<|object_ref_end|>', audio_duration_token = '<|AUDIO_DURATION|>')
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L48)

**Parametreler:**

feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : Ses işleme için özellik çıkarıcı.

tokenizer (`Qwen2TokenizerFast`) : Metin işleme için belirteç ayrıştırıcı.

chat_template (`str`, *isteğe bağlı*) : Bir sohbet içindeki mesaj listelerini tokenize edilebilir bir metne dönüştürmek için kullanılacak bir Jinja şablonu.

audio_token (`str`, *isteğe bağlı*, varsayılan `"<|box_start|>"`) : Sohbet şablonunda kullanılacak ses belirteci yer tutucusu.

audio_bos_token (`str`, *isteğe bağlı*, varsayılan `"<|object_ref_start|>"`) : Sohbet şablonunda kullanılacak ses başlangıç dizisi (begin-of-sequence) belirteci yer tutucusu.

audio_eos_token (`str`, *isteğe bağlı*, varsayılan `"<|object_ref_end|>"`) : Sohbet şablonunda kullanılacak ses dizin sonu (end-of-sequence) belirteci yer tutucusu.

audio_duration_token (`str`, *isteğe bağlı*, varsayılan `"<|AUDIO_DURATION|>"`) : Sohbet şablonunda kullanılacak ses süresi belirteci yer tutucusu.

[VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/tr/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) ve [Qwen2TokenizerFast](/docs/transformers/main/tr/model_doc/qwen2#transformers.Qwen2Tokenizer) bileşenlerini, hem ses özellik çıkarımı hem de tokenizer işlevselliğini devralan tek bir işlemciye sararak bir VibeVoice ASR işlemcisi oluşturur.

Daha fazla bilgi için [__call__()](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) yöntemine bakın.

#### __call__[[transformers.VibeVoiceAsrProcessor.__call__]]

```python
__call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.models.vibevoice_asr.processing_vibevoice_asr.VibeVoiceAsrProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L94)

**Parametreler:**

text (`Union[str, list[str]]`) : Kodlanacak dizi veya dizi partisi. Her dizi bir metin veya metin listesi (önceden tokenize edilmiş metin) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, partili girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *isteğe bağlı*) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

output_labels (`bool`, *isteğe bağlı*, varsayılan=False) : Eğitim için etiketlerin döndürülüp döndürülmeyeceğini belirtir.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

**Dönüş:** [BatchFeature](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.BatchFeature)

Tokenize edilmiş metin (`input_ids`, `attention_mask`) ve ses özellikleri (`input_values`, `padding_mask`) içeren bir sözlük.

#### apply_transcription_request[[transformers.VibeVoiceAsrProcessor.apply_transcription_request]]

```python
apply_transcription_request(audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], prompt: str | list[str] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.models.vibevoice_asr.processing_vibevoice_asr.VibeVoiceAsrProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L177)

**Parametreler:**

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Transkribe edilecek ses. Dizgiler yerel yollar veya URL'ler olarak yorumlanır ve sohbet şablonu yükleyicisi tarafından otomatik olarak yüklenir; NumPy dizileri ve PyTorch tensörleri doğrudan iletilir.

prompt (`str` veya `list[str]`, *isteğe bağlı*) : Kullanıcı turuna ek bağlam olarak dahil edilecek özel istem(ler). Bir liste, partinin uzunluğuyla aynı uzunlukta olmalıdır. `None` olduğunda, ek bağlam sağlanmaz.

tokenize (`bool`, *isteğe bağlı*, varsayılan `True`) : İfadelerin (prompts) tokenize edilip edilmeyeceğini ve sesin işlenip işlenmeyeceğini belirler. `False` ise ses yüklenmez ve ifadeler, genişletilmemiş ses yer tutucuları (placeholders) içeren dizgeler olarak döndürülür. Bunları sesle birlikte işlemciye (processor) iletirseniz, `processor(text=prompts, audio=audio)`, `tokenize=True` ile aynı çıktıları verir.

- ****kwargs** : [apply_chat_template()](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) fonksiyonuna iletilecek ek anahtar kelime argümanları (örneğin `text_kwargs`, `audio_kwargs`, ...).

**Dönüş:** [BatchFeature](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.BatchFeature) veya `list[str]`

`tokenize=False` olduğunda ses başına bir istem, aksi halde [VibeVoiceAsrForConditionalGeneration.generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) fonksiyonuna doğrudan geçirilmeye hazır işlemci çıktıları.

Otomatik konuşma tanıma için girdileri, sohbet şablonunu elle yazmadan hazırlayın.

#### decode[[transformers.VibeVoiceAsrProcessor.decode]]

```python
decode(*args, return_format = 'raw', **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L233)

**Parametreler:**

return_format (`str`, *isteğe bağlı*, varsayılan `"raw"`) : Seçenekler: - `"raw"`: Tokenizer'dan herhangi bir ayrıştırma yapılmadan ham çözümlenmiş dizeler listesi döndürür. - `"parsed"`: Her konuşmacı ifadesi için zaman damgalarıyla birlikte ayrıştırılmış sözlük nesneleri listesi döndürür. - `"transcription_only"`: Çıkarılan transkripsiyon dizeleri listesi döndürür. `skip_special_tokens`, `"parsed"` ve `"transcription_only"` için otomatik olarak (sabit olarak) `True` olarak ayarlanır.

Argümanları [decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) işlevine iletin ve isteğe bağlı olarak sözlük benzeri çıktıyı ayrıştırın.

VibeVoice ASR, transkripsiyonları sözlük benzeri bir biçimde çıktılar, örneğin:
```
[
    'assistant
":0.0,"End":7.56,"Speaker":0,"Content":"text"}]

    'assistant
":0,"End":5.20,"Speaker":0,"Content":"text"}]

]
```

## VibeVoiceAsrModel[[transformers.VibeVoiceAsrModel]]

#### transformers.VibeVoiceAsrModel[[transformers.VibeVoiceAsrModel]]

```python
transformers.VibeVoiceAsrModel(config: VibeVoiceAsrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L304)

**Parametreler:**

config ([VibeVoiceAsrConfig](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Dil modelleme kafası olmadan VibeVoice ASR modeli (akustik belirteçleyici + anlamsal belirteçleyici + çok modlu projeksiyoncu + dil modeli).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.VibeVoiceAsrModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L379)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi ham ses dalgasının float değerleri. Değerler, bir `.flac` veya `.wav` ses dosyasını `list[float]` tipinde bir diziye, `numpy.ndarray` veya `torch.Tensor` içine yükleyerek elde edilebilir; *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) bölümüne bakın.

padding_mask (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu özellik indeksleri üzerinde işlemleri gerçekleştirmekten kaçınmak için maske.

sample (`bool`, *isteğe bağlı*, varsayılan `True`) : Orijinal modelde olduğu gibi akustik latentlere Gauss gürültüsü eklenip eklenmeyeceğini belirtir (σ-VAE: gürültü ölçeği, parti başına bir öğe için N(0, `vae_std`) dağılımından çekilir). False ise, kodlayıcı çıktısı olduğu gibi kullanılır ve çıktı deterministik olur.

**Dönüş:** `VibeVoiceAsrModelOutputWithPast` veya `tuple(torch.Tensor)`

Bir `VibeVoiceAsrModelOutputWithPast` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırma ([VibeVoiceAsrConfig](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VibeVoiceAsrModel](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **audio_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- Projeksiyonlanmış ses gizli durumları.

## VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]]

#### transformers.VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]]

```python
transformers.VibeVoiceAsrForConditionalGeneration(config: VibeVoiceAsrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L435)

**Parametreler:**

config ([VibeVoiceAsrConfig](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Önceden eğitilmiş akustik belirleyiciler ve bir dil modeline sahip VibeVoice ASR modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.VibeVoiceAsrForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L445)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi ham ses dalgasının float değerleri. Değerler, bir `.flac` veya `.wav` ses dosyasını `list[float]` tipinde bir diziye, `numpy.ndarray` veya `torch.Tensor` içine yükleyerek elde edilebilir; *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) bölümüne bakın.

padding_mask (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu özellik indeksleri üzerinde işlemleri gerçekleştirmekten kaçınmak için maske.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı ya da -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

logits_to_keep (`Union[int, torch.Tensor]`, *isteğe bağlı*, varsayılan `0`) : `int` ise, son `logits_to_keep` token için logits hesaplanır. `0` ise, tüm `input_ids` için logits hesaplanır (özel durum). Üretim için yalnızca son token'ın logits'ine ihtiyaç duyulur ve bunların yalnızca o token için hesaplanması bellek tasarrufu sağlar; bu, uzun diziler veya büyük sözlük boyutu için oldukça önemli hale gelir. `torch.Tensor` ise, dizi uzunluğu boyutunda tutulacak indekslere karşılık gelen 1B olmalıdır. Bu, paketlenmiş tensor biçimini (batch ve dizi uzunluğu için tek boyut) kullanırken faydalıdır.

sample (`bool`, *isteğe bağlı*, varsayılan `True`) : Orijinal modelde olduğu gibi akustik latentlere Gauss gürültüsü eklenip eklenmeyeceğini belirtir (σ-VAE: gürültü ölçeği, parti başına bir öğe için N(0, `vae_std`) dağılımından çekilir). False ise, kodlayıcı çıktısı olduğu gibi kullanılır ve çıktı deterministik olur.

**Dönüş:** `VibeVoiceAsrCausalLMOutputWithPast` veya `tuple(torch.Tensor)`

`VibeVoiceAsrCausalLMOutputWithPast` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([VibeVoiceAsrConfig](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VibeVoiceAsrForConditionalGeneration](/docs/transformers/main/tr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrForConditionalGeneration) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Tahmin puanları.
- **past_key_values** (`Cache`, *isteğe bağlı*) -- Cache örneği.
- **hidden_states** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren ve `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **audio_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- Projeksiyonlanmış ses gizli durumları.

Örnek:

```python
>>> from transformers import VibeVoiceAsrForConditionalGeneration, AutoProcessor

>>> model_id = "microsoft/VibeVoice-ASR-HF"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, dtype="auto", device_map="auto")
```

#### get_audio_features[[transformers.VibeVoiceAsrForConditionalGeneration.get_audio_features]]

```python
get_audio_features(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L442)