Transformers documentation
VibeVoice
Ce modèle a été publié dans HF papers le 2025-08-26 et contribué à Hugging Face Transformers le 2026-08-27.
VibeVoice
Aperçu
VibeVoice est un nouveau cadre permettant de synthétiser des voix de haute fidélité et de longue durée avec plusieurs locuteurs, en utilisant une approche de diffusion par jeton suivant au sein d’une structure de Large Language Model (LLM). Il est conçu pour capturer l’« ambiance » authentique d’une conversation et est particulièrement adapté à la génération de contenus audio tels que des podcasts et des audiobooks à plusieurs participants.
Deux points de contrôle de modèle sont disponibles à l'adresse suivante :
Ce modèle a été contribué par Eric Bezzam.
Architecture

Le framework VibeVoice intègre trois composants clés :
- Tokeniseurs de parole continus : tokeniseurs acoustiques et sémantiques spécialisés, où le tokeniseur acoustique utilise un $\sigma$-VAE pour atteindre une compression ultra-faible (7,5 jetons/s, 3200x) afin d'assurer l'évolutivité et la fidélité, et où le tokeniseur sémantique utilise une tâche de proxy ASR pour une extraction de fonctionnalités centrée sur le contenu.
- Grand modèle de langage (LLM) : utilise Qwen2.5 (en versions 1,5 Md et 7 Md de paramètres) comme modèle de séquence central.
- Tête de diffusion au niveau des jetons : conditionnée sur l'état caché du LLM et chargée de prédire les caractéristiques continues du VAE de manière en flux continu.
Le point de contrôle original de VibeVoice-1.5B est disponible sous l’organisation Microsoft sur Hugging Face.
Fonctionnalités clés
- Synthèse de longue durée : peut synthétiser jusqu'à 90 minutes de conversation orale à plusieurs locuteurs.
- Dialogue multi-locuteurs : capable de synthétiser de l'audio avec un maximum de 4 locuteurs.
- Qualité de pointe : Surpasse les références sur les métriques subjectives et objectives.
- Compression élevée : obtenue grâce à un tokeniseur acoustique novateur fonctionnant à un taux de trame ultra-faible de 7,5 Hz.
- LLM évolutif : le passage du LLM de base de 1,5 Md à 7 Md améliore nettement la qualité perçue.
Utilisation
Configuration
Un planificateur de bruit est nécessaire, car la génération d’audio repose sur un processus de diffusion. L’approche la plus simple (et celle adoptée par les développeurs du modèle) consiste à utiliser un planificateur de bruit de la bibliothèque diffusers. Par défaut, le modèle crée un planificateur de bruit avec diffusers en interne.
pip install diffusers
pip install soundfile # for saving audioChargement du modèle
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)Texte vers parole (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}")Clonage de voix TTS
Une voix peut être clonée en fournissant un audio de référence aux côtés du texte dans le dictionnaire du modèle de chat.
import os
from transformers import AutoProcessor, AutoModelForTextToWaveform, set_seed
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
set_seed(42) # for deterministic results
# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
sampling_rate = processor.feature_extractor.sampling_rate
# Prepare input
conversation = [
{
"role": "0",
"content": [
{"type": "text", "text": text},
{
"type": "audio",
"url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
},
],
}
]
inputs = processor.apply_chat_template(
conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)
# Generate!
audio = model.generate(**inputs)
# Save to file
fn = f"{os.path.basename(model_id)}_tts_clone.wav"
processor.save_audio(audio, fn)
print(f"Saved output to {fn}")Générer un podcast à partir d'un script
Voici un exemple de génération d'une conversation entre deux interlocuteurs, dont les voix sont clonées en fournissant un audio de référence pour chaque identifiant de rôle unique dans le modèle de chat.
L’exemple ci-dessous utilise également l’option monitor_progress pour suivre la progression de la génération.
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}")Inférence par lots
Pour le traitement par lots, une liste de conversations peut être transmise à 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}")Utilisation du pipeline
VibeVoice peut également être chargé en tant que pipeline. Nous montrons également ci-dessous comment les paramètres de diffusion peuvent être ajustés.
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}")Entraînement
VibeVoice peut être entraîné à l'aide de la perte produite par le modèle.
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
Le modèle peut être compilé avec torch.compile pour accélérer l'inférence. Quelques exécutions de mise en route sont nécessaires avant que le modèle compilé n'atteigne sa vitesse maximale.
Sur une A100 avec une taille de lot de 4, nous avons observé une accélération d’environ 1,5x entre l’inférence compilée et non compilée, voir ce script.
import os
import time
import torch
from transformers import AutoModelForTextToWaveform, AutoProcessor, CompileConfig
model_id = "vibevoice/VibeVoice-1.5B-hf" # "vibevoice/VibeVoice-7B-hf"
num_warmup = 5
max_new_tokens = 128
torch.set_float32_matmul_precision("high")
# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto").eval()
# Prepare inputs
conversation = [
[
{
"role": "0",
"content": [
{"type": "text", "text": "VibeVoice is a novel framework for generating expressive audio."},
{
"type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
},
],
}
],
] * 4 # batch size 4
inputs = processor.apply_chat_template(
conversation, tokenize=True, return_dict=True, add_generation_prompt=True,
).to(model.device, model.dtype)
compile_config = CompileConfig(mode="default", dynamic=False)
generate_kwargs = dict(
**inputs,
max_new_tokens=max_new_tokens,
cache_implementation="static",
compile_config=compile_config,
)
# Warmup
print("Warming up...")
warmup_start = time.time()
with torch.inference_mode():
for _ in range(num_warmup):
torch.compiler.cudagraph_mark_step_begin()
_ = model.generate(**generate_kwargs)
torch.cuda.synchronize()
print(f"Warmup complete in {time.time() - warmup_start:.2f}s. Ready!")
# Apply model
with torch.inference_mode():
torch.compiler.cudagraph_mark_step_begin()
audio = model.generate(**generate_kwargs)
output_folder = f"{os.path.basename(model_id)}_compiled_output"
processor.save_audio(audio, output_folder)
print(f"Saved output to {output_folder}")VibeVoiceConfig
classe transformers.VibeVoiceConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonediffusion_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 151643eos_token_id: int = 151643audio_bos_token_id: int = 151652audio_eos_token_id: int = 151653audio_token_id: int = 151654diffusion_loss_weight: float = 0.5 )
Paramètres
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone audio. - semantic_model_config (
Union[AutoConfig, dict], facultatif) — L’objet de configuration ou le dictionnaire de l’encodeur du tokenizer sémantique. Ce tokenizer extrait des caractéristiques sémantiques à partir de l’audio. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte. - diffusion_head_config (
Union[VibeVoiceDiffusionHeadConfig, dict], facultatif) — Objet de configuration ou dictionnaire de la tête de diffusion utilisée pour synthétiser les latents acoustiques. - pad_token_id (
int, facultatif, par défaut151643) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - eos_token_id (
int, facultatif, valeur par défaut151643) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - audio_bos_token_id (
int, facultatif, valeur par défaut : 151652) — L'identifiant du jeton indiquant le début des jetons audio. - audio_eos_token_id (
int, facultatif, valeur par défaut : 151653) — L'identifiant du jeton indiquant la fin des jetons audio. - audio_token_id (
int, facultatif, valeur par défaut151654) — L'index du jeton audio utilisé comme espace réservé pour l'audio d'entrée. - diffusion_loss_weight (
float, facultatif, valeur par défaut 0.5) — Le poids de la perte de diffusion dans le calcul de la perte globale. La perte d'entropie croisée pour la tête de modélisation du langage est pondérée par(1 - diffusion_loss_weight).
Ceci est la classe de configuration destinée à stocker la configuration d'un VibeVoiceForConditionalGeneration. Elle est utilisée pour instancier un modèle Vibevoice en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de vibevoice/VibeVoice-1.5B-hf
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
>>> from transformers import VibeVoiceForConditionalGeneration, VibeVoiceConfig
>>> # Initializing a VibeVoice configuration
>>> configuration = VibeVoiceConfig()
>>> # Initializing a 1.5B model with random weights
>>> model = VibeVoiceForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configVibeVoiceDiffusionHeadConfig
classe transformers.VibeVoiceDiffusionHeadConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1536latent_size: int = 64num_hidden_layers: int = 4intermediate_size: int = 4608rms_norm_eps: float = 1e-05hidden_act: str = 'silu'frequency_embedding_size: int = 256diffusion_max_period: int = 10000mlp_bias: bool = False )
Paramètres
- hidden_size (
int, facultatif, par défaut1536) — Dimension des représentations cachées. - latent_size (
int, facultatif, valeur par défaut : 64) — Dimension des latents acoustiques que la tête débruite. - num_hidden_layers (
int, facultatif, par défaut4) — Nombre de couches cachées dans le décodeur Transformer. - intermediate_size (
int, facultatif, par défaut4608) — Dimension des représentations du MLP. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - frequency_embedding_size (
int, facultatif, valeur par défaut : 256) — Taille de l'intégration sinusoïdale de fréquence pour l'encodage des pas de temps dans la tête de diffusion. - diffusion_max_period (
int, facultatif, valeur par défaut : 10000) — Période maximale pour l'encodage de fréquence sinusoïdale dans la tête de diffusion. - mlp_bias (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser un biais dans les couches up_proj, down_proj et gate_proj des couches MLP.
Ceci est la classe de configuration destinée à stocker la configuration d'un VibeVoiceForConditionalGeneration. Elle est utilisée pour instancier un modèle Vibevoice en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de vibevoice/VibeVoice-1.5B-hf
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
VibeVoiceProcessor
classe transformers.VibeVoiceProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_bos_token = '<|vision_start|>'audio_eos_token = '<|vision_end|>'audio_token = '<|vision_pad|>' )
Paramètres
- feature_extractor (
VibeVoiceAcousticTokenizerFeatureExtractor) — L’extracteur de caractéristiques est une entrée obligatoire. - tokenizer (
Qwen2TokenizerFast) — Le tokenizer est une entrée obligatoire. - chat_template (
str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. - audio_bos_token (
str, facultatif, par défaut"<|vision_start|>") — Le jeton utilisé pour indiquer le début de la génération audio. - audio_eos_token (
str, facultatif, par défaut"<|vision_end|>") — Le jeton utilisé pour indiquer la fin de la génération audio. - audio_token (
str, facultatif, par défaut"<|vision_pad|>") — Le jeton utilisé pour indiquer de continuer à générer de l'audio.
Construit un VibeVoiceProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
VibeVoiceProcessor propose toutes les fonctionnalités de VibeVoiceAcousticTokenizerFeatureExtractor et de Qwen2TokenizerFast. Consultez ~VibeVoiceAcousticTokenizerFeatureExtractor et ~Qwen2TokenizerFast pour plus d’informations.
__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
Paramètres
- text (
str,List[str]) — Le ou les textes d'entrée à traiter, généralement préparés par apply_chat_template avec des jetons de remplacement pour l'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, facultatif, par défaut=False) — Indique s'il faut retourner les étiquettes pour l'entraînement. - **kwargs — Arguments supplémentaires passés au tokenizer et à l'extracteur de caractéristiques.
- return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Retourne
Un BatchFeature avec les champs suivants :
- input_ids — Liste des identifiants de jetons à fournir au modèle.
- attention_mask — Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque
return_attention_mask=True). - input_values — Liste des valeurs audio à fournir au modèle. Renvoyé lorsque
audion'est pasNone. - padding_mask — Liste d'indices indiquant les trames audio auxquelles le modèle doit prêter attention.
Retourné lorsque
audion'est pasNone. - labels — Étiquettes pour l'entraînement du modèle de langage. Les jetons de bourrage et de diffusion audio sont masqués avec
-100 (les embeddings des jetons de diffusion audio sont remplacés par des caractéristiques audio, de sorte que l'identité de ces jetons ne constitue pas une cible
significative). Les jetons bos/eos audio et les jetons eos texte sont conservés comme cibles afin que le LM apprenne quand commencer
et arrêter la génération d'audio. Renvoyé lorsque
output_labels=True. - acoustic_loss_mask — Masque booléen pour les positions où la perte de diffusion est calculée. Vrai aux positions des jetons de diffusion audio. Renvoyé lorsque
output_labels=True.
VibeVoiceForConditionalGeneration
classe transformers.VibeVoiceForConditionalGeneration
< source >( config: VibeVoiceConfig )
Paramètres
- config (VibeVoiceConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle VibeVoice, qui est composé d'un modèle de langage, de tokenizers audio, de connecteurs et d'une tête de diffusion.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - logits_to_keep (
Union[int, slice], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_ids(cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les longues séquences ou les grandes tailles de vocabulaire. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de séquence). - input_values (
torch.Tensor, facultatif) — Forme d'onde audio prétraitée pour le clonage de voix. - padding_mask (
torch.BoolTensor, facultatif) — Masques indiquant les trames d'entrée valides. - acoustic_loss_mask (
torch.BoolTensor, facultatif) — Masque pour calculer la perte de diffusion uniquement sur des jetons acoustiques spécifiques. - noise_scheduler (
object, facultatif) — Nécessaire pour l’entraînement afin de calculer les cibles de bruit pour la perte de diffusion. Par défaut, utilise la configuration du planificateur de bruit spécifiée dans legeneration_configdu modèle. - ddpm_batch_multiplier (
int, facultatif, valeur par défaut : 4) — Pour l’entraînement, nombre d’échantillons de bruit à générer par jeton audio pour le calcul de la perte de diffusion, ce qui peut aider à stabiliser l’entraînement. - num_diffusion_steps (
int, facultatif, valeur par défaut : 10) — Pour l’entraînement, le nombre d’étapes de diffusion à utiliser. La valeur par défaut est 10 si aucune valeur n’est fournie. - sample (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter du bruit gaussien aux latents acoustiques, comme dans le modèle d'origine (σ-VAE : l'échelle du bruit est tirée pour chaque élément du lot à partir de N(0,vae_std)). Si False, la sortie de l'encodeur est utilisée telle quelle, ce qui rend la sortie déterministe.
Retourne
VibeVoiceCausalLMOutputWithPast ou tuple(torch.Tensor)
Un VibeVoiceCausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (VibeVoiceConfig) et des entrées.
La méthode forward de VibeVoiceForConditionalGeneration redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si
config.is_encoder_decoder=True, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entréepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).audio_features (
torch.Tensorde forme(batch_size, sequence_length, feature_size), facultatif) — Caractéristiques audio extraites qui peuvent être utilisées pour conditionner le modèle de langage.
Exemple :
>>> 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
Paramètres
- inputs (
torch.Tensorde forme variable selon la modalité, facultatif) — La séquence utilisée comme invite pour la génération ou comme entrées du modèle pour l’encodeur. SiNone, la méthode l’initialise avecbos_token_idet une taille de lot de 1. Pour les modèles uniquement décodeurs,inputsdoit être au format deinput_ids. Pour les modèles encodeur-décodeur, inputs peut représenter l’un desinput_ids,input_values,input_featuresoupixel_values. - generation_config (GenerationConfig, facultatif) —
La configuration de génération à utiliser comme paramétrage de base pour l’appel de génération. Les
**kwargstransmis à generate qui correspondent aux attributs degeneration_configles remplaceront. Sigeneration_confign’est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèlegeneration_config.json, s’il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de GenerationConfig, dont la documentation doit être consultée pour paramétrer la génération. - logits_processor (
LogitsProcessorList, facultatif) — Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut construits à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés. - stopping_criteria (
StoppingCriteriaList, facultatif) — Critères d’arrêt personnalisés qui complètent les critères d’arrêt par défaut construits à partir des arguments et d’une configuration de génération. Si un critère d’arrêt est transmis qui a déjà été créé à partir des arguments ou d’une configuration de génération, une erreur est levée. Si votre critère d’arrêt dépend de l’entréescores, assurez-vous de passerreturn_dict_in_generate=True, output_scores=Trueàgenerate. Cette fonctionnalité est destinée aux utilisateurs avancés. - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], list[int]], facultatif) — Si fourni, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si non fourni, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lotbatch_idetinput_ids. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lotbatch_idet les jetons générés précédemmentinputs_ids. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans Autoregressive Entity Retrieval. - synced_gpus (
bool, facultatif) — Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length. Sauf si cette valeur est remplacée, ce drapeau est défini surTruelors de l'utilisation deFullyShardedDataParallelou de DeepSpeed ZeRO Stage 3 avec plusieurs GPU, afin d'éviter tout blocage si un GPU termine la génération avant les autres. Sinon, la valeur par défaut estFalse. - assistant_model (
PreTrainedModel, facultatif) — Un modèle assistant pouvant être utilisé pour accélérer la génération. Le modèle assistant doit utiliser exactement le même tokenizer. L’accélération est obtenue lorsque la prédiction des jetons candidats par le modèle assistant est beaucoup plus rapide que l’exécution de la génération avec le modèle dont vous appelez la méthode generate. En conséquence, le modèle assistant doit être beaucoup plus petit. - streamer (
BaseStreamer, facultatif) — Objet de diffusion utilisé pour diffuser les séquences générées. Les jetons générés sont transmis viastreamer.put(token_ids)et l’objet est responsable de tout traitement ultérieur. - negative_prompt_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Le prompt négatif requis par certains processeurs tels que CFG. La taille du lot doit correspondre à la taille du lot d’entrée. Il s’agit d’une fonctionnalité expérimentale, susceptible de subir des modifications cassant l’API dans les versions futures. - negative_prompt_attention_mask (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Attention_mask pournegative_prompt_ids. - custom_generate (
strouCallable, facultatif) — L'une des options suivantes :str(nom du dépôt Hugging Face Hub) : exécute la fonctiongeneratepersonnalisée définie danscustom_generate/generate.pyde ce dépôt à la place de la méthode standardgenerate. Le dépôt remplace entièrement la logique de génération, et le type de retour peut différer.str(chemin du dépôt local) : identique à ce qui précède, mais à partir d’un chemin local. Les répertoires locaux nécessitent égalementtrust_remote_code=Truecar le fichier localcustom_generate/generate.pyest exécuté.Callable:generateeffectuera les étapes habituelles de préparation des entrées, puis appellera le callable fourni pour exécuter la boucle de décodage. Pour plus d’informations, consultez la documentation.
- kwargs (
dict[str, Any], facultatif) — Paramétrage ad hoc degeneration_configet/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonctionforwarddu modèle. Si le modèle est un modèle encodeur-décodeur, les kwargs spécifiques à l'encodeur ne doivent pas être préfixés et les kwargs spécifiques au décodeur doivent être préfixés par decoder_.
Retourne
ModelOutput ou torch.LongTensor
Un ModelOutput (si return_dict_in_generate=True
ou lorsque config.return_dict_in_generate=True) ou un torch.LongTensor.
Si le modèle n'est pas un modèle encodeur-décodeur (model.config.is_encoder_decoder=False), les types
ModelOutput possibles sont :
Si le modèle est un modèle encodeur-décodeur (model.config.is_encoder_decoder=True), les types
ModelOutput possibles sont :
Génère des séquences d'identifiants de jetons pour les modèles dotés d'une tête de modélisation de langage.
La plupart des paramètres de contrôle de la génération sont définis dans
generation_configqui, s'il n'est pas transmis, sera défini sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quelgeneration_configen transmettant les paramètres correspondants à generate(), par exemple.generate(inputs, num_beams=4, do_sample=True).Pour un aperçu des stratégies de génération et des exemples de code, consultez le guide suivant.
VibeVoiceModel
classe transformers.VibeVoiceModel
< source >( config: VibeVoiceConfig )
Paramètres
- config (VibeVoiceConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle VibeVoice, qui se compose de tokeniseurs audio et d'un squelette LLM, sans tête de modélisation de langage.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - input_values (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Valeurs flottantes de la forme d’onde brute de la parole d’entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, il faut utiliser AutoProcessor pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. Voir VibeVoiceProcessor.call() pour plus de détails. - padding_mask (
torch.Tensorde forme(batch_size, padded_audio_length)) — Masque de bourrage pour supprimer les parties bourrées de l'audio. - sample (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter du bruit gaussien aux latents acoustiques, comme dans le modèle d'origine (σ-VAE : l'échelle du bruit est tirée pour chaque élément du lot à partir de N(0,vae_std)). Si False, la sortie de l'encodeur est utilisée telle quelle, ce qui rend la sortie déterministe.
Retourne
BaseModelOutputWithPast ou tuple(torch.Tensor)
Un BaseModelOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (VibeVoiceConfig) et des entrées.
La méthode forward du modèle VibeVoiceModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si
config.is_encoder_decoder=True, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entréepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
get_audio_features
< source >( input_values: Tensorpadding_mask: Tensorsample: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensor) — Valeurs flottantes de la forme d'onde audio (normalisée). - padding_mask (
torch.Tensorde forme(batch_size, padded_audio_length)) — Masque de bourrage pour supprimer les parties bourrées de l'audio. - sample (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter du bruit gaussien aux latents acoustiques, comme dans le modèle d'origine (σ-VAE : l'échelle du bruit est tirée pour chaque élément du lot à partir de N(0,vae_std)). Si False, la sortie de l'encodeur est utilisée telle quelle, ce qui rend la sortie déterministe.
Retourne
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (VibeVoiceConfig) et des entrées.
Cette méthode est utilisée pour obtenir les embeddings audio (qui remplacent les jetons audio de substitution dans la séquence d'entrée) et les caractéristiques acoustiques (utilisées comme cible de diffusion) à partir de la forme d'onde audio d'entrée.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.Tensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
get_placeholder_mask
< source >( input_ids: LongTensorinputs_embeds: Tensoraudio_features: Tensor )
Obtient le masque de jetons multimodaux à partir de input_ids ou de inputs_embeds, et vérifie que le nombre de jetons correspond à la longueur des fonctionnalités multimodales. Si les longueurs diffèrent, une erreur est levée.