Transformers documentation
Higgs Audio V2 Tokenizer
Ce modèle a été contribué à Hugging Face Transformers le 2026-02-19.
Higgs Audio V2 Tokenizer
Aperçu
- Basse fréquence d'images : à 25 images par seconde, notre tokenizer divise par deux la fréquence d'images de nombreuses références tout en maintenant une haute qualité audio.
- Entraînement unifié à 24 kHz : nous mélangeons des extraits de parole, de musique et d'événements sonores dans un seul modèle, capturant à la fois les détails sémantiques et acoustiques, ce qui facilite considérablement l'entraînement des modèles de langage audio.
- Inférence rapide : en évitant les étapes de diffusion, notre encodeur/décodeur traite les lots rapidement, ce qui le rend pratique pour les tâches en temps réel ou à grande échelle.
Architecture du modèle :
Utilisation
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, HiggsAudioV2TokenizerModel
# load model and feature extractor
model_id = "eustlb/higgs-audio-v2-tokenizer"
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = HiggsAudioV2TokenizerModel.from_pretrained(model_id, device_map="auto")
# load audio sample
dummy_dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dummy_dataset = dummy_dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = dummy_dataset[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)
# encode and decode
encoder_outputs = model.encode(inputs["input_values"])
decoder_outputs = model.decode(encoder_outputs.audio_codes)
audio_values = decoder_outputs.audio_values
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_valuesHiggsAudioV2TokenizerConfig
classe transformers.HiggsAudioV2TokenizerConfig
< 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 = Nonetarget_bandwidths: list[int | float] | tuple[int | float, ...] = (0.5, 1, 1.5, 2, 4)sample_rate: int = 24000kernel_size: int = 3channel_ratios: list[int] | tuple[int, ...] = (1, 1)strides: list[int] | tuple[int, ...] = (1, 1)block_dilations: list[int] | tuple[int, ...] = (1, 1)unit_kernel_size: int = 3codebook_size: int = 1024codebook_dim: int = 64initializer_range: float = 0.02acoustic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonesemantic_sample_rate: int = 16000downsample_factor: int = 320 )
Paramètres
- target_bandwidths (
List[float], facultatif, par défaut[0.5, 1, 1.5, 2]) — La plage de différentes largeurs de bande (en kbps) avec lesquelles le modèle peut encoder l'audio. - sample_rate (
int, facultatif, par défaut24000) — Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz). - kernel_size (
int, facultatif, valeur par défaut 3) — Taille du noyau pour la convolution sémantique initiale. - channel_ratios (
List[float], facultatif, par défaut[1, 1]) — Facteurs d'expansion du nombre de canaux de sortie dans chaque bloc sémantique. - strides (
List[int], facultatif, par défaut[1, 1]) — Pas pour chaque bloc d'encodeur sémantique. - block_dilations (
List[int], facultatif, par défaut[1, 1]) — Facteurs de dilatation pour les unités résiduelles dans les blocs sémantiques. - unit_kernel_size (
int, facultatif, valeur par défaut 3) — Taille du noyau à l'intérieur de chaque ResidualUnit des blocs sémantiques. - codebook_size (
int, facultatif, par défaut1024) — Le nombre de codebooks parallèles utilisés par le modèle. - codebook_dim (
int, facultatif, par défaut64) — Dimension de chaque vecteur d'embedding du codebook. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - acoustic_model_config (
Union[Dict, AutoConfig], facultatif) — Une instance de la configuration du modèle acoustique (DAC). - semantic_model_config (
Union[Dict, AutoConfig], facultatif) — Une instance de l'objet de configuration du modèle sémantique (HuBERT). - semantic_sample_rate (
int, facultatif, valeur par défaut 16000) — La fréquence d'échantillonnage à laquelle le modèle sémantique s'attend à recevoir l'entrée audio, en hertz (Hz). - downsample_factor (
int, facultatif, valeur par défaut 320) — Facteur de sous-échantillonnage pour les caractéristiques sémantiques.
Ceci est la classe de configuration destinée à stocker la configuration d'un HiggsAudioV2TokenizerModel. Elle est utilisée pour instancier un modèle Higgs Audio V2 Tokenizer en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de bosonai/higgs-audio-v2-tokenizer
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 HiggsAudioV2TokenizerModel, HiggsAudioV2TokenizerConfig
>>> # Initializing configuration
>>> configuration = HiggsAudioV2TokenizerConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = HiggsAudioV2TokenizerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configHiggsAudioV2TokenizerModel
classe transformers.HiggsAudioV2TokenizerModel
< source >( config: HiggsAudioV2TokenizerConfig )
Paramètres
- config (HiggsAudioV2TokenizerConfig) — 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 de codec audio neuronal HiggsAudioV2Tokenizer.
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.
décoder
< source >( audio_codes: Tensorreturn_dict: bool | None = None )
Paramètres
- audio_codes (
torch.LongTensorde forme(batch_size, num_quantizers, codes_length)) — Indices de codes discrets calculés à l'aide demodel.encode. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput
encode
< source >( input_values: Tensorbandwidth: float | None = Nonereturn_dict: bool | None = None )
Paramètres
- input_values (
torch.Tensorde forme(batch_size, channels, num_samples)) — Valeurs flottantes de la forme d'onde audio d'entrée. - bandwidth (
float, facultatif) — La bande passante cible en (kbps) ne prend en charge que les valeurs deconfig.target_bandwidths. Par défaut, la bande passante disponible la plus élevée, soit4.0kbps. - return_dict (
bool, facultatif) — Indique s'il faut ou non retourner un ModelOutput.
forward
< source >( input_values: Tensoraudio_codes: typing.Optional[torch.Tensor] = Nonebandwidth: float | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → HiggsAudioV2TokenizerOutput or tuple (audio_codes, audio_values)
Paramètres
- input_values (
torch.Tensorde forme(batch_size, channels, num_samples)) — Les valeurs flottantes brutes de la forme d'onde audio d'entrée. - audio_codes (
torch.LongTensorde forme(batch_size, num_quantizers, codes_length)— Indices de codes discrets calculés à l'aide demodel.encode. - bandwidth (
float, facultatif) — Bande passante cible en kbps. Doit être l’une des valeurs deconfig.target_bandwidths. Par défaut, la bande passante disponible la plus élevée est utilisée. - bandwidth (
float, facultatif) — Bande passante cible en kbps. Doit être l’une des valeurs deconfig.target_bandwidths. Par défaut, la bande passante disponible la plus élevée est utilisée.
Retourne
HiggsAudioV2TokenizerOutput ou tuple (audio_codes, audio_values)
audio_codesde forme(batch_size, num_quantizers, codes_length): les codes discrets quantifiés.audio_valuesde forme(batch_size, channels, num_samples): la forme d’onde audio reconstruite à partir des codes.
La méthode forward du modèle HiggsAudioV2TokenizerModel 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.
Exemple :
>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, HiggsAudioV2TokenizerModel
>>> model_id = "hf-audio/higgs_audio_v2_tokenizer-hubert-librispeech"
>>> model = HiggsAudioV2TokenizerModel.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> audio_sample = dataset[0]['audio']['array']
>>> inputs = feature_extractor(raw_audio=audio_sample, return_tensors="pt")
>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values