Transformers documentation
VibeVoice
Este modelo foi publicado em HF papers em 2025-08-26 e contribuído para Hugging Face Transformers em 2026-08-27.
VibeVoice
Visão geral
VibeVoice é um novo framework para sintetizar fala de alta fidelidade e longa duração com múltiplos falantes, empregando uma abordagem de difusão de próximo token dentro de uma estrutura de Large Language Model (LLM). Ele foi projetado para capturar a “vibe” autêntica de conversas e é particularmente adequado para gerar conteúdo de áudio, como podcasts e audiobooks com múltiplos participantes.
Dois checkpoints de modelo estão disponíveis em:
Este modelo foi contribuído por Eric Bezzam.
Arquitetura

O framework VibeVoice integra três componentes principais:
- Tokenizadores contínuos de fala: Tokenizadores acústicos e semânticos especializados, em que o tokenizador acústico utiliza um $\sigma$-VAE para alcançar compressão ultrabaixa (7,5 tokens/seg, 3200x) visando escalabilidade e fidelidade, e o tokenizador semântico utiliza uma tarefa proxy de ASR para extração de recursos centrada no conteúdo.
- Large Language Model (LLM): Utiliza o Qwen2.5 (nas versões de 1,5B e 7B) como seu modelo de sequência principal.
- Cabeça de Difusão em Nível de Token: condicionada ao estado oculto do LLM e responsável por prever os recursos contínuos do VAE de forma em streaming.
O checkpoint original do VibeVoice-1.5B está disponível sob a organização Microsoft no Hugging Face.
Principais recursos
- Síntese de Longa Duração: Pode sintetizar até 90 minutos de fala conversacional com múltiplos falantes.
- Diálogo com múltiplos falantes: capaz de sintetizar áudio com um máximo de 4 falantes.
- Qualidade de ponta: Supera as linhas de base em métricas subjetivas e objetivas.
- Alta compressão: obtida por meio de um tokenizador acústico inovador que opera em uma taxa de quadros ultrabaixa de 7,5 Hz.
- LLM escalável: Escalar o LLM central de 1,5B para 7B melhora significativamente a qualidade perceptual.
Uso
Configuração
Um agendador de ruído é necessário, pois a geração de áudio depende de um processo de difusão. A abordagem mais simples (e a adotada pelos desenvolvedores do modelo) é usar um agendador de ruído da biblioteca diffusers. Por padrão, o modelo cria internamente um agendador de ruído com diffusers.
pip install diffusers
pip install soundfile # for saving audioCarregando o 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 para fala (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}")Clonagem de voz TTS
Uma voz pode ser clonada fornecendo um áudio de referência junto com o texto no dicionário do modelo 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}")Gerando um podcast a partir de um roteiro
Abaixo, há um exemplo para gerar uma conversa entre dois falantes, cujas vozes são clonadas fornecendo um áudio de referência para cada ID de papel único no modelo de chat.
O exemplo abaixo também utilizou a opção monitor_progress para acompanhar o progresso da geração.
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}")Inferência em lote
Para processamento em lote, uma lista de conversas pode ser passada para 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 do Pipeline
O VibeVoice também pode ser carregado como um pipeline. Também mostramos abaixo como os parâmetros de difusão podem ser ajustados.
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}")Treinamento
O VibeVoice pode ser treinado com a perda emitida pelo 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
O modelo pode ser compilado com torch.compile para uma inferência mais rápida. Algumas execuções de aquecimento são necessárias antes que o modelo compilado atinja a velocidade máxima.
Em uma A100 com tamanho de lote 4, observamos uma aceleração de ~1,5x entre a inferência compilada e a não compilada, veja 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
classe 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) — O objeto de configuração ou dicionário do backbone de áudio. - semantic_model_config (
Union[AutoConfig, dict], opcional) — O objeto de configuração ou dicionário do codificador do tokenizador semântico. Este tokenizador extrai recursos semânticos do áudio. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - diffusion_head_config (
Union[VibeVoiceDiffusionHeadConfig, dict], opcional) — O objeto de configuração ou dicionário da cabeça de difusão usada para sintetizar latentes acústicos. - pad_token_id (
int, opcional, padrão151643) — ID do token usado para preenchimento no vocabulário. - eos_token_id (
int, opcional, padrão151643) — ID do token usado para o fim do fluxo no vocabulário. - audio_bos_token_id (
int, opcional, padrão 151652) — O ID do token que indica o início dos tokens de áudio. - audio_eos_token_id (
int, opcional, padrão 151653) — O ID do token que indica o fim dos tokens de áudio. - audio_token_id (
int, opcional, padrão151654) — O índice do token de áudio usado como marcador de posição para o áudio de entrada. - diffusion_loss_weight (
float, opcional, padrão 0.5) — O peso da perda de difusão no cálculo da perda total. A perda de entropia cruzada para a cabeça de modelagem de linguagem é ponderada por(1 - diffusion_loss_weight).
Esta é a classe de configuração para armazenar a configuração de um VibeVoiceForConditionalGeneration. Ela é usada para instanciar um modelo Vibevoice de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do vibevoice/VibeVoice-1.5B-hf
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
>>> 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
classe 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, padrão1536) — Dimensão das representações ocultas. - latent_size (
int, opcional, padrão 64) — Dimensão dos latentes acústicos que a cabeça dessinaliza. - num_hidden_layers (
int, opcional, padrão4) — Número de camadas ocultas no decodificador do Transformer. - intermediate_size (
int, opcional, padrão4608) — Dimensão das representações do MLP. - rms_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização rms. - hidden_act (
str, opcional, padrãosilu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - frequency_embedding_size (
int, opcional, padrão 256) — O tamanho da incorporação de frequência senoidal para a codificação do passo de tempo na cabeça de difusão. - diffusion_max_period (
int, opcional, padrão 10000) — O período máximo para o incorporamento de frequência senoidal na cabeça de difusão. - mlp_bias (
bool, opcional, padrãoFalse) — Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP.
Esta é a classe de configuração para armazenar a configuração de um VibeVoiceForConditionalGeneration. Ela é usada para instanciar um modelo Vibevoice de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do vibevoice/VibeVoice-1.5B-hf
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
VibeVoiceProcessor
classe 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) — O extrator de recursos é uma entrada obrigatória. - tokenizer (
Qwen2TokenizerFast) — O tokenizer é uma entrada obrigatória. - chat_template (
str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. - audio_bos_token (
str, opcional, padrão"<|vision_start|>") — O token usado para indicar o início da geração de áudio. - audio_eos_token (
str, opcional, padrão"<|vision_end|>") — O token usado para indicar o fim da geração de áudio. - audio_token (
str, opcional, padrão"<|vision_pad|>") — O token usado para indicar a continuação da geração de áudio.
Constrói um VibeVoiceProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.
VibeVoiceProcessor oferece todas as funcionalidades de VibeVoiceAcousticTokenizerFeatureExtractor e Qwen2TokenizerFast. Consulte ~VibeVoiceAcousticTokenizerFeatureExtractor e ~Qwen2TokenizerFast para mais informações.
__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]) — O(s) texto(s) de entrada a serem processados, geralmente preparados por apply_chat_template com placeholders de tokens de áudio. - audio (
List[Union[str, np.ndarray]], opcional) — Amostras de áudio para clonagem de voz do falante. Deve corresponder ao número de tokens de áudio no texto. - output_labels (
bool, opcional, padrão=False) — Se deve retornar rótulos para o treinamento. - **kwargs — Argumentos de palavra-chave adicionais passados para o tokenizer e o extrator de recursos.
- return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo NumPy.
- **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
Retorna
Um BatchFeature com os seguintes campos:
- input_ids — Lista de ids de tokens a serem fornecidos ao modelo.
- attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando
return_attention_mask=True). - input_values — Lista de valores de áudio a serem fornecidos ao modelo. Retornado quando
audionão éNone. - padding_mask — Lista de índices que especifica quais quadros de áudio devem ser considerados pelo modelo.
Retornado quando
audionão éNone. - labels — Rótulos para o treinamento do modelo de linguagem. Os tokens de preenchimento e de difusão de áudio são mascarados com
-100 (as incorporações dos tokens de difusão de áudio são substituídas por recursos de áudio, portanto, a identidade desses tokens não é um
alvo significativo). Os tokens bos/eos de áudio e os tokens eos de texto são mantidos como alvos para que o LM aprenda quando começar
e parar de gerar áudio. Retornado quando
output_labels=True. - acoustic_loss_mask — Máscara booleana para as posições em que a perda de difusão é calculada. Verdadeiro nas posições dos tokens de difusão de áudio. Retornado quando
output_labels=True.
VibeVoiceForConditionalGeneration
classe transformers.VibeVoiceForConditionalGeneration
< source >( config: VibeVoiceConfig )
Parâmetros
- config (VibeVoiceConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo VibeVoice, que consiste em um modelo de linguagem, tokenizadores de áudio, conectores e uma cabeça de difusão.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - logits_to_keep (
Union[int, slice], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (dimensão única para lote e comprimento da sequência). - input_values (
torch.Tensor, opcional) — Forma de onda de áudio pré-processada para clonagem de voz. - padding_mask (
torch.BoolTensor, opcional) — Máscaras que indicam os quadros de entrada válidos. - acoustic_loss_mask (
torch.BoolTensor, opcional) — Máscara para calcular a perda de difusão apenas em tokens acústicos específicos. - noise_scheduler (
object, opcional) — Necessário para o treinamento, a fim de calcular os alvos de ruído para a perda de difusão. Por padrão, utiliza a configuração do agendador de ruído especificada nogeneration_configdo modelo. - ddpm_batch_multiplier (
int, opcional, padrão 4) — Para o treinamento, número de amostras de ruído a serem geradas por token de áudio para o cálculo da perda de difusão, o que pode ajudar a estabilizar o treinamento. - num_diffusion_steps (
int, opcional, padrão 10) — Para o treinamento, o número de etapas de difusão a serem usadas. O padrão é 10, caso não seja fornecido. - sample (
bool, opcional, padrãoTrue) — Indica se deve ser adicionado ruído gaussiano aos latentes acústicos, como no modelo original (σ-VAE: a escala do ruído é extraída por item do lote de N(0,vae_std)). Se False, a saída do codificador é usada como está, tornando a saída determinística.
Retorna
VibeVoiceCausalLMOutputWithPast ou tuple(torch.Tensor)
Uma VibeVoiceCausalLMOutputWithPast ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo vários
elementos dependendo da configuração (VibeVoiceConfig) e das entradas.
O método forward de VibeVoiceForConditionalGeneration substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se
config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradapast_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).audio_features (
torch.Tensorde forma(batch_size, sequence_length, feature_size), opcional) — Recursos de áudio extraídos que podem ser usados para condicionar o modelo de linguagem.
Exemplo:
>>> 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 variável dependendo da modalidade, opcional) — A sequência usada como prompt para a geração ou como entrada do modelo para o codificador. SeNone, o método a inicializa combos_token_ide um tamanho de lote de 1. Para modelos apenas de decodificador,inputsdeve estar no formato deinput_ids. Para modelos codificador-decodificador, inputs pode representar qualquer um deinput_ids,input_values,input_featuresoupixel_values. - generation_config (GenerationConfig, opcional) —
A configuração de geração a ser usada como parametrização base para a chamada de geração. Os
**kwargspassados para generate que correspondam aos atributos degeneration_configos sobrescreverão. Segeneration_confignão for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelogeneration_config.json, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de GenerationConfig, cuja documentação deve ser consultada para parametrizar a geração. - logits_processor (
LogitsProcessorList, opcional) — Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração. Se um processador de logits for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados. - stopping_criteria (
StoppingCriteriaList, opcional) — Critérios de parada personalizados que complementam os critérios de parada padrão criados a partir dos argumentos e de uma configuração de geração. Se um critério de parada for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Se o seu critério de parada depende da entradascores, certifique-se de passarreturn_dict_in_generate=True, output_scores=Trueparagenerate. Este recurso é destinado a usuários avançados. - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], list[int]], opcional) — Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos: o ID do lotebatch_ideinput_ids. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lotebatch_ide aos tokens gerados anteriormenteinputs_ids. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em Autoregressive Entity Retrieval. - synced_gpus (
bool, opcional) — Se deve continuar executando o loop while até max_length. A menos que seja sobrescrito, este sinalizador será definido comoTrueao usarFullyShardedDataParallelou DeepSpeed ZeRO Stage 3 com múltiplas GPUs para evitar deadlock caso uma GPU termine a geração antes das outras. Caso contrário, o valor padrão éFalse. - assistant_model (
PreTrainedModel, opcional) — Um modelo assistente que pode ser usado para acelerar a geração. O modelo assistente deve ter exatamente o mesmo tokenizer. A aceleração é obtida quando a previsão de tokens candidatos com o modelo assistente é muito mais rápida do que executar a geração com o modelo do qual você está chamando generate. Dessa forma, o modelo assistente deve ser muito menor. - streamer (
BaseStreamer, opcional) — Objeto que será usado para transmitir as sequências geradas. Os tokens gerados são passados porstreamer.put(token_ids)e o streamer é responsável por qualquer processamento adicional. - negative_prompt_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — O prompt negativo necessário para alguns processadores, como o CFG. O tamanho do lote deve corresponder ao tamanho do lote de entrada. Esta é uma funcionalidade experimental, sujeita a alterações na API que podem quebrar a compatibilidade em versões futuras. - negative_prompt_attention_mask (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Attention_mask paranegative_prompt_ids. - custom_generate (
strouCallable, opcional) — Um dos seguintes:str(nome do repositório no Hugging Face Hub): executa a função personalizadageneratedefinida emcustom_generate/generate.pynesse repositório, em vez do método padrãogenerate. O repositório substitui completamente a lógica de geração, e o tipo de retorno pode ser diferente.str(caminho do repositório local): o mesmo que acima, mas a partir de um caminho local. Diretórios locais também exigemtrust_remote_code=Trueporque ocustom_generate/generate.pylocal é executado.Callable:generateexecutará as etapas habituais de preparação da entrada e, em seguida, chamará a função fornecida para executar o loop de decodificação. Para mais informações, consulte a documentação.
- kwargs (
dict[str, Any], opcional) — Parametrização ad hoc degeneration_confige/ou kwargs específicos do modelo adicionais que serão encaminhados para a funçãoforwarddo modelo. Se o modelo for um modelo encoder-decoder, os kwargs específicos do encoder não devem ter prefixo e os kwargs específicos do decoder devem ter o prefixo decoder_.
Retorna
ModelOutput ou torch.LongTensor
Um ModelOutput (se return_dict_in_generate=True
ou quando config.return_dict_in_generate=True) ou um torch.LongTensor.
Se o modelo não for um modelo encoder-decoder (model.config.is_encoder_decoder=False), os tipos possíveis de
ModelOutput são:
Se o modelo for um modelo encoder-decoder (model.config.is_encoder_decoder=True), os tipos possíveis de
ModelOutput são:
Gera sequências de ids de tokens para modelos com uma cabeça de modelagem de linguagem.
A maioria dos parâmetros de controle de geração é definida em
generation_config, que, se não for fornecida, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquergeneration_configpassando os parâmetros correspondentes para generate(), por exemplo,.generate(inputs, num_beams=4, do_sample=True).Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.
VibeVoiceModel
classe transformers.VibeVoiceModel
< source >( config: VibeVoiceConfig )
Parâmetros
- config (VibeVoiceConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo VibeVoice, que consiste em tokenizadores de áudio e um backbone de LLM, sem uma cabeça de modelagem de linguagem.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte VibeVoiceProcessor.call() para mais detalhes. - padding_mask (
torch.Tensorde forma(batch_size, padded_audio_length)) — Máscara de preenchimento para remover as partes preenchidas do áudio. - sample (
bool, opcional, padrãoTrue) — Indica se deve ser adicionado ruído gaussiano aos latentes acústicos, como no modelo original (σ-VAE: a escala do ruído é extraída por item do lote de N(0,vae_std)). Se False, a saída do codificador é usada como está, tornando a saída determinística.
Retorna
BaseModelOutputWithPast ou tuple(torch.Tensor)
Um BaseModelOutputWithPast ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (VibeVoiceConfig) e das entradas.
O método forward do VibeVoiceModel substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se
config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradapast_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
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 em ponto flutuante da forma de onda de áudio (normalizada). - padding_mask (
torch.Tensorde forma(batch_size, padded_audio_length)) — Máscara de preenchimento para remover as partes preenchidas do áudio. - sample (
bool, opcional, padrãoTrue) — Indica se deve ser adicionado ruído gaussiano aos latentes acústicos, como no modelo original (σ-VAE: a escala do ruído é extraída por item do lote de N(0,vae_std)). Se False, a saída do codificador é usada como está, tornando a saída determinística.
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (VibeVoiceConfig) e das entradas.
Esse método é usado para obter os embeddings de áudio (que substituem os tokens de áudio placeholder na sequência de entrada) e os recursos acústicos (usados como alvo de difusão) a partir da forma de onda de áudio de entrada.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
get_placeholder_mask
< source >( input_ids: LongTensorinputs_embeds: Tensoraudio_features: Tensor )
Obtém a máscara de placeholder multimodal a partir de input_ids ou inputs_embeds e verifica se a contagem de tokens de placeholder é igual ao comprimento dos recursos multimodais. Se os comprimentos forem diferentes, um erro é lançado.