# VibeVoice ASR

## Resumen

VibeVoice ASR es un modelo de reconocimiento automático de voz de Microsoft que combina tokenizadores acústicos y semánticos de audio con un modelo de lenguaje causal para una transcripción robusta de voz a texto. El modelo utiliza los tokenizadores acústicos y semánticos de VibeVoice, que procesan el audio a 24 kHz, junto con un decodificador de lenguaje basado en Qwen2 para generar las transcripciones. Consulte el [informe técnico](https://huggingface.co/papers/2601.18184) para obtener más detalles.

El punto de control del modelo está disponible en: [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF)

Puntos destacados:

- **🕒 Procesamiento de un solo paso de 60 minutos**: A diferencia de los modelos de ASR convencionales que dividen el audio en fragmentos cortos (lo que a menudo provoca la pérdida del contexto global), VibeVoice ASR acepta hasta **60 minutos** de audio continuo dentro de una longitud de 64K tokens. Esto garantiza un seguimiento coherente de los hablantes y una coherencia semántica a lo largo de toda la hora.

- **👤 Palabras clave personalizadas**: Los usuarios pueden proporcionar palabras clave personalizadas (p. ej., nombres específicos, términos técnicos o información de contexto) para guiar el proceso de reconocimiento, lo que mejora significativamente la precisión en contenido específico de un dominio.

- **📝 Transcripción rica (quién, cuándo, qué)**: El modelo realiza conjuntamente ASR, diarización y marcaje de tiempo, generando una salida estructurada que indica *quién* dijo *qué* y *cuándo*.
  
- **🌍 Soporte multilingüe y de cambio de código**: Admite más de 50 idiomas, no requiere configurar el idioma de forma explícita y maneja de forma nativa el cambio de código dentro y entre enunciados.

Este modelo fue aportado por [Eric Bezzam](https://huggingface.co/bezzam).

## Uso

El modelo admite diversas funcionalidades de reconocimiento automático de voz.

### Transcripción con marcas de tiempo por hablante

Una característica destacada de VibeVoice ASR es su capacidad para transcribir contenido de varios hablantes, indicando quién habló y cuándo.

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

El modelo VibeVoice ASR se entrena para generar una cadena que se asemeja a una estructura JSON. El flag `return_format="parsed"` intenta devolver la salida generada como una lista de dicts, mientras que `return_format="transcription_only"` intenta extraer solo el audio transcrito. Si fallan, la salida generada se devuelve tal cual.

### Proporcionar contexto

También es posible proporcionar contexto. Esto puede ser útil si ciertas palabras no se pueden transcribir correctamente, como los nombres propios.

A continuación transcribimos un audio en el que el hablante (con acento alemán) habla sobre VibeVoice, comparando con y sin el contexto "About VibeVoice".

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

### Inferencia por lotes

La inferencia por lotes es posible pasando una lista de audios y, si se proporcionan, una lista de prompts. El número de entradas de audio y prompts debe coincidir (para los prompts, puede establecer una entrada como `None` si no es necesaria para un audio dado).

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

### Ajustar el tamaño de los fragmentos del tokenizador (p. ej., si se agota la memoria)

Una característica clave de VibeVoice ASR es que puede transcribir hasta 60 minutos de audio continuo. Esto se logra dividiendo el audio en segmentos de 60 segundos (1440000 muestras a 24 kHz) y almacenando en caché los estados de convolución entre cada segmento.

Sin embargo, si los fragmentos de 60 segundos son demasiado grandes para tu dispositivo, se puede ajustar el argumento `acoustic_tokenizer_chunk_size` que se pasa a `generate`. *Ten en cuenta que debe ser un múltiplo de la longitud del salto (3200 para el tokenizador acústico original).*

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

### Plantilla de chat

VibeVoice ASR también acepta entradas de plantilla de chat (`apply_transcription_request` es en realidad un envoltorio de `apply_chat_template` para mayor comodidad):
```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)
```

### Entrenamiento

VibeVoice ASR se puede entrenar con la pérdida emitida por el modelo.

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

El modelo se puede compilar para una inferencia/entrenamiento más rápidos.
```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")
```

### Uso de Pipeline

El modelo se puede usar como un pipeline, pero deberá definir sus propios métodos para analizar la salida cruda.

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

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

**Parámetros:**

acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *opcional*) : El objeto de configuración o diccionario del tokenizador acústico. Este tokenizador extrae características acústicas del audio.

semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *opcional*) : El objeto de configuración o diccionario del tokenizador semántico. Este tokenizador extrae características semánticas del audio.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

audio_token_id (`int`, *opcional*, valor predeterminado `151648`) : El índice del token de audio utilizado como marcador de posición para el audio de entrada.

audio_bos_token_id (`int`, *opcional*, valor predeterminado 151646) : El índice del token de inicio de secuencia de audio.

audio_eos_token_id (`int`, *opcional*, valor predeterminado 151647) : El índice del token de fin de secuencia de audio.

acoustic_tokenizer_chunk_size (`int`, *opcional*, valor predeterminado 1440000) : El tamaño de bloque (en número de muestras) que se utilizará al tokenizar las entradas de audio. El valor predeterminado corresponde a 60 segundos a 24 kHz.

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceAsrModel. Se utiliza para instanciar un modelo Vibevoice Asr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : El extractor de características para el procesamiento de audio.

tokenizer (`Qwen2TokenizerFast`) : El tokenizador para el procesamiento de texto.

chat_template (`str`, *opcional*) : Una plantilla de Jinja que se utilizará para convertir listas de mensajes de un chat en una cadena tokenizable.

