# VibeVoice

## Ikhtisar

[VibeVoice](https://huggingface.co/papers/2508.19205) adalah kerangka kerja baru untuk mensintesis ucapan berdurasi panjang dengan fidelitas tinggi yang melibatkan beberapa pembicara, dengan menggunakan pendekatan next-token diffusion di dalam struktur Large Language Model (LLM). Kerangka ini dirancang untuk menangkap “vibe” percakapan yang autentik dan sangat cocok untuk menghasilkan konten audio seperti podcast dan buku audio dengan banyak peserta.

Dua checkpoint model tersedia di:
- [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)
- [vibevoice/VibeVoice-7B-hf](https://huggingface.co/vibevoice/VibeVoice-7B-hf)

Model ini disumbangkan oleh [Eric Bezzam](https://huggingface.co/bezzam).

## Arsitektur

    

Framework VibeVoice mengintegrasikan tiga komponen utama:
1. **Continuous Speech Tokenizers:** [acoustic](./vibevoice_acoustic_tokenizer) dan semantic tokenizer yang khusus, di mana acoustic tokenizer menggunakan $\sigma$-VAE untuk mencapai kompresi ultra-rendah (7,5 token/detik, 3200x) demi skalabilitas dan fidelitas, sedangkan semantic tokenizer menggunakan tugas proxy ASR untuk ekstraksi fitur yang berpusat pada konten.
2. **Large Language Model (LLM):** Menggunakan Qwen2.5 (dalam versi 1.5B dan 7B) sebagai model urutan intinya.
3. **Token-Level Diffusion Head:** dikondisikan pada hidden state LLM dan bertanggung jawab untuk memprediksi fitur VAE kontinu secara streaming.

Checkpoint asli VibeVoice-1.5B tersedia di bawah organisasi [Microsoft](https://huggingface.co/microsoft/VibeVoice-1.5B) di Hugging Face.

## Fitur Utama

- **Sintesis Bentuk Panjang**: Dapat mensintesis percakapan multi-pembicara hingga 90 menit.
- **Dialog Multi-Pembicara**: Mampu mensintesis audio dengan maksimal 4 pembicara.
- **Kualitas Terkini**: Melampaui baseline pada metrik subjektif maupun objektif.
- **Kompresi Tinggi**: Dicapai melalui tokenizer akustik baru yang beroperasi pada laju bingkai ultra-rendah 7,5 Hz.
- **LLM yang dapat diskalakan**: Penskalaan LLM inti dari 1,5 miliar menjadi 7 miliar secara signifikan meningkatkan kualitas perseptual.

## Penggunaan

### Pengaturan 

Noise scheduler diperlukan karena generasi audio bergantung pada proses difusi. Pendekatan termudah (dan yang dilakukan oleh pengembang model) adalah menggunakan noise scheduler dari pustaka `diffusers`. Secara default, model akan membuat noise scheduler dengan `diffusers` secara internal.
```
pip install diffusers
pip install soundfile   # for saving audio
```

### Memuat model

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

### Teks-ke-suara (TTS)

```python
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}")
```

### Kloning suara TTS

Suara dapat dikloning dengan menyediakan audio referensi bersama teks di dalam kamus template chat.

```python
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}")
```

### Membuat podcast dari naskah

Di bawah ini adalah contoh untuk menghasilkan percakapan antara dua pembicara, di mana suara mereka dikloning dengan menyediakan audio referensi untuk setiap ID peran unik dalam template chat.

Contoh di bawah ini juga menggunakan opsi `monitor_progress` untuk melacak kemajuan generasi.

```python
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}")
```

### Inferensi berbatch

Untuk pemrosesan batch, daftar percakapan dapat diteruskan ke `processor.apply_chat_template`:

```python
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}")
```

### Penggunaan Pipeline

VibeVoice juga dapat dimuat sebagai pipeline. Di bawah ini juga ditunjukkan bagaimana parameter difusi dapat disesuaikan.

```python
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}")
```

### Pelatihan

VibeVoice dapat dilatih dengan loss yang dioutputkan oleh model.

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

Model dapat dikompilasi dengan `torch.compile` untuk inferensi yang lebih cepat. Beberapa eksekusi pemanasan diperlukan sebelum model terkompilasi mencapai kecepatan penuh.

Pada A100 dengan ukuran batch 4, kami mengamati percepatan sekitar 1,5x antara inferensi yang dikompilasi dan yang tidak dikompilasi, lihat [skrip ini](https://gist.github.com/ebezzam/c45b9fdee65f3029e17d566e30c59399).

```python
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[[transformers.VibeVoiceConfig]]

#### transformers.VibeVoiceConfig[[transformers.VibeVoiceConfig]]

```python
transformers.VibeVoiceConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, diffusion_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 151643, eos_token_id: int = 151643, audio_bos_token_id: int = 151652, audio_eos_token_id: int = 151653, audio_token_id: int = 151654, diffusion_loss_weight: float = 0.5)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/configuration_vibevoice.py#L49)

**Parameter:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari audio backbone.

semantic_model_config (`Union[AutoConfig, dict]`, *opsional*) : Objek config atau dictionary dari encoder semantic tokenizer. Tokenizer ini mengekstrak fitur semantik dari audio.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari text backbone.

diffusion_head_config (`Union[VibeVoiceDiffusionHeadConfig, dict]`, *opsional*) : Objek konfigurasi atau kamus dari kepala difusi yang digunakan untuk mensintesis laten akustik.

pad_token_id (`int`, *opsional*, defaultnya `151643`) : Token id yang digunakan untuk padding dalam kosakata.

eos_token_id (`int`, *opsional*, defaultnya `151643`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

audio_bos_token_id (`int`, *opsional*, default 151652) : ID token yang menandakan awal token audio.

audio_eos_token_id (`int`, *opsional*, default 151653) : ID token yang menandakan akhir token audio.

audio_token_id (`int`, *opsional*, defaultnya `151654`) : Indeks token audio yang digunakan sebagai placeholder untuk audio input.

diffusion_loss_weight (`float`, *opsional*, default 0.5) : Bobot dari loss difusi dalam perhitungan loss keseluruhan. Loss cross entropy untuk kepala pemodelan bahasa diberi bobot `(1 - diffusion_loss_weight)`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VibeVoiceForConditionalGeneration. Kelas ini digunakan untuk membuat instans model Vibevoice berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

```python
>>> 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[[transformers.VibeVoiceDiffusionHeadConfig]]

#### transformers.VibeVoiceDiffusionHeadConfig[[transformers.VibeVoiceDiffusionHeadConfig]]

```python
transformers.VibeVoiceDiffusionHeadConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1536, latent_size: int = 64, num_hidden_layers: int = 4, intermediate_size: int = 4608, rms_norm_eps: float = 1e-05, hidden_act: str = 'silu', frequency_embedding_size: int = 256, diffusion_max_period: int = 10000, mlp_bias: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/configuration_vibevoice.py#L24)

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `1536`) : Dimensi dari representasi tersembunyi.

latent_size (`int`, *opsional*, default 64) : Dimensi dari latens akustik yang dinoised oleh head.

num_hidden_layers (`int`, *opsional*, defaultnya `4`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

intermediate_size (`int`, *opsional*, defaultnya `4608`) : Dimensi dari representasi MLP.

rms_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : epsilon yang digunakan oleh lapisan normalisasi rms.

hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

frequency_embedding_size (`int`, *opsional*, defaultnya 256) : Ukuran embedding frekuensi sinusoidal untuk encoding timestep di kepala difusi.

diffusion_max_period (`int`, *opsional*, default 10000) : Periode maksimum untuk penanam frekuensi sinusoidal di kepala difusi.

mlp_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di lapisan MLP.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VibeVoiceForConditionalGeneration. Kelas ini digunakan untuk membuat instans model Vibevoice berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## VibeVoiceProcessor[[transformers.VibeVoiceProcessor]]

#### transformers.VibeVoiceProcessor[[transformers.VibeVoiceProcessor]]

```python
transformers.VibeVoiceProcessor(feature_extractor, tokenizer, chat_template = None, audio_bos_token = '<|vision_start|>', audio_eos_token = '<|vision_end|>', audio_token = '<|vision_pad|>')
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/processing_vibevoice.py#L38)

**Parameter:**

feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : Feature extractor adalah input yang wajib.

tokenizer (`Qwen2TokenizerFast`) : Tokenizer adalah input yang wajib.

chat_template (`str`) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

audio_bos_token (`str`, *opsional*, defaultnya `"<|vision_start|>"`) : Token yang digunakan untuk menunjukkan awal dari generasi audio.

audio_eos_token (`str`, *opsional*, defaultnya `"<|vision_end|>"`) : Token yang digunakan untuk menunjukkan akhir dari generasi audio.

audio_token (`str`, *opsional*, defaultnya `"<|vision_pad|>"`) : Token yang digunakan untuk menunjukkan agar melanjutkan generasi audio.

Membangun VibeVoiceProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[VibeVoiceProcessor](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceProcessor) menyediakan semua fungsionalitas dari [VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) dan [Qwen2TokenizerFast](/docs/transformers/v5.23.0/id/model_doc/qwen2#transformers.Qwen2Tokenizer). Lihat [~VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) dan [~Qwen2TokenizerFast](/docs/transformers/v5.23.0/id/model_doc/qwen2#transformers.Qwen2Tokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.VibeVoiceProcessor.__call__]]

```python
__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] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/processing_vibevoice.py#L92)

**Parameter:**

text (`str`, `List[str]`) : Teks masukan yang akan diproses, biasanya disiapkan oleh apply_chat_template dengan placeholder token audio.

audio (`List[Union[str, np.ndarray]]`, *opsional*) : Sampel audio untuk kloning suara pembicara. Harus sesuai dengan jumlah placeholder token audio dalam teks.

output_labels (`bool`, *opsional*, default=False) : Apakah akan mengembalikan label untuk pelatihan.

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke tokenizer dan feature extractor.

return_mm_token_type_ids (`bool`, *kwargs*) : Apakah akan mengembalikan id tipe token multimodal yang menunjukkan posisi token placeholder multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Apakah akan mengembalikan offset karakter untuk setiap placeholder multimodal dan pengantinya.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** [BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature)

[BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature) dengan bidang berikut:
- **input_ids** -- Daftar id token yang akan diberikan ke model.
- **attention_mask** -- Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika `return_attention_mask=True`).
- **input_values** -- Daftar nilai audio yang akan diberikan ke model. Dikembalikan ketika `audio` bukan `None`.
- **padding_mask** -- Daftar indeks yang menentukan frame audio mana yang harus diperhatikan oleh model. Dikembalikan ketika `audio` bukan `None`.
- **labels** -- Label untuk pelatihan model bahasa. Token padding dan token difusi audio dimasker dengan -100 (embedding token difusi audio diganti oleh fitur audio, sehingga identitas tokennya bukan target yang bermakna). Token bos/eos audio dan token eos teks dipertahankan sebagai target agar LM belajar kapan harus memulai dan menghentikan generasi audio. Dikembalikan ketika `output_labels=True`.
- **acoustic_loss_mask** -- Mask Boolean untuk posisi di mana loss difusi dihitung. True pada posisi token difusi audio. Dikembalikan ketika `output_labels=True`.

## VibeVoiceForConditionalGeneration[[transformers.VibeVoiceForConditionalGeneration]]

#### transformers.VibeVoiceForConditionalGeneration[[transformers.VibeVoiceForConditionalGeneration]]

```python
transformers.VibeVoiceForConditionalGeneration(config: VibeVoiceConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L367)

**Parameter:**

config ([VibeVoiceConfig](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model VibeVoice, yang terdiri dari model bahasa, tokenizer audio, konektor, dan kepala difusi.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.VibeVoiceForConditionalGeneration.forward]]

```python
forward(input_ids: LongTensor = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: int | slice = 0, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, acoustic_loss_mask: typing.Optional[torch.BoolTensor] = None, noise_scheduler: object | None = None, ddpm_batch_multiplier: int = 4, num_diffusion_steps: int = 10, sample: bool = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L422)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada di `[0, ..., config.vocab_size]` atau -100 (lihat docstring `input_ids`). Token dengan indeks yang disetel ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label di `[0, ..., config.vocab_size]`.

logits_to_keep (`Union[int, slice]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_ids` (kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupa `torch.Tensor`, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan).

input_values (`torch.Tensor`, *opsional*) : Gelombang audio yang telah diproses untuk kloning suara.

padding_mask (`torch.BoolTensor`, *opsional*) : Mask yang menunjukkan frame input yang valid.

acoustic_loss_mask (`torch.BoolTensor`, *opsional*) : Mask untuk menghitung loss difusi hanya pada token akustik tertentu.

noise_scheduler (`object`, *opsional*) : Diperlukan untuk pelatihan guna menghitung target noise untuk loss difusi. Secara default, menggunakan konfigurasi noise scheduler yang ditentukan dalam `generation_config` model.

ddpm_batch_multiplier (`int`, *opsional*, default 4) : Untuk pelatihan, jumlah sampel noise yang akan dihasilkan per token audio untuk perhitungan loss difusi, yang dapat membantu menstabilkan pelatihan.

num_diffusion_steps (`int`, *opsional*, default 10) : Untuk pelatihan, jumlah langkah difusi yang digunakan. Defaultnya 10 jika tidak diberikan.

sample (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model asli (σ-VAE: skala noise diambil per item batch dari N(0, `vae_std`)). Jika False, output encoder digunakan apa adanya, sehingga output bersifat deterministik.

**Mengembalikan:** `VibeVoiceCausalLMOutputWithPast` atau `tuple(torch.Tensor)`

Sebuah `VibeVoiceCausalLMOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([VibeVoiceConfig](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceConfig)) dan input.

Metode forward dari [VibeVoiceForConditionalGeneration](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceForConditionalGeneration) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **audio_features** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_size)`, *opsional*) -- Fitur audio yang diekstrak dan dapat digunakan untuk mengondisikan model bahasa.

Contoh:

```python
>>> 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[[transformers.VibeVoiceForConditionalGeneration.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | collections.abc.Callable | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L2581)

**Parameter:**

inputs (`torch.Tensor` dengan bentuk yang bervariasi tergantung pada modalitas, *opsional*) : Urutan yang digunakan sebagai prompt untuk generasi atau sebagai input model ke encoder. Jika `None`, metode ini menginisialisasinya dengan `bos_token_id` dan ukuran batch 1. Untuk model decoder-only, `inputs` harus dalam format `input_ids`. Untuk model encoder-decoder, *inputs* dapat mewakili salah satu dari `input_ids`, `input_values`, `input_features`, atau `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationConfig), *opsional*) : Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi. `**kwargs` yang diteruskan ke generate dan cocok dengan atribut dari `generation_config` akan menimpanya. Jika `generation_config` tidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file model `generation_config.json`, jika ada; 2) dari konfigurasi model. Harap diperhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari [GenerationConfig](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationConfig), dan dokumentasinya harus diperiksa untuk memparametrisasi generasi.

logits_processor (`LogitsProcessorList`, *opsional*) : Prosesor logits kustom yang melengkapi prosesor logits bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika prosesor logits yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Fitur ini ditujukan untuk pengguna tingkat lanjut.

stopping_criteria (`StoppingCriteriaList`, *opsional*) : Kriteria penghentian kustom yang melengkapi kriteria penghentian bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika kriteria penghentian yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Jika kriteria penghentian Anda bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`. Fitur ini ditujukan untuk pengguna tingkat lanjut.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opsional*) : Jika disediakan, fungsi ini membatasi beam search hanya pada token yang diizinkan di setiap langkah. Jika tidak disediakan, tidak ada batasan yang diterapkan. Fungsi ini mengambil 2 argumen: ID batch `batch_id` dan `input_ids`. Fungsi ini harus mengembalikan daftar token yang diizinkan untuk langkah generasi berikutnya yang dikondisikan pada ID batch `batch_id` dan token yang sebelumnya dihasilkan `inputs_ids`. Argumen ini berguna untuk generasi yang dibatasi berdasarkan prefiks, seperti yang dijelaskan dalam [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opsional*) : Apakah akan terus menjalankan loop while hingga max_length. Kecuali ditimpa, flag ini akan disetel ke `True` jika menggunakan `FullyShardedDataParallel` atau DeepSpeed ZeRO Stage 3 dengan beberapa GPU untuk menghindari deadlocking jika satu GPU selesai menghasilkan sebelum GPU lainnya. Jika tidak, defaultnya adalah `False`.

assistant_model (`PreTrainedModel`, *opsional*) : Model asisten yang dapat digunakan untuk mempercepat generasi. Model asisten harus memiliki tokenizer yang persis sama. Percepatan tercapai ketika memprediksi token kandidat dengan model asisten jauh lebih cepat daripada menjalankan generasi dengan model yang Anda panggil generate dari. Oleh karena itu, model asisten harus jauh lebih kecil.

streamer (`BaseStreamer`, *opsional*) : Objek Streamer yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melalui `streamer.put(token_ids)` dan streamer bertanggung jawab untuk pemrosesan lebih lanjut.

negative_prompt_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Prompt negatif yang diperlukan untuk beberapa prosesor seperti CFG. Ukuran batch harus sesuai dengan ukuran batch input. Ini adalah fitur eksperimental, yang dapat mengalami perubahan API yang merusak (breaking changes) di versi mendatang.

negative_prompt_attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Attention_mask untuk `negative_prompt_ids`.

custom_generate (`str` atau `Callable`, *opsional*) : Salah satu dari berikut: - `str` (nama repositori Hugging Face Hub): menjalankan fungsi `generate` kustom yang didefinisikan di `custom_generate/generate.py` pada repositori tersebut, bukan metode `generate` standar. Repositori ini sepenuhnya menggantikan logika generasi, dan tipe pengembalian dapat berbeda. - `str` (jalur repositori lokal): sama seperti di atas tetapi dari jalur lokal. Direktori lokal juga memerlukan `trust_remote_code=True` karena `custom_generate/generate.py` lokal akan dieksekusi. - `Callable`: `generate` akan melakukan langkah-langkah persiapan input yang biasa, lalu memanggil callable yang diberikan untuk menjalankan loop decoding. Untuk informasi lebih lanjut, lihat [dokumentasinya](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk `generation_config` dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. Jika model adalah model encoder-decoder, kwargs spesifik encoder tidak boleh diberi awalan dan kwargs spesifik decoder harus diberi awalan *decoder_*.

**Mengembalikan:** [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) atau `torch.LongTensor`

[ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) (jika `return_dict_in_generate=True` atau ketika `config.return_dict_in_generate=True`) atau `torch.LongTensor`.

Jika model *bukan* model encoder-decoder (`model.config.is_encoder_decoder=False`), tipe [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

- [GenerateDecoderOnlyOutput](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput),
- [GenerateBeamDecoderOnlyOutput](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.generation.GenerateBeamDecoderOnlyOutput)

Jika model adalah model encoder-decoder (`model.config.is_encoder_decoder=True`), tipe [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Membuat rangkaian id token untuk model dengan kepala pemodelan bahasa.

Sebagian besar parameter pengendali generasi diatur di `generation_config` yang, jika tidak diteruskan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpa `generation_config` mana pun dengan meneruskan parameter yang sesuai ke generate(), misalnya `.generate(inputs, num_beams=4, do_sample=True)`.

Untuk ringkasan strategi generasi dan contoh kode, lihat [panduan berikut](../generation_strategies).

## VibeVoiceModel[[transformers.VibeVoiceModel]]

#### transformers.VibeVoiceModel[[transformers.VibeVoiceModel]]

```python
transformers.VibeVoiceModel(config: VibeVoiceConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L241)

**Parameter:**

config ([VibeVoiceConfig](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model VibeVoice yang terdiri dari tokenizer audio dan backbone LLM, tanpa kepala pemodelan bahasa.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.VibeVoiceModel.forward]]

```python
forward(input_ids: LongTensor = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L324)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah input. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [VibeVoiceProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceProcessor.__call__) untuk detailnya.

padding_mask (`torch.Tensor` dengan bentuk `(batch_size, padded_audio_length)`) : Padding mask untuk menghapus bagian audio yang di-pad.

sample (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model asli (σ-VAE: skala noise diambil per item batch dari N(0, `vae_std`)). Jika False, output encoder digunakan apa adanya, sehingga output bersifat deterministik.

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([VibeVoiceConfig](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceConfig)) dan input.

Metode forward dari [VibeVoiceModel](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

#### get_audio_features[[transformers.VibeVoiceModel.get_audio_features]]

```python
get_audio_features(input_values: Tensor, padding_mask: Tensor, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L258)

**Parameter:**

input_values (`torch.Tensor`) : Nilai Float dari waveform audio (ternormalisasi).

padding_mask (`torch.Tensor` dengan bentuk `(batch_size, padded_audio_length)`) : Padding mask untuk menghapus bagian audio yang di-pad.

sample (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model asli (σ-VAE: skala noise diambil per item batch dari N(0, `vae_std`)). Jika False, output encoder digunakan apa adanya, sehingga output bersifat deterministik.

**Mengembalikan:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([VibeVoiceConfig](/docs/transformers/v5.23.0/id/model_doc/vibevoice#transformers.VibeVoiceConfig)) dan input.

Metode ini digunakan untuk mendapatkan embedding audio (yang menggantikan token audio placeholder dalam urutan input) dan fitur akustik (yang digunakan sebagai target difusi) dari waveform audio input.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

#### get_placeholder_mask[[transformers.VibeVoiceModel.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, audio_features: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vibevoice/modeling_vibevoice.py#L300)

Mengambil mask placeholder multimodal dari `input_ids` atau `inputs_embeds`, dan memeriksa bahwa jumlah token placeholder sama dengan panjang fitur multimodal. Jika panjangnya berbeda, error akan dilempar.

