Transformers documentation
VibeVoice Acoustic Tokenizer
Ce modèle a été publié dans HF papers le 2025-08-26 et contribué à Hugging Face Transformers le 2026-02-06.
VibeVoice Acoustic Tokenizer
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.
L'une des fonctionnalités clés de VibeVoice est l'utilisation de deux tokeniseurs audio continus, l'un pour l'extraction des caractéristiques acoustiques et l'autre pour les caractéristiques sémantiques.
Un point de contrôle du modèle est disponible sur microsoft/VibeVoice-AcousticTokenizer
Ce modèle a été contribué par Eric Bezzam.
Architecture
L'architecture est une structure encodeur-décodeur symétrique par miroir. L'encodeur adopte une conception hiérarchique composée de 7 niveaux de blocs de type ConvNeXt, qui utilisent des convolutions causales en profondeur 1D pour un traitement en flux efficace. Six couches de sous-échantillonnage atteignent un taux de sous-échantillonnage cumulé de 3200X à partir d'une entrée de 24 kHz, produisant 7,5 jetons/trames par seconde. Chaque composant encodeur/décodeur compte environ 340 M de paramètres, soit un total d'environ 680 M de paramètres. L'objectif d'entraînement suit celui de DAC, y compris la conception de son discriminateur et de ses fonctions de perte.
Acoustic Tokenizer adopte les principes d'un auto-encodeur variationnel (VAE). L'encodeur mappe l'audio d'entrée vers les paramètres d'une distribution latente, à savoir la moyenne. Avec un écart-type fixe, un vecteur latent est ensuite échantillonné à l'aide de l'astuce de reparamétrisation. Veuillez consulter le rapport technique pour plus de détails.
Utilisation
Voici un exemple d'utilisation pour encoder et décoder de l'audio :
import torch
from scipy.io import wavfile
from transformers import AutoFeatureExtractor, VibeVoiceAcousticTokenizerModel
from transformers.audio_utils import load_audio_librosa
model_id = "microsoft/VibeVoice-AcousticTokenizer"
# load model
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = VibeVoiceAcousticTokenizerModel.from_pretrained(model_id, device_map="auto")
print("Model loaded on device:", model.device)
print("Model dtype:", model.dtype)
# load audio
audio = load_audio_librosa(
"https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
sampling_rate=feature_extractor.sampling_rate,
)
# preprocess audio
inputs = feature_extractor(
audio,
sampling_rate=feature_extractor.sampling_rate,
pad_to_multiple_of=3200,
).to(model.device, model.dtype)
print("Input audio shape:", inputs.input_values.shape)
# Input audio shape: torch.Size([1, 1, 224000])
with torch.no_grad():
# set VAE sampling to False for deterministic output
encoded_outputs = model.encode(inputs.input_values, sample=False)
print("Latent shape:", encoded_outputs.latents.shape)
# Latent shape: torch.Size([1, 70, 64])
decoded_outputs = model.decode(**encoded_outputs)
print("Reconstructed audio shape:", decoded_outputs.audio.shape)
# Reconstructed audio shape: torch.Size([1, 1, 224000])
# Save audio
output_fp = "vibevoice_acoustic_tokenizer_reconstructed.wav"
wavfile.write(output_fp, feature_extractor.sampling_rate, decoded_outputs.audio.squeeze().float().cpu().numpy())
print(f"Reconstructed audio saved to : {output_fp}")Streaming
Pour l’ASR ou le TTS en streaming, où les états mis en cache doivent être suivis, le paramètre use_cache peut être utilisé lors de l’encodage ou du décodage de l’audio :
import torch
from scipy.io import wavfile
from transformers import AutoFeatureExtractor, VibeVoiceAcousticTokenizerModel
from transformers.audio_utils import load_audio_librosa
model_id = "microsoft/VibeVoice-AcousticTokenizer"
# load model
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = VibeVoiceAcousticTokenizerModel.from_pretrained(model_id, device_map="auto")
print("Model loaded on device:", model.device)
print("Model dtype:", model.dtype)
# load audio
audio = load_audio_librosa(
"https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
sampling_rate=feature_extractor.sampling_rate,
)
# preprocess audio
inputs = feature_extractor(
audio,
sampling_rate=feature_extractor.sampling_rate,
pad_to_multiple_of=3200,
).to(model.device, model.dtype)
print("Input audio shape:", inputs.input_values.shape)
# Input audio shape: torch.Size([1, 1, 224000])
# cache will be initialized after a first pass
encoder_cache = None
decoder_cache = None
with torch.no_grad():
# set VAE sampling to False for deterministic output
encoded_outputs = model.encode(inputs.input_values, sample=False, padding_cache=encoder_cache, use_cache=True)
print("Latent shape:", encoded_outputs.latents.shape)
# Latent shape: torch.Size([1, 70, 64])
decoded_outputs = model.decode(encoded_outputs.latents, padding_cache=decoder_cache, use_cache=True)
print("Reconstructed audio shape:", decoded_outputs.audio.shape)
# Reconstructed audio shape: torch.Size([1, 1, 224000])
# `padding_cache` can be extracted from the outputs for subsequent passes
encoder_cache = encoded_outputs.padding_cache
print("Number of cached encoder layers:", len(encoder_cache.per_layer_in_channels))
# Number of cached encoder layers: 34
decoder_cache = decoded_outputs.padding_cache
print("Number of cached decoder layers:", len(decoder_cache.per_layer_in_channels))
# Number of cached decoder layers: 34
# Save audio
output_fp = "vibevoice_acoustic_tokenizer_reconstructed.wav"
wavfile.write(output_fp, feature_extractor.sampling_rate, decoded_outputs.audio.squeeze().float().cpu().numpy())
print(f"Reconstructed audio saved to : {output_fp}")VibeVoiceAcousticTokenizerConfig
classe transformers.VibeVoiceAcousticTokenizerConfig
< 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 = Nonechannels: int = 1hidden_size: int = 64kernel_size: int = 7rms_norm_eps: float = 1e-05layer_scale_init_value: float = 1e-06initializer_range: float = 0.01num_filters: int = 32downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8)depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8)hidden_act: str = 'gelu'ffn_expansion: int = 4vae_std: float = 0.625 )
Paramètres
- channels (
int, facultatif, par défaut 1) — Nombre de canaux d'entrée. - hidden_size (
int, facultatif, valeur par défaut : 64) — Dimension des représentations latentes. - kernel_size (
int, facultatif, valeur par défaut : 7) — Taille du noyau pour les couches de convolution. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - layer_scale_init_value (
float, facultatif, par défaut1e-06) — Échelle à utiliser dans les couches d'auto-attention. 0.1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche. - initializer_range (
float, facultatif, par défaut0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - num_filters (
int, facultatif, valeur par défaut : 32) — Nombre de filtres dans la couche convolutive initiale, doublé après chaque sous-échantillonnage. - downsampling_ratios (
List[int], facultatif, par défaut[2, 2, 4, 5, 5, 8]) — Ratios de sous-échantillonnage pour chaque couche. - depths (
List[int], facultatif, par défaut[3, 3, 3, 3, 3, 3, 8]) — Nombre de blocs ConvNeXt à chaque étape. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - ffn_expansion (
int, facultatif, valeur par défaut : 4) — Facteur d'expansion pour les réseaux feed-forward. - vae_std (
float, facultatif, valeur par défaut 0,625) — Écart-type de la gaussienne à partir de laquelle l'échelle de bruit par échantillon est tirée lorsque du bruit est ajouté aux latents de l'encodeur (sample=True).
Il s'agit de la classe de configuration destinée à stocker la configuration d'un VibeVoiceAcousticTokenizerModel. Elle est utilisée pour instancier un modèle Vibevoice Acoustic Tokenizer 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 microsoft/VibeVoice-1.5B
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.
Exemple :
>>> from transformers import VibeVoiceAcousticTokenizerModel, VibeVoiceAcousticTokenizerConfig
>>> # Initializing a VibeVoice Acoustic Tokenizer configuration
>>> configuration = VibeVoiceAcousticTokenizerConfig()
>>> # Initializing a model (with random weights)
>>> model = VibeVoiceAcousticTokenizerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configVibeVoiceAcousticTokenizerEncoderConfig
classe transformers.VibeVoiceAcousticTokenizerEncoderConfig
< 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 = Nonechannels: int = 1hidden_size: int = 64kernel_size: int = 7rms_norm_eps: float = 1e-05layer_scale_init_value: float = 1e-06initializer_range: float = 0.01num_filters: int = 32downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8)depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8)hidden_act: str = 'gelu'ffn_expansion: int = 4vae_std: float = 0.625 )
Paramètres
- channels (
int, facultatif, par défaut 1) — Nombre de canaux d'entrée. - hidden_size (
int, facultatif, valeur par défaut : 64) — Dimension des représentations latentes. - kernel_size (
int, facultatif, valeur par défaut : 7) — Taille du noyau pour les couches de convolution. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - layer_scale_init_value (
float, facultatif, par défaut1e-06) — Échelle à utiliser dans les couches d'auto-attention. 0.1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche. - initializer_range (
float, facultatif, par défaut0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - num_filters (
int, facultatif, valeur par défaut : 32) — Nombre de filtres dans la couche convolutive initiale, doublé après chaque sous-échantillonnage. - downsampling_ratios (
List[int], facultatif, par défaut[2, 2, 4, 5, 5, 8]) — Ratios de sous-échantillonnage pour chaque couche. - depths (
List[int], facultatif, par défaut[3, 3, 3, 3, 3, 3, 8]) — Nombre de blocs ConvNeXt à chaque étape. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - ffn_expansion (
int, facultatif, valeur par défaut : 4) — Facteur d'expansion pour les réseaux feed-forward. - vae_std (
float, facultatif, valeur par défaut 0,625) — Écart-type de la gaussienne à partir de laquelle l'échelle de bruit par échantillon est tirée lorsque du bruit est ajouté aux latents de l'encodeur (sample=True).
Il s'agit de la classe de configuration destinée à stocker la configuration d'un VibeVoiceAcousticTokenizerModel. Elle est utilisée pour instancier un modèle Vibevoice Acoustic Tokenizer 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 microsoft/VibeVoice-1.5B
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.
VibeVoiceAcousticTokenizerDecoderConfig
classe transformers.VibeVoiceAcousticTokenizerDecoderConfig
< 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 = Nonechannels: int = 1hidden_size: int = 64kernel_size: int = 7rms_norm_eps: float = 1e-05layer_scale_init_value: float = 1e-06initializer_range: float = 0.01num_filters: int = 32downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8)depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8)hidden_act: str = 'gelu'ffn_expansion: int = 4vae_std: float = 0.625 )
Paramètres
- channels (
int, facultatif, par défaut 1) — Nombre de canaux d'entrée. - hidden_size (
int, facultatif, valeur par défaut : 64) — Dimension des représentations latentes. - kernel_size (
int, facultatif, valeur par défaut : 7) — Taille du noyau pour les couches de convolution. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - layer_scale_init_value (
float, facultatif, par défaut1e-06) — Échelle à utiliser dans les couches d'auto-attention. 0.1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche. - initializer_range (
float, facultatif, par défaut0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - num_filters (
int, facultatif, valeur par défaut : 32) — Nombre de filtres dans la couche convolutive initiale, doublé après chaque sous-échantillonnage. - downsampling_ratios (
List[int], facultatif, par défaut[2, 2, 4, 5, 5, 8]) — Ratios de sous-échantillonnage pour chaque couche. - depths (
List[int], facultatif, par défaut[3, 3, 3, 3, 3, 3, 8]) — Nombre de blocs ConvNeXt à chaque étape. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - ffn_expansion (
int, facultatif, valeur par défaut : 4) — Facteur d'expansion pour les réseaux feed-forward. - vae_std (
float, facultatif, valeur par défaut 0,625) — Écart-type de la gaussienne à partir de laquelle l'échelle de bruit par échantillon est tirée lorsque du bruit est ajouté aux latents de l'encodeur (sample=True).
Il s'agit de la classe de configuration destinée à stocker la configuration d'un VibeVoiceAcousticTokenizerModel. Elle est utilisée pour instancier un modèle Vibevoice Acoustic Tokenizer 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 microsoft/VibeVoice-1.5B
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.
VibeVoiceAcousticTokenizerFeatureExtractor
classe transformers.VibeVoiceAcousticTokenizerFeatureExtractor
< source >( feature_size = 1sampling_rate = 24000padding_value = 0.0normalize_audio = Truetarget_dB_FS = -25eps = 1e-06pad_to_multiple_of = 3200**kwargs )
Paramètres
- feature_size (
int, facultatif, valeur par défaut 1) — Le nombre de canaux. - sampling_rate (
int, facultatif, par défaut 24000) — La fréquence d'échantillonnage à laquelle la forme d'onde audio doit être numérisée, exprimée en hertz (Hz). - padding_value (
float, facultatif, par défaut 0.0) — La valeur utilisée pour le bourrage. - normalize_audio (
bool, facultatif, par défautTrue) — Indique s'il faut normaliser l'audio vers un niveau cible en dB FS. - target_dB_FS (
float, facultatif, valeur par défaut : -25) — dB FS cible pour la normalisation. - eps (
float, facultatif, valeur par défaut 1e-06) — Petite valeur utilisée pour éviter la division par zéro lors de la normalisation. - pad_to_multiple_of (
int, facultatif, valeur par défaut 3200) — Remplit l’audio jusqu’à un multiple de cette valeur, qui doit correspondre à la longueur de saut du tokenizer acoustique, c’est-à-dire au facteur de sous-échantillonnage de son encodeur.
Construit un extracteur de caractéristiques VibeVoiceAcousticTokenizer.
__call__
< source >( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]sampling_rate: int | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy | None = Truepad_to_multiple_of: int | None = Nonemax_length: int | None = Nonereturn_attention_mask: bool | None = Truereturn_tensors: str | None = 'pt'**kwargs )
Paramètres
- audio (
np.ndarray,torch.Tensor,list[np.ndarray],list[torch.Tensor]— La séquence ou le lot de séquences à traiter. Chaque séquence peut être un tableau numpy, un tenseur torch, une liste de tableaux numpy ou une liste de tenseurs torch. - sampling_rate (
int, facultatif) — La fréquence d’échantillonnage à laquelle l’entréeaudioa été échantillonnée. Il est fortement recommandé de passersampling_ratelors de l’appel forward afin d’éviter les erreurs silencieuses. - padding (
bool,strou PaddingStrategy, facultatif, défaut :True) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourdée jusqu'à un multiple de la valeur fournie. Par défaut,self.pad_to_multiple_ofest utilisé si aucune valeur n'est fournie.
VibeVoiceAcousticTokenizerModel
classe transformers.VibeVoiceAcousticTokenizerModel
< source >( config: VibeVoiceAcousticTokenizerConfig )
Paramètres
- config (VibeVoiceAcousticTokenizerConfig) — 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.
VibeVoice, un tokenizer acoustique doté d'un encodeur et d'un décodeur pour des jetons acoustiques continus.
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.
encode
< source >( input_valuespadding_cache = Noneuse_cache = Nonesample = True )
Paramètres
- input_values (
torch.Tensorde forme(batch_size, channels, sequence_length)) — Forme d'onde audio d'entrée à encoder en représentation latente. - padding_cache (
VibeVoiceAcousticTokenizerConv1dPaddingCache, facultatif) — Objet de cache pour le mode streaming afin de maintenir les états de convolution entre les couches. - use_cache (
bool, facultatif) — Indique s'il faut utiliser la mise en cache pour les états de convolution. - sample (
bool, facultatif) — Indique s'il faut ajouter du bruit gaussien aux latents (σ-VAE : l'échelle du bruit est tirée par élément du lot à partir de N(0,config.vae_std)). Si la valeur est False, la sortie de l'encodeur est renvoyée telle quelle.
décoder
< source >( latentspadding_cache = Noneuse_cache = False )
Paramètres
- latents (
torch.Tensorde forme(batch_size, channels, sequence_length)) — Représentation latente d'entrée à décoder en audio. - padding_cache (
VibeVoiceAcousticTokenizerConv1dPaddingCache, facultatif) — Objet de cache pour le mode streaming afin de maintenir les états de convolution entre les couches. - use_cache (
bool, facultatif) — Indique s'il faut utiliser la mise en cache pour les états de convolution.
forward
< source >( input_valuespadding_cache = Noneuse_cache = Falsesample = True**kwargs )
Paramètres
- input_values (
torch.Tensorde forme(batch_size, channels, sequence_length)) — Forme d'onde audio d'entrée à encoder en représentation latente. - padding_cache (
VibeVoiceAcousticTokenizerConv1dPaddingCache, facultatif) — Objet de cache pour le mode streaming afin de maintenir les états de convolution entre les couches. À noter qu'il n'est utilisé que par le décodeur. - use_cache (
bool, facultatif) — Indique s'il faut utiliser la mise en cache pour les états de convolution. - sample (
bool, facultatif) — Indique s'il faut ajouter du bruit gaussien aux latents (σ-VAE : l'échelle du bruit est tirée par élément du lot à partir de N(0,config.vae_std)). Si la valeur est False, la sortie de l'encodeur est renvoyée telle quelle.
La méthode forward du modèle VibeVoiceAcousticTokenizerModel 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.
VibeVoiceAcousticTokenizerEncoderModel
classe transformers.VibeVoiceAcousticTokenizerEncoderModel
< source >( config: VibeVoiceAcousticTokenizerEncoderConfig )
VibeVoiceAcousticTokenizerDecoderModel
classe transformers.VibeVoiceAcousticTokenizerDecoderModel
< source >( config: VibeVoiceAcousticTokenizerDecoderConfig )