audio_token (`str`, *opcional*, valor predeterminado `"<|box_start|>"`) : El marcador de posición de token de audio que se usará en la plantilla de chat.

audio_bos_token (`str`, *opcional*, valor predeterminado `"<|object_ref_start|>"`) : El marcador de posición del token de inicio de secuencia de audio que se usará en la plantilla de chat.

audio_eos_token (`str`, *opcional*, valor predeterminado `"<|object_ref_end|>"`) : El marcador de posición del token de fin de secuencia de audio que se utilizará en la plantilla de chat.

audio_duration_token (`str`, *opcional*, valor predeterminado `"<|AUDIO_DURATION|>"`) : El marcador de posición del token de duración de audio que se usará en la plantilla de chat.

Construye un procesador ASR de VibeVoice que envuelve [VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/es/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) y [Qwen2TokenizerFast](/docs/transformers/main/es/model_doc/qwen2#transformers.Qwen2Tokenizer) en un único procesador que hereda tanto las funcionalidades de extracción de características de audio como las del tokenizador.

Consulte [__call__()](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para obtener más información.

#### __llamada__[[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.processing_utils.ProcessingKwargs'>)
```

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

**Parámetros:**

text (`Union[str, list[str]]`) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio.

output_labels (`bool`, *opcional*, predeterminado=False) : Si se deben devolver etiquetas para el entrenamiento.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

**Devuelve:** [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature)

Un diccionario con texto tokenizado (`input_ids`, `attention_mask`) y características de audio (`input_values`, `padding_mask`).

#### 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.processing_utils.ProcessingKwargs'>)
```

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

**Parámetros:**

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Audio a transcribir. Las cadenas se interpretan como rutas locales o URL y se cargan automáticamente mediante el cargador de plantillas de chat; los arreglos de NumPy y los tensores de PyTorch se reenvían directamente.

prompt (`str` o `list[str]`, *opcional*) : Prompt(s) personalizado(s) para incluir en el turno del usuario como contexto adicional. Una lista debe tener la misma longitud que el lote. Cuando es `None`, no se proporciona contexto adicional.

tokenize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben tokenizar los prompts y procesar el audio. Si es `False`, el audio no se carga y los prompts se devuelven como cadenas de texto con marcadores de posición de audio sin expandir. Al pasarlos junto con el audio al procesador, `processor(text=prompts, audio=audio)`, se obtienen las mismas salidas que con `tokenize=True`.

- ****kwargs** : Argumentos de palabra clave adicionales que se reenvían a [apply_chat_template()](/docs/transformers/main/es/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (por ejemplo, `text_kwargs`, `audio_kwargs`, ...).

**Devuelve:** [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature) o `list[str]`

Un prompt por audio cuando `tokenize=False`; en caso contrario, el procesador genera la salida lista para pasarse a [VibeVoiceAsrForConditionalGeneration.generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate).

Prepara las entradas para el reconocimiento automático de voz sin escribir manualmente la plantilla de chat.

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

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

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

**Parámetros:**

return_format (`str`, *opcional*, valor predeterminado `"raw"`) : Las opciones son: - `"raw"`: Devuelve una lista de cadenas decodificadas sin procesar del tokenizador, sin ningún análisis. - `"parsed"`: Devuelve una lista de listas de objetos de diccionario analizados para cada intervención de cada orador, con marcas de tiempo. - `"transcription_only"`: Devuelve una lista de cadenas de transcripción extraídas. `skip_special_tokens` se aplica automáticamente (fijado de forma estricta) a `True` para `"parsed"` y `"transcription_only"`.

Reenvía los argumentos a [decode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) y, opcionalmente, analiza la salida de tipo diccionario.

VibeVoice ASR genera transcripciones en un formato similar a un diccionario, por ejemplo:
```
[
    '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)
```

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

**Parámetros:**

config ([VibeVoiceAsrConfig](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VibeVoice ASR (tokenizador acústico + tokenizador semántico + proyector multimodal + modelo de lenguaje), sin una cabeza de modelado de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para más detalles.

padding_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar operaciones en los índices de características de relleno.

sample (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir ruido gaussiano a los latentes acústicos, tal como en el modelo original (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `vae_std`)). Si es False, la salida del codificador se utiliza tal cual, por lo que la salida es determinista.

**Devuelve:** `VibeVoiceAsrModelOutputWithPast` o `tuple(torch.Tensor)`

Un `VibeVoiceAsrModelOutputWithPast` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([VibeVoiceAsrConfig](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) y las entradas.

El método forward de [VibeVoiceAsrModel](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de audio proyectados.

## VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]]

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

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

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

**Parámetros:**

config ([VibeVoiceAsrConfig](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VibeVoice ASR con tokenizadores acústicos preentrenados y un modelo de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para más detalles.

padding_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar operaciones en los índices de características de relleno.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

sample (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir ruido gaussiano a los latentes acústicos, tal como en el modelo original (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `vae_std`)). Si es False, la salida del codificador se utiliza tal cual, por lo que la salida es determinista.

**Devuelve:** `VibeVoiceAsrCausalLMOutputWithPast` o `tuple(torch.Tensor)`

Un `VibeVoiceAsrCausalLMOutputWithPast` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([VibeVoiceAsrConfig](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) y las entradas.

El método forward de [VibeVoiceAsrForConditionalGeneration](/docs/transformers/main/es/model_doc/vibevoice_asr#transformers.VibeVoiceAsrForConditionalGeneration) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción.
- **past_key_values** (`Cache`, *opcional*) -- Instancia de caché.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de audio proyectados.

Ejemplo:

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

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