Transformers documentation
VibeVoice
Este modelo se publicó en HF papers el 26 de agosto de 2025 y se contribuyó a Hugging Face Transformers el 27 de agosto de 2026.
VibeVoice
Resumen
VibeVoice es un marco novedoso para sintetizar audio de alta fidelidad y de larga duración con múltiples hablantes, empleando un enfoque de difusión de próximo token dentro de una estructura de modelo de lenguaje grande (LLM). Está diseñado para capturar la auténtica “vibe” conversacional y es especialmente adecuado para generar contenido de audio como pódcasts y audiolibros con múltiples participantes.
Hay dos puntos de control de modelos disponibles en:
Este modelo fue aportado por Eric Bezzam.
Arquitectura

El marco de trabajo VibeVoice integra tres componentes clave:
- Tokenizadores de voz continuos: Tokenizadores acústicos y semánticos especializados, donde el tokenizador acústico utiliza un $\sigma$-VAE para lograr una compresión ultrabaja (7,5 tokens/seg, 3200x) para la escalabilidad y la fidelidad, y el tokenizador semántico utiliza una tarea proxy de ASR para la extracción de características centrada en el contenido.
- Modelo de lenguaje de gran escala (LLM): Utiliza Qwen2.5 (en versiones de 1.5B y 7B) como su modelo de secuencia principal.
- Cabeza de difusión a nivel de token: condicionada en el estado oculto del LLM y responsable de predecir las características continuas del VAE de forma en streaming.
El checkpoint original de VibeVoice-1.5B está disponible bajo la organización Microsoft en Hugging Face.
Características principales
- Síntesis de formato largo: Puede sintetizar hasta 90 minutos de conversación hablada con múltiples hablantes.
- Diálogo de varios hablantes: Capaz de sintetizar audio con un máximo de 4 hablantes.
- Calidad de vanguardia: Supera a las líneas base en métricas tanto subjetivas como objetivas.
- Alta compresión: Lograda mediante un tokenizador acústico novedoso que opera a una tasa de fotogramas ultrabaja de 7,5 Hz.
- LLM escalable: Escalar el LLM central de 1.5B a 7B mejora significativamente la calidad perceptual.
Uso
Configuración
Se necesita un programador de ruido, ya que la generación de audio se basa en un proceso de difusión. El enfoque más sencillo (y el utilizado por los desarrolladores del modelo) es emplear un programador de ruido de la biblioteca diffusers. De forma predeterminada, el modelo creará internamente un programador de ruido con diffusers.
pip install diffusers
pip install soundfile # for saving audioCarga del modelo
from transformers import AutoProcessor, AutoModelForTextToWaveform
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id)Texto a voz (TTS)
import os
from transformers import AutoProcessor, AutoModelForTextToWaveform
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
# Prepare input
conversation = [{"role": "0", "content": [{"type": "text", "text": text}]}]
inputs = processor.apply_chat_template(
conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)
# Generate!
audio = model.generate(**inputs)
# Save to file
file_name = f"{os.path.basename(model_id)}_tts.wav"
processor.save_audio(audio, file_name)
print(f"Saved output to {file_name}")Clonación de voz TTS
Se puede clonar una voz proporcionando un audio de referencia junto con el texto dentro del diccionario de la plantilla de chat.
import os
from transformers import AutoProcessor, AutoModelForTextToWaveform, set_seed
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
set_seed(42) # for deterministic results
# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
sampling_rate = processor.feature_extractor.sampling_rate
# Prepare input
conversation = [
{
"role": "0",
"content": [
{"type": "text", "text": text},
{
"type": "audio",
"url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
}
]
inputs = processor.apply_chat_template(
conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)
# Generate!
audio = model.generate(**inputs)
# Save to file
fn = f"{os.path.basename(model_id)}_tts_clone.wav"
processor.save_audio(audio, fn)
print(f"Saved output to {fn}")Generar un podcast a partir de un guion
A continuación se muestra un ejemplo para generar una conversación entre dos hablantes, cuyas voces se clonan proporcionando un audio de referencia para cada ID de rol único en la plantilla de chat.
El ejemplo anterior también utilizó la opción monitor_progress para seguir el progreso de la generación.
import os
import time
from transformers import AutoProcessor, AutoModelForTextToWaveform
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
max_new_tokens = 400 # `None` to ensure full generation
# create conversation with an audio for the first time a speaker appears to clone that particular voice
conversation = [
{
"role": "0",
"content": [
{
"type": "text", "text": "Hello everyone, and welcome to the VibeVoice podcast. I'm your host, Linda, 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 Thomas here to talk about it with me.",
},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
},
{
"role": "1",
"content": [
{
"type": "text", "text": "Thanks so much for having me, Linda. You're absolutely right—this question always brings out some seriously strong feelings.",
},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
},
],
},
{
"role": "0",
"content": [
{
"type": "text", "text": "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.",
},
],
},
{
"role": "1",
"content": [
{
"type": "text", "text": "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",
},
],
},
]
# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
# prepare inputs
inputs = processor.apply_chat_template(
conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)
# Generate audio with a progress bar to track generation
model.generation_config.max_new_tokens = max_new_tokens
start_time = time.time()
audio = model.generate(**inputs, monitor_progress=True)
generation_time = time.time() - start_time
print(f"Generation time: {generation_time:.2f} seconds")
# Save audio
fn = f"{os.path.basename(model_id)}_script.wav"
processor.save_audio(audio, fn)
print(f"Saved output to {fn}")Inferencia por lotes
Para el procesamiento por lotes, se puede pasar una lista de conversaciones a processor.apply_chat_template:
import os
import time
from transformers import AutoProcessor, AutoModelForTextToWaveform
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
max_new_tokens = 400 # `None` to ensure full generation
conversation = [
[
{
"role": "0",
"content": [
{
"type": "text", "text": "Hello everyone, and welcome to the VibeVoice podcast. I'm your host, Linda, 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 Thomas here to talk about it with me.",
},
{
"type": "audio",
"url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
},
{
"role": "1",
"content": [
{
"type": "text", "text": "Thanks so much for having me, Linda.",
},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
},
],
},
],
[
{
"role": "0",
"content": [
{
"type": "text", "text": "Hello and welcome to Planet in Peril. I'm your host, Alice. We're here today to discuss a really sobering new report that looks back at the last ten years of climate change. I'm joined by our expert panel. Welcome Carter, Frank, and Maya.",
},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
},
{
"role": "1",
"content": [
{"type": "text", "text": "Hi Alice, it's great to be here. I'm Carter."},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Carter_man.wav",
},
],
},
{
"role": "2",
"content": [
{"type": "text", "text": "Hello, uh, I'm Frank. Good to be on."},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
},
],
},
{
"role": "3",
"content": [
{"type": "text", "text": "And I'm Maya. Thanks for having me."},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Maya_woman.wav",
},
],
},
],
]
# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
# prepare inputs
inputs = processor.apply_chat_template(
conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)
# Generate audio with a progress bar to track generation
model.generation_config.max_new_tokens = max_new_tokens
start_time = time.time()
audio = model.generate(**inputs, monitor_progress=True)
generation_time = time.time() - start_time
print(f"Generation time: {generation_time:.2f} seconds")
# Save audio
output_dir = f"{os.path.basename(model_id)}_batch"
processor.save_audio(audio, output_dir)
print(f"Saved output to {output_dir}")Uso de Pipeline
VibeVoice también se puede cargar como un pipeline. A continuación, mostramos cómo se pueden ajustar los parámetros de difusión.
import os
import soundfile as sf
from transformers import pipeline
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
pipe = pipeline("text-to-speech", model=model_id)
# Generate!
conversation = [
{
"role": "0",
"content": [
{"type": "text", "text": text},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
}
]
# optional kwargs for generation
generate_kwargs = {"guidance_scale": 1.3, "num_diffusion_steps": 10}
output = pipe(conversation, generate_kwargs=generate_kwargs)
# Save to file
fn = f"{os.path.basename(model_id)}_pipeline.wav"
sf.write(fn, output["audio"], output["sampling_rate"])
print(f"Saved output to {fn}")Entrenamiento
VibeVoice se puede entrenar con la pérdida emitida por el modelo.
from transformers import AutoProcessor, AutoModelForTextToWaveform
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
# Load model and processor
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(
model_id,
diffusion_loss_weight=0.75, # by default, equal weighting (0.5) of language modeling loss (CE) and diffusion loss is applied
device_map="auto"
)
model.train()
# Prepare batch of 2
conversation = [
[
{
"role": "0",
"content": [
{
"type": "text", "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio.",
},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
},
],
}
],
# NOTE: multiple speakers not supported yet
[
{
"role": "0",
"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",
"url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav",
},
],
}
],
]
# Process with apply_chat_template and output_labels=True for training
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
return_dict=True,
processor_kwargs={"output_labels": True},
).to(model.device, model.dtype)
# Forward pass
outputs = model(**inputs, ddpm_batch_multiplier=2, num_diffusion_steps=2)
print(f"Total loss: {outputs.loss.item():.4f}")
# Backward pass
outputs.loss.backward()Torch compile
El modelo se puede compilar con torch.compile para una inferencia más rápida. Se necesitan algunas ejecuciones de calentamiento antes de que el modelo compilado alcance su velocidad máxima.
En una A100 con un tamaño de lote de 4, observamos una aceleración de aproximadamente 1,5x entre la inferencia compilada y la no compilada, consulte este script.
import os
import time
import torch
from transformers import AutoModelForTextToWaveform, AutoProcessor, CompileConfig
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
num_warmup = 5
max_new_tokens = 128
torch.set_float32_matmul_precision("high")
# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto").eval()
# Prepare inputs
conversation = [
[
{
"role": "0",
"content": [
{"type": "text", "text": "VibeVoice is a novel framework for generating expressive audio."},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
},
],
}
],
] * 4 # batch size 4
inputs = processor.apply_chat_template(
conversation, tokenize=True, return_dict=True, add_generation_prompt=True,
).to(model.device, model.dtype)
compile_config = CompileConfig(mode="default", dynamic=False)
generate_kwargs = dict(
**inputs,
max_new_tokens=max_new_tokens,
cache_implementation="static",
compile_config=compile_config,
)
# Warmup
print("Warming up...")
warmup_start = time.time()
with torch.inference_mode():
for _ in range(num_warmup):
torch.compiler.cudagraph_mark_step_begin()
_ = model.generate(**generate_kwargs)
torch.cuda.synchronize()
print(f"Warmup complete in {time.time() - warmup_start:.2f}s. Ready!")
# Apply model
with torch.inference_mode():
torch.compiler.cudagraph_mark_step_begin()
audio = model.generate(**generate_kwargs)
output_folder = f"{os.path.basename(model_id)}_compiled_output"
processor.save_audio(audio, output_folder)
print(f"Saved output to {output_folder}")VibeVoiceConfig
clase transformers.VibeVoiceConfig
< 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 = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonediffusion_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 151643eos_token_id: int = 151643audio_bos_token_id: int = 151652audio_eos_token_id: int = 151653audio_token_id: int = 151654diffusion_loss_weight: float = 0.5 )
Parámetros
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de audio. - semantic_model_config (
Union[AutoConfig, dict], opcional) — El objeto de configuración o diccionario del codificador 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. - diffusion_head_config (
Union[VibeVoiceDiffusionHeadConfig, dict], opcional) — El objeto de configuración o diccionario de la cabeza de difusión utilizada para sintetizar latentes acústicos. - pad_token_id (
int, opcional, valor predeterminado151643) — Id del token utilizado para el relleno en el vocabulario. - eos_token_id (
int, opcional, valor predeterminado151643) — Identificador de token utilizado para el fin de secuencia en el vocabulario. - audio_bos_token_id (
int, opcional, valor predeterminado 151652) — El ID de token que indica el inicio de los tokens de audio. - audio_eos_token_id (
int, opcional, valor predeterminado 151653) — El ID del token que indica el final de los tokens de audio. - audio_token_id (
int, opcional, valor predeterminado151654) — El índice del token de audio utilizado como marcador de posición para el audio de entrada. - diffusion_loss_weight (
float, opcional, valor predeterminado 0.5) — El peso de la pérdida de difusión en el cálculo de la pérdida total. La pérdida de entropía cruzada para la cabeza de modelado de lenguaje se pondera por(1 - diffusion_loss_weight).
Esta es la clase de configuración para almacenar la configuración de un VibeVoiceForConditionalGeneration. Se utiliza para instanciar un modelo Vibevoice 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 vibevoice/VibeVoice-1.5B-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.
>>> from transformers import VibeVoiceForConditionalGeneration, VibeVoiceConfig
>>> # Initializing a VibeVoice configuration
>>> configuration = VibeVoiceConfig()
>>> # Initializing a 1.5B model with random weights
>>> model = VibeVoiceForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configVibeVoiceDiffusionHeadConfig
clase transformers.VibeVoiceDiffusionHeadConfig
< 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 = Nonehidden_size: int = 1536latent_size: int = 64num_hidden_layers: int = 4intermediate_size: int = 4608rms_norm_eps: float = 1e-05hidden_act: str = 'silu'frequency_embedding_size: int = 256diffusion_max_period: int = 10000mlp_bias: bool = False )
Parámetros
- hidden_size (
int, opcional, valor predeterminado1536) — Dimensión de las representaciones ocultas. - latent_size (
int, opcional, valor predeterminado 64) — Dimensionalidad de los latentes acústicos que la cabeza desruidiza. - num_hidden_layers (
int, opcional, valor predeterminado4) — Número de capas ocultas en el decodificador Transformer. - intermediate_size (
int, opcional, valor predeterminado4608) — Dimensión de las representaciones del MLP. - rms_norm_eps (
float, opcional, valor predeterminado1e-05) — La epsilon utilizada por las capas de normalización rms. - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - frequency_embedding_size (
int, opcional, valor predeterminado 256) — El tamaño de la incrustación sinusoidal de frecuencia para la codificación del paso de tiempo en la cabeza de difusión. - diffusion_max_period (
int, opcional, valor predeterminado 10000) — El período máximo para la incrustación de frecuencia sinusoidal en la cabeza de difusión. - mlp_bias (
bool, opcional, valor predeterminadoFalse) — Si se debe usar un sesgo en las capas up_proj, down_proj y gate_proj de las capas MLP.
Esta es la clase de configuración para almacenar la configuración de un VibeVoiceForConditionalGeneration. Se utiliza para instanciar un modelo Vibevoice 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 vibevoice/VibeVoice-1.5B-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.
VibeVoiceProcessor
clase transformers.VibeVoiceProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_bos_token = '<|vision_start|>'audio_eos_token = '<|vision_end|>'audio_token = '<|vision_pad|>' )
Parámetros
- feature_extractor (
VibeVoiceAcousticTokenizerFeatureExtractor) — El extractor de características es una entrada obligatoria. - tokenizer (
Qwen2TokenizerFast) — El tokenizador es una entrada obligatoria. - chat_template (
str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable. - audio_bos_token (
str, opcional, valor predeterminado"<|vision_start|>") — El token utilizado para indicar el inicio de la generación de audio. - audio_eos_token (
str, opcional, por defecto"<|vision_end|>") — El token utilizado para indicar el final de la generación de audio. - audio_token (
str, opcional, valor predeterminado"<|vision_pad|>") — El token utilizado para indicar que se debe continuar generando audio.
Construye un VibeVoiceProcessor que envuelve un extractor de características y un tokenizador en un único procesador.
VibeVoiceProcessor ofrece todas las funcionalidades de VibeVoiceAcousticTokenizerFeatureExtractor y Qwen2TokenizerFast. Consulte ~VibeVoiceAcousticTokenizerFeatureExtractor y ~Qwen2TokenizerFast para obtener más información.
__call__
< source >( text: str | list[str] | list[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.processing_vibevoice.VibeVoiceProcessorKwargs'> ) → BatchFeature
Parámetros
- text (
str,List[str]) — El texto de entrada a procesar, normalmente preparado con apply_chat_template y marcadores de posición para tokens de audio. - audio (
List[Union[str, np.ndarray]], optional) — Audio samples for speaker voice cloning. Should match the number of audio token placeholders in text. - output_labels (
bool, opcional, default=False) — Si se deben devolver etiquetas para el entrenamiento. - **kwargs — Argumentos de palabra clave adicionales que se pasan al tokenizador y al extractor de características.
- 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 BatchFeature con los siguientes campos:
- input_ids — Lista de ids de tokens que se enviarán al modelo.
- attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando
return_attention_mask=True). - input_values — Lista de valores de audio que se enviarán al modelo. Se devuelve cuando
audiono esNone. - padding_mask — Lista de índices que especifica qué fotogramas de audio deben ser atendidos por el modelo.
Se devuelve cuando
audiono esNone. - labels — Etiquetas para el entrenamiento del modelo de lenguaje. Los tokens de relleno y de difusión de audio se enmascaran con
-100 (los embeddings de los tokens de difusión de audio se reemplazan por las características de audio, por lo que su identidad de token no es un
objetivo significativo). Los tokens bos/eos de audio y los tokens eos de texto se conservan como objetivos para que el LM aprenda cuándo
comenzar y detener la generación de audio. Se devuelve cuando
output_labels=True. - acoustic_loss_mask — Máscara booleana para las posiciones donde se calcula la pérdida de difusión. True en las posiciones de tokens de difusión de audio. Se devuelve cuando
output_labels=True.
VibeVoiceForConditionalGeneration
clase transformers.VibeVoiceForConditionalGeneration
< source >( config: VibeVoiceConfig )
Parámetros
- config (VibeVoiceConfig) — 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, que consta de un modelo de lenguaje, tokenizadores de audio, conectores y una cabeza de difusión.
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: LongTensor = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: int | slice = 0input_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Noneacoustic_loss_mask: typing.Optional[torch.BoolTensor] = Nonenoise_scheduler: object | None = Noneddpm_batch_multiplier: int = 4num_diffusion_steps: int = 10sample: bool = True**kwargs ) → VibeVoiceCausalLMOutputWithPast 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.
- 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. - 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, slice], 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). - input_values (
torch.Tensor, opcional) — Forma de onda de audio preprocesada para clonación de voz. - padding_mask (
torch.BoolTensor, opcional) — Máscaras que indican los cuadros de entrada válidos. - acoustic_loss_mask (
torch.BoolTensor, opcional) — Máscara para calcular la pérdida de difusión solo en tokens acústicos específicos. - noise_scheduler (
object, opcional) — Necesario para el entrenamiento a fin de calcular los objetivos de ruido para la pérdida de difusión. De forma predeterminada, utiliza la configuración del programador de ruido especificada en lageneration_configdel modelo. - ddpm_batch_multiplier (
int, opcional, valor predeterminado 4) — Para el entrenamiento, número de muestras de ruido a generar por token de audio para el cálculo de la pérdida de difusión, lo que puede ayudar a estabilizar el entrenamiento. - num_diffusion_steps (
int, opcional, valor predeterminado 10) — Para el entrenamiento, el número de pasos de difusión a utilizar. Si no se proporciona, el valor predeterminado es 10. - 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
VibeVoiceCausalLMOutputWithPast o tuple(torch.Tensor)
Un VibeVoiceCausalLMOutputWithPast 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 (VibeVoiceConfig) y las entradas.
El método forward de VibeVoiceForConditionalGeneration 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. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradapast_key_values) para acelerar la decodificación secuencial.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.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).audio_features (
torch.Tensorde forma(batch_size, sequence_length, feature_size), opcional) — Características de audio extraídas que pueden usarse para condicionar el modelo de lenguaje.
Ejemplo:
>>> from transformers import AutoProcessor, VibeVoiceForConditionalGeneration
>>> model = VibeVoiceForConditionalGeneration.from_pretrained("vibevoice/VibeVoice-1.5B-hf")
>>> processor = AutoProcessor.from_pretrained("vibevoice/VibeVoice-1.5B-hf")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> # generate speech
>>> speech = model(inputs["input_ids"])generate
< source >( inputs: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonesynced_gpus: bool | None = Noneassistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = Nonestreamer: typing.Optional[ForwardRef('BaseStreamer')] = Nonenegative_prompt_ids: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonecustom_generate: str | collections.abc.Callable | None = None**kwargs ) → ModelOutput or torch.LongTensor
Parámetros
- inputs (
torch.Tensorde forma variable según la modalidad, opcional) — La secuencia utilizada como indicación para la generación o como entrada del modelo para el codificador. Si esNone, el método la inicializa conbos_token_idy un tamaño de lote de 1. Para modelos solo de decodificador,inputsdebe estar en el formato deinput_ids. Para modelos codificador-decodificador, inputs puede representar cualquiera deinput_ids,input_values,input_featuresopixel_values. - generation_config (GenerationConfig, opcional) —
La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los
**kwargspasados a generate que coincidan con los atributos degeneration_configlos sobrescribirán. Si no se proporcionageneration_config, se utilizará el valor predeterminado, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelogeneration_config.json, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de GenerationConfig, cuya documentación debe consultarse para parametrizar la generación. - logits_processor (
LogitsProcessorList, opcional) — Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya fue creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados. - stopping_criteria (
StoppingCriteriaList, opcional) — Criterios de parada personalizados que complementan los criterios de parada predeterminados creados a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya fue creado con los argumentos o una configuración de generación, se lanza un error. Si su criterio de parada depende de la entradascores, asegúrese de pasarreturn_dict_in_generate=True, output_scores=Trueagenerate. Esta función está destinada a usuarios avanzados. - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], list[int]], opcional) — Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lotebatch_idyinput_ids. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación condicionado al ID del lotebatch_idy a los tokens generados previamenteinputs_ids. Este argumento es útil para la generación condicionada al prefijo, tal como se describe en Autoregressive Entity Retrieval. - synced_gpus (
bool, opcional) — Si se debe continuar ejecutando el bucle while hasta max_length. A menos que se sobrescriba, esta bandera se establecerá enTruesi se usaFullyShardedDataParallelo DeepSpeed ZeRO Stage 3 con varias GPUs para evitar bloqueos si una GPU termina de generar antes que las demás. De lo contrario, el valor predeterminado esFalse. - assistant_model (
PreTrainedModel, opcional) — Un modelo asistente que se puede usar para acelerar la generación. El modelo asistente debe tener exactamente el mismo tokenizer. La aceleración se logra cuando la predicción de tokens candidatos con el modelo asistente es mucho más rápida que ejecutar la generación con el modelo desde el que se llama a generate. Por lo tanto, el modelo asistente debe ser mucho más pequeño. - streamer (
BaseStreamer, opcional) — Objeto que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través destreamer.put(token_ids)y el objeto responsable de cualquier procesamiento adicional. - negative_prompt_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El prompt negativo necesario para algunos procesadores, como CFG. El tamaño del lote debe coincidir con el tamaño del lote de entrada. Esta es una función experimental, sujeta a cambios que rompan la API en versiones futuras. - negative_prompt_attention_mask (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Attention_mask paranegative_prompt_ids. - custom_generate (
stroCallable, opcional) — Una de las siguientes opciones:str(nombre del repositorio de Hugging Face Hub): ejecuta la función personalizadageneratedefinida encustom_generate/generate.pyde ese repositorio en lugar del método estándargenerate. El repositorio reemplaza por completo la lógica de generación, y el tipo de retorno puede diferir.str(ruta del repositorio local): igual que lo anterior, pero desde una ruta local. Los directorios locales también requierentrust_remote_code=Trueporque se ejecuta elcustom_generate/generate.pylocal.Callable:generateejecutará los pasos habituales de preparación de la entrada y, a continuación, llamará al callable proporcionado para ejecutar el bucle de decodificación. Para obtener más información, consulte la documentación.
- kwargs (
dict[str, Any], opcional) — Parametrización ad hoc degeneration_configy/o kwargs adicionales específicos del modelo que se reenviarán a la funciónforwarddel modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo decoder_.
Devuelve
ModelOutput o torch.LongTensor
Un ModelOutput (si return_dict_in_generate=True
o cuando config.return_dict_in_generate=True) o un torch.LongTensor.
Si el modelo no es un modelo encoder-decoder (model.config.is_encoder_decoder=False), los tipos
ModelOutput posibles son:
Si el modelo es un modelo encoder-decoder (model.config.is_encoder_decoder=True), los tipos
ModelOutput posibles son:
Genera secuencias de ids de tokens para modelos con una cabeza de modelado de lenguaje.
La mayoría de los parámetros de control de generación se configuran en
generation_config, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquiergeneration_configpasando los parámetros correspondientes a generate(), por ejemplo,.generate(inputs, num_beams=4, do_sample=True).Para obtener una visión general de las estrategias de generación y ejemplos de código, consulte la siguiente guía.
VibeVoiceModel
clase transformers.VibeVoiceModel
< source >( config: VibeVoiceConfig )
Parámetros
- config (VibeVoiceConfig) — 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, que consta de tokenizadores de audio y un backbone de LLM, 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: LongTensor = 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'> ) → BaseModelOutputWithPast 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.
- 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 VibeVoiceProcessor.call() para más detalles. - padding_mask (
torch.Tensorde forma(batch_size, padded_audio_length)) — Máscara de relleno para eliminar las partes rellenas del audio. - 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
BaseModelOutputWithPast o tuple(torch.Tensor)
Un BaseModelOutputWithPast 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 (VibeVoiceConfig) y las entradas.
El método forward de VibeVoiceModel 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. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradapast_key_values) para acelerar la decodificación secuencial.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.
get_audio_features
< source >( input_values: Tensorpadding_mask: Tensorsample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parámetros
- input_values (
torch.Tensor) — Valores flotantes de la forma de onda de audio (normalizada). - padding_mask (
torch.Tensorde forma(batch_size, padded_audio_length)) — Máscara de relleno para eliminar las partes rellenas del audio. - 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
BaseModelOutputWithPooling o tuple(torch.Tensor)
Un BaseModelOutputWithPooling 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 (VibeVoiceConfig) y las entradas.
Este método se utiliza para obtener los embeddings de audio (que reemplazan los tokens de audio de marcador de posición en la secuencia de entrada) y las características acústicas (utilizadas como objetivo de difusión) a partir de la forma de onda de audio de entrada.
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.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.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.
get_placeholder_mask
< source >( input_ids: LongTensorinputs_embeds: Tensoraudio_features: Tensor )
Obtiene la máscara de marcador de posición multimodal a partir de input_ids o inputs_embeds y comprueba que la cantidad de tokens de marcador de posición sea igual a la longitud de las características multimodales. Si las longitudes son diferentes, se genera un error.