Transformers documentation

VibeVoice

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em HF papers em 2025-08-26 e contribuído para Hugging Face Transformers em 2026-08-27.

VibeVoice

FlashAttention SDPA

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:

  1. 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.
  2. Large Language Model (LLM): Utiliza o Qwen2.5 (nas versões de 1,5B e 7B) como seu modelo de sequência principal.
  3. 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 audio

Carregando 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

< >

( 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ão 151643) — ID do token usado para preenchimento no vocabulário.
  • eos_token_id (int, opcional, padrão 151643) — 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ão 151654) — 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.config

VibeVoiceDiffusionHeadConfig

classe transformers.VibeVoiceDiffusionHeadConfig

< >

( 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ão 1536) — 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ão 4) — Número de camadas ocultas no decodificador do Transformer.
  • intermediate_size (int, opcional, padrão 4608) — Dimensão das representações do MLP.
  • rms_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização rms.
  • hidden_act (str, opcional, padrão silu) — 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ão False) — 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

< >

( 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__

< >

( 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 (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do 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

BatchFeature

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 audio não é None.
  • padding_mask — Lista de índices que especifica quais quadros de áudio devem ser considerados pelo modelo. Retornado quando audio nã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

< >

( 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

< >

( 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.LongTensor de 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.

    O que são IDs de entrada?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • labels (torch.LongTensor de 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 de input_ids). Tokens com índices definidos como -100 sã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ão 0) — Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_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 um torch.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 no generation_config do 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ão True) — 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 Module em 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.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.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 entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de 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.Tensor de 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

< >

( 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.Tensor de 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. Se None, o método a inicializa com bos_token_id e um tamanho de lote de 1. Para modelos apenas de decodificador, inputs deve estar no formato de input_ids. Para modelos codificador-decodificador, inputs pode representar qualquer um de input_ids, input_values, input_features ou pixel_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 **kwargs passados para generate que correspondam aos atributos de generation_config os sobrescreverão. Se generation_config não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo generation_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 entrada scores, certifique-se de passar return_dict_in_generate=True, output_scores=True para generate. 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 lote batch_id e input_ids. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lote batch_id e aos tokens gerados anteriormente inputs_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 como True ao usar FullyShardedDataParallel ou 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 por streamer.put(token_ids) e o streamer é responsável por qualquer processamento adicional.
  • negative_prompt_ids (torch.LongTensor de 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.LongTensor de forma (batch_size, sequence_length), opcional) — Attention_mask para negative_prompt_ids.
  • custom_generate (str ou Callable, opcional) — Um dos seguintes:
    • str (nome do repositório no Hugging Face Hub): executa a função personalizada generate definida em custom_generate/generate.py nesse repositório, em vez do método padrão generate. 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 exigem trust_remote_code=True porque o custom_generate/generate.py local é executado.
    • Callable: generate executará 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 de generation_config e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função forward do 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 qualquer generation_config passando 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

< >

( 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

< >

( 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.LongTensor de 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.

    O que são IDs de entrada?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • input_values (torch.Tensor de 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 .flac ou .wav em um array do tipo list[float], um numpy.ndarray ou um torch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array para input_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipo torch.Tensor. Consulte VibeVoiceProcessor.call() para mais detalhes.
  • padding_mask (torch.Tensor de forma (batch_size, padded_audio_length)) — Máscara de preenchimento para remover as partes preenchidas do áudio.
  • sample (bool, opcional, padrão True) — 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 Module em 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.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.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 entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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

< >

( 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.Tensor de forma (batch_size, padded_audio_length)) — Máscara de preenchimento para remover as partes preenchidas do áudio.
  • sample (bool, opcional, padrão True) — 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.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • pooler_output (torch.Tensor de 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 quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.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

< >

( 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.

Update on GitHub