Transformers documentation
VibeVoice ASR
Este modelo se publicó en HF papers el 26 de enero de 2026 y se contribuyó a Hugging Face Transformers el 2 de marzo de 2026.
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 para más detalles.
El punto de control del modelo está disponible en: 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 (a menudo perdiendo el contexto global), VibeVoice ASR acepta hasta 60 minutos de audio continuo dentro de la longitud de 64K tokens. Esto garantiza un seguimiento coherente de los hablantes y una coherencia semántica durante 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, mejorando 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 temporal, 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.
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.
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”.
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).
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).
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):
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.
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.
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.
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
clase transformers.VibeVoiceAsrConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneacoustic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151648audio_bos_token_id: int = 151646audio_eos_token_id: int = 151647acoustic_tokenizer_chunk_size: int = 1440000 )
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 predeterminado151648) — 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) — Índice del token de inicio de secuencia de audio. - audio_eos_token_id (
int, opcional, valor predeterminado 151647) — Í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 utiliza 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
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> 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.configVibeVoiceAsrProcessor
clase transformers.VibeVoiceAsrProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_token = '<|box_start|>'audio_bos_token = '<|object_ref_start|>'audio_eos_token = '<|object_ref_end|>'audio_duration_token = '<|AUDIO_DURATION|>' )
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 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 del token de audio que se utilizará 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 utilizará 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 utilizará en la plantilla de chat.
Construye un procesador de ASR de VibeVoice que envuelve VibeVoiceAcousticTokenizerFeatureExtractor y Qwen2TokenizerFast en un único procesador que hereda tanto las funcionalidades de extracción de características de audio como las del tokenizador.
Consulte call() para obtener más información.
__call__
< source >( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.vibevoice_asr.processing_vibevoice_asr.VibeVoiceAsrProcessorKwargs'> ) → BatchFeature
Parámetros
- text (
Union[str, list[str]]) — La secuencia o lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pretokenizadas). Si se pasa una entrada pretokenizada, establezcais_split_into_words=Truepara evitar ambigüedad con las entradas por lotes. - 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 la muestra del audio. - output_labels (
bool, opcional, default=False) — Si se deben devolver etiquetas para el entrenamiento. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetosnp.ndarrayde NumPy.
- **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.
Devuelve
Un diccionario con texto tokenizado (input_ids, attention_mask) y
características de audio (input_values, padding_mask).
apply_transcription_request
< source >( 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 = Nonetokenize: bool = True**kwargs: *<class 'transformers.models.vibevoice_asr.processing_vibevoice_asr.VibeVoiceAsrProcessorKwargs'> ) → BatchFeature or list[str]
Parámetros
- audio (
str,list[str],np.ndarray,torch.Tensor,list[np.ndarray],list[torch.Tensor]) — Audio a transcribir. Las cadenas de caracteres se interpretan como rutas locales o URLs y se cargarán automáticamente mediante el chat template loader; los arrays de NumPy y los tensores de PyTorch se reenvían directamente. - prompt (
strolist[str], opcional) — Prompts personalizados para incluir en el turno del usuario como contexto adicional. Una lista debe tener la misma longitud que el lote. Cuando esNone, no se proporciona contexto adicional. - tokenize (
bool, opcional, valor predeterminadoTrue) — Indica si se deben tokenizar los prompts y procesar el audio. Si esFalse, el audio no se carga y los prompts se devuelven como cadenas de texto con marcadores de posición de audio sin expandir. Pasarlos junto con el audio al procesador,processor(text=prompts, audio=audio), produce las mismas salidas quetokenize=True. - **kwargs —
Argumentos de palabra clave adicionales que se reenvían a apply_chat_template() (por ejemplo
text_kwargs,audio_kwargs, …).
Devuelve
BatchFeature o list[str]
Un prompt por audio cuando tokenize=False, de lo contrario el procesador devuelve la salida lista para pasarse a VibeVoiceAsrForConditionalGeneration.generate().
Prepara las entradas para el reconocimiento automático de voz sin escribir manualmente la plantilla de chat.
decode
< source >( *argsreturn_format = 'raw'**kwargs )
Parámetros
- return_format (
str, opcional, por defecto es"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 enunciado de cada orador, con marcas de tiempo."transcription_only": Devuelve una lista de cadenas de transcripción extraídas.
skip_special_tokensse aplica automáticamente (se fija de forma estricta) enTruepara"parsed"y"transcription_only".
Reenvía los argumentos a decode() y, opcionalmente, analiza la salida de tipo diccionario.
VibeVoiceAsrModel
clase transformers.VibeVoiceAsrModel
< source >( config: VibeVoiceAsrConfig )
Parámetros
- config (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() 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. Consulta 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 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Nonesample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VibeVoiceAsrModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- 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 usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulte VibeVoiceAsrProcessor.call() para más detalles. - padding_mask (
torch.BoolTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar operaciones en los índices de características de relleno. - sample (
bool, opcional, valor predeterminadoTrue) — Indica si se debe añadir ruido gaussiano a los latentes acústicos, 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) y las entradas.
El método forward de 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
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.Tensorde 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 pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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
clase transformers.VibeVoiceAsrForConditionalGeneration
< source >( config: VibeVoiceAsrConfig )
Parámetros
- config (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() 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. Consulta 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 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0sample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VibeVoiceAsrCausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- 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 usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinput_values, se debe utilizar AutoProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. Consulte VibeVoiceAsrProcessor.call() para más detalles. - padding_mask (
torch.BoolTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar operaciones en los índices de características de relleno. - labels (
torch.LongTensorde 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 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); 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 predeterminado0) — Si es unint, calcula los logits para los últimoslogits_to_keeptokens. Si es0, calcula los logits para todos losinput_ids(caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es untorch.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 predeterminadoTrue) — Indica si se debe añadir ruido gaussiano a los latentes acústicos, 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) y las entradas.
El método forward de 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
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje.logits (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.