Transformers documentation
VibeVoice
Model ini dipublikasikan di HF papers pada 2025-08-26 dan disumbangkan ke Hugging Face Transformers pada 2026-08-27.
VibeVoice
Ikhtisar
VibeVoice 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 kerja 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:
Model ini disumbangkan oleh Eric Bezzam.
Arsitektur

Framework VibeVoice mengintegrasikan tiga komponen utama:
- Continuous Speech Tokenizers: acoustic 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.
- Large Language Model (LLM): Menggunakan Qwen2.5 (dalam versi 1.5B dan 7B) sebagai model urutan intinya.
- 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 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 audioMemuat model
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)
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.
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.
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:
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.
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.
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.
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
kelas transformers.VibeVoiceConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonediffusion_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 151643eos_token_id: int = 151643audio_bos_token_id: int = 151652audio_eos_token_id: int = 151653audio_token_id: int = 151654diffusion_loss_weight: float = 0.5 )
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 config atau dictionary dari diffusion head yang digunakan untuk mensintesis acoustic latents. - pad_token_id (
int, opsional, default151643) — ID token yang digunakan untuk padding dalam kosakata. - eos_token_id (
int, opsional, default151643) — ID token yang digunakan untuk end-of-stream dalam kosakata. - audio_bos_token_id (
int, opsional, default 151652) — ID token yang menandakan awal dari token audio. - audio_eos_token_id (
int, opsional, default 151653) — ID token yang menandakan akhir dari token audio. - audio_token_id (
int, opsional, default151654) — Indeks token audio yang digunakan sebagai placeholder untuk audio input. - diffusion_loss_weight (
float, opsional, default 0.5) — Bobot dari diffusion loss dalam perhitungan loss keseluruhan. Cross entropy loss untuk language modeling head 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, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai default akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari vibevoice/VibeVoice-1.5B-hf
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
>>> from transformers import VibeVoiceForConditionalGeneration, VibeVoiceConfig
>>> # Initializing a VibeVoice configuration
>>> configuration = VibeVoiceConfig()
>>> # Initializing a 1.5B model with random weights
>>> model = VibeVoiceForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configVibeVoiceDiffusionHeadConfig
kelas transformers.VibeVoiceDiffusionHeadConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1536latent_size: int = 64num_hidden_layers: int = 4intermediate_size: int = 4608rms_norm_eps: float = 1e-05hidden_act: str = 'silu'frequency_embedding_size: int = 256diffusion_max_period: int = 10000mlp_bias: bool = False )
Parameter
- hidden_size (
int, opsional, default1536) — Dimensi dari representasi tersembunyi. - latent_size (
int, opsional, default 64) — Dimensi dari latens akustik yang dinois oleh head. - num_hidden_layers (
int, opsional, default4) — Jumlah lapisan tersembunyi dalam decoder Transformer. - intermediate_size (
int, opsional, default4608) — Dimensi representasi MLP. - rms_norm_eps (
float, opsional, defaultnya1e-05) — Epsilon yang digunakan oleh lapisan normalisasi rms. - hidden_act (
str, opsional, defaultnyasilu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - frequency_embedding_size (
int, opsional, default 256) — Ukuran sinusoidal frequency embedding untuk encoding timestep di diffusion head. - diffusion_max_period (
int, opsional, default 10000) — Periode maksimum untuk embedding frekuensi sinusoidal di kepala difusi. - mlp_bias (
bool, opsional, defaultFalse) — Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di dalam lapisan MLP.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VibeVoiceForConditionalGeneration. Kelas ini digunakan untuk membuat instans model Vibevoice berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai default akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari vibevoice/VibeVoice-1.5B-hf
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
VibeVoiceProcessor
kelas transformers.VibeVoiceProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_bos_token = '<|vision_start|>'audio_eos_token = '<|vision_end|>'audio_token = '<|vision_pad|>' )
Parameter
- feature_extractor (
VibeVoiceAcousticTokenizerFeatureExtractor) — Feature extractor adalah input yang wajib. - tokenizer (
Qwen2TokenizerFast) — Tokenizer adalah input yang wajib. - chat_template (
str) — Template Jinja untuk mengubah daftar pesan dalam chat menjadi string yang dapat ditokenisasi. - audio_bos_token (
str, opsional, default"<|vision_start|>") — Token yang digunakan untuk menandai awal dari generasi audio. - audio_eos_token (
str, opsional, default"<|vision_end|>") — Token yang digunakan untuk menandai akhir dari generasi audio. - audio_token (
str, opsional, default"<|vision_pad|>") — Token yang digunakan untuk menunjukkan agar proses generasi audio dilanjutkan.
Membangun VibeVoiceProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.
VibeVoiceProcessor menyediakan semua fungsionalitas dari VibeVoiceAcousticTokenizerFeatureExtractor dan Qwen2TokenizerFast. Lihat ~VibeVoiceAcousticTokenizerFeatureExtractor dan ~Qwen2TokenizerFast untuk informasi lebih lanjut.
__call__
< source >( text: str | list[str] | list[list[str]]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.vibevoice.processing_vibevoice.VibeVoiceProcessorKwargs'> ) → BatchFeature
Parameter
- text (
str,List[str]) — Teks input yang akan diproses, biasanya disiapkan dengan apply_chat_template menggunakan placeholder token audio. - audio (
List[Union[str, np.ndarray]], optional) — Audio samples for speaker voice cloning. Should match the number of audio token placeholders in text. - output_labels (
bool, opsional, default=False) — Apakah akan mengembalikan label untuk pelatihan. - **kwargs — Argumen kata kunci tambahan yang diteruskan ke tokenizer dan feature extractor.
- return_tensors (
stratau TensorType, opsional) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:'pt': Mengembalikan objek PyTorchtorch.Tensor.'np': Mengembalikan objek NumPynp.ndarray.
- **kwargs (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 dengan bidang berikut:
- input_ids — Daftar token id 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
audiobukanNone. - padding_mask — Daftar indeks yang menentukan frame audio mana yang harus diperhatikan oleh model.
Dikembalikan ketika
audiobukanNone. - 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-posisi di mana loss difusi dihitung. True pada posisi token difusi audio. Dikembalikan ketika
output_labels=True.
VibeVoiceForConditionalGeneration
kelas transformers.VibeVoiceForConditionalGeneration
< source >( config: VibeVoiceConfig )
Parameter
- config (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() untuk memuat bobot model.
Model VibeVoice, yang terdiri dari model bahasa, tokenizer audio, konektor, dan kepala difusi.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari 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
< source >( input_ids: LongTensor = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: int | slice = 0input_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Noneacoustic_loss_mask: typing.Optional[torch.BoolTensor] = Nonenoise_scheduler: object | None = Noneddpm_batch_multiplier: int = 4num_diffusion_steps: int = 10sample: bool = True**kwargs ) → VibeVoiceCausalLMOutputWithPast or tuple(torch.Tensor)
Parameter
- input_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
- inputs_embeds (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskaninput_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeksinput_idsmenjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model. - labels (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling). Indeks harus berada dalam[0, ..., config.vocab_size]atau -100 (lihat docstringinput_ids). Token dengan indeks yang disetel ke-100diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam[0, ..., config.vocab_size]. - logits_to_keep (
Union[int, slice], opsional, default0) — Jika berupaint, hitung logits untuklogits_to_keeptoken terakhir. Jika0, hitung logits untuk semuainput_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 berupatorch.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 diffusion loss 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 dalamgeneration_configmodel. - ddpm_batch_multiplier (
int, opsional, default 4) — Untuk pelatihan, jumlah sampel noise yang 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 akan digunakan. Defaultnya 10 jika tidak diberikan. - sample (
bool, opsional, defaultTrue) — Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model aslinya (σ-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) dan input.
Metode forward dari VibeVoiceForConditionalGeneration menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.Tensordengan bentuk(batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.Jika
past_key_valuesdigunakan, hanya hidden-state terakhir dari sekuens dengan bentuk(batch_size, 1, hidden_size)yang dioutput.past_key_values (
Cache, opsional, dikembalikan saatuse_cache=Truedilewatkan atau saatconfig.use_cache=True) — Ini adalah instance Cache. Untuk detail lebih lanjut, lihat panduan 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=Truedi blok cross-attention) yang dapat digunakan (lihat inputpast_key_values) untuk mempercepat decoding berurutan.hidden_states (
tuple(torch.Tensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.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 saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.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 perhatian diri (self-attention).
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss pemodelan bahasa (untuk prediksi token berikutnya).logits (
torch.Tensordengan bentuk(batch_size, sequence_length, config.vocab_size)) — Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).audio_features (
torch.Tensordengan bentuk(batch_size, sequence_length, feature_size), opsional) — Fitur audio yang diekstrak dan dapat digunakan untuk mengondisikan model bahasa.
Contoh:
>>> from transformers import AutoProcessor, VibeVoiceForConditionalGeneration
>>> model = VibeVoiceForConditionalGeneration.from_pretrained("vibevoice/VibeVoice-1.5B-hf")
>>> processor = AutoProcessor.from_pretrained("vibevoice/VibeVoice-1.5B-hf")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> # generate speech
>>> speech = model(inputs["input_ids"])generate
< source >( inputs: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonesynced_gpus: bool | None = Noneassistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = Nonestreamer: typing.Optional[ForwardRef('BaseStreamer')] = Nonenegative_prompt_ids: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonecustom_generate: str | collections.abc.Callable | None = None**kwargs ) → ModelOutput or torch.LongTensor
Parameter
- inputs (
torch.Tensordengan bentuk yang bervariasi tergantung pada modalitas, opsional) — Urutan yang digunakan sebagai prompt untuk generasi atau sebagai input model ke encoder. JikaNone, metode ini menginisialisasinya denganbos_token_iddan ukuran batch 1. Untuk model decoder-only,inputsharus dalam formatinput_ids. Untuk model encoder-decoder, inputs dapat mewakili salah satu dariinput_ids,input_values,input_features, ataupixel_values. - generation_config (GenerationConfig, opsional) —
Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi.
**kwargsyang diteruskan ke generate dan cocok dengan atribut darigeneration_configakan menimpanya. Jikageneration_configtidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file modelgeneration_config.json, jika ada; 2) dari konfigurasi model. Perhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari GenerationConfig, yang dokumentasinya harus diperiksa untuk memparametrisasi generasi. - logits_processor (
LogitsProcessorList, opsional) — Prosesor logits kustom yang melengkapi prosesornya logits default yang dibangun dari argumen dan konfigurasi generasi. Jika prosesornya logits yang sudah dibuat dengan argumen atau konfigurasi generasi dilewatkan, sebuah error akan dilempar. Fitur ini ditujukan untuk pengguna tingkat lanjut. - stopping_criteria (
StoppingCriteriaList, opsional) — Kriteria penghentian kustom yang melengkapi kriteria penghentian default yang dibangun dari argumen dan konfigurasi generasi. Jika kriteria penghentian yang di-pass sudah dibuat dengan argumen atau konfigurasi generasi, sebuah error akan dilempar. Jika kriteria penghentian Anda bergantung pada inputscores, pastikan Anda meng-passreturn_dict_in_generate=True, output_scores=Truekegenerate. Fitur ini ditujukan untuk pengguna tingkat lanjut. - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], list[int]], opsional) — Jika disediakan, fungsi ini membatasi pencarian beam hanya pada token yang diizinkan di setiap langkah. Jika tidak disediakan, tidak ada batasan yang diterapkan. Fungsi ini mengambil 2 argumen: ID batchbatch_iddaninput_ids. Fungsi ini harus mengembalikan daftar token yang diizinkan untuk langkah generasi berikutnya yang dikondisikan pada ID batchbatch_iddan token yang sebelumnya dihasilkaninputs_ids. Argumen ini berguna untuk generasi yang dibatasi berdasarkan prefiks, seperti yang dijelaskan dalam Autoregressive Entity Retrieval. - synced_gpus (
bool, opsional) — Apakah akan terus menjalankan loop while hingga max_length. Kecuali di-override, flag ini akan diset keTruejika menggunakanFullyShardedDataParallelatau DeepSpeed ZeRO Stage 3 dengan beberapa GPU untuk menghindari deadlock jika satu GPU selesai menghasilkan sebelum GPU lainnya. Jika tidak, defaultnya adalahFalse. - 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 yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melaluistreamer.put(token_ids)dan objek tersebut bertanggung jawab untuk pemrosesan lebih lanjut. - negative_prompt_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Prompt negatif yang diperlukan oleh 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) pada versi mendatang. - negative_prompt_attention_mask (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Attention_mask untuknegative_prompt_ids. - custom_generate (
stratauCallable, opsional) — Salah satu dari berikut ini:str(nama repositori Hugging Face Hub): menjalankan fungsigeneratekustom yang didefinisikan dicustom_generate/generate.pypada repositori tersebut, bukan metodegeneratestandar. Repositori ini sepenuhnya menggantikan logika generasi, dan tipe pengembaliannya dapat berbeda.str(jalur repositori lokal): sama seperti di atas tetapi dari jalur lokal. Direktori lokal juga memerlukantrust_remote_code=Truekarenacustom_generate/generate.pylokal dieksekusi.Callable:generateakan melakukan langkah-langkah persiapan input yang biasa, lalu memanggil callable yang diberikan untuk menjalankan loop decoding. Untuk informasi lebih lanjut, lihat dokumentasinya.
- kwargs (
dict[str, Any], opsional) — Parametrisasi ad hoc untukgeneration_configdan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsiforwarddari model. Jika model tersebut adalah model encoder-decoder, kwargs spesifik encoder tidak boleh diberi awalan dan kwargs spesifik decoder harus diberi awalan decoder_.
Mengembalikan
ModelOutput atau torch.LongTensor
Sebuah ModelOutput (jika return_dict_in_generate=True
atau ketika config.return_dict_in_generate=True) atau sebuah torch.LongTensor.
Jika model bukan model encoder-decoder (model.config.is_encoder_decoder=False), tipe
ModelOutput yang mungkin adalah:
Jika model adalah model encoder-decoder (model.config.is_encoder_decoder=True), tipe
ModelOutput yang mungkin adalah:
Membuat rangkaian id token untuk model dengan kepala pemodelan bahasa.
Sebagian besar parameter pengendali generasi diatur di
generation_configyang, jika tidak diteruskan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpageneration_configmana 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.
VibeVoiceModel
kelas transformers.VibeVoiceModel
< source >( config: VibeVoiceConfig )
Parameter
- config (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() untuk memuat bobot model.
Model VibeVoice yang terdiri dari tokenizer audio dan backbone LLM, tanpa kepala pemodelan bahasa.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari 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
< source >( input_ids: LongTensor = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Nonesample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parameter
- input_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
- inputs_embeds (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskaninput_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeksinput_idsmenjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model. - input_values (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Nilai float dari gelombang suara mentah input. Nilai dapat diperoleh dengan memuat file audio.flacatau.wavke dalam array bertipelist[float],numpy.ndarrayatautorch.Tensor, misalnya melalui pustaka torchcodec (pip install torchcodec) atau pustaka soundfile (pip install soundfile). Untuk menyiapkan array menjadiinput_values, gunakan AutoProcessor untuk padding dan konversi menjadi tensor bertipetorch.Tensor. Lihat VibeVoiceProcessor.call() untuk detailnya. - padding_mask (
torch.Tensordengan bentuk(batch_size, padded_audio_length)) — Mask padding untuk menghapus bagian audio yang di-padding. - sample (
bool, opsional, defaultTrue) — Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model aslinya (σ-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 atau tuple(torch.Tensor)
A BaseModelOutputWithPast atau tuple dari
torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (VibeVoiceConfig) dan input.
Metode forward dari VibeVoiceModel menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.Tensordengan bentuk(batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.Jika
past_key_valuesdigunakan, hanya hidden-state terakhir dari sekuens dengan bentuk(batch_size, 1, hidden_size)yang dioutput.past_key_values (
Cache, opsional, dikembalikan saatuse_cache=Truedilewatkan atau saatconfig.use_cache=True) — Ini adalah instance Cache. Untuk detail lebih lanjut, lihat panduan 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=Truedi blok cross-attention) yang dapat digunakan (lihat inputpast_key_values) untuk mempercepat decoding berurutan.hidden_states (
tuple(torch.Tensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.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 saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.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 perhatian diri (self-attention).
get_audio_features
< source >( input_values: Tensorpadding_mask: Tensorsample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parameter
- input_values (
torch.Tensor) — Nilai float dari waveform audio (ternormalisasi). - padding_mask (
torch.Tensordengan bentuk(batch_size, padded_audio_length)) — Mask padding untuk menghapus bagian audio yang di-padding. - sample (
bool, opsional, defaultTrue) — Apakah akan menambahkan noise Gaussian ke latens akustik, seperti pada model aslinya (σ-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 atau tuple(torch.Tensor)
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) 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.Tensordengan bentuk(batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.pooler_output (
torch.Tensordengan 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 saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.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 saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.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 perhatian diri (self-attention).
get_placeholder_mask
< source >( input_ids: LongTensorinputs_embeds: Tensoraudio_features: Tensor )
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.