Hugging Face's logo

Transformers documentation

Mimi

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2024-09-18.

FlashAttention SDPA

Mimi

Mimi est un modèle de codec audio neuronal doté de variantes préentraînées et quantifiées, conçu pour une représentation et une compression efficaces de la parole. Le modèle fonctionne à 1,1 kbps avec un taux de trame de 12 Hz et utilise une architecture encodeur-décodeur convolutif combinée à un quantificateur vectoriel résiduel de 16 livres de codes. Mimi génère des flux de jetons doubles, à savoir sémantiques et acoustiques, afin d’équilibrer la richesse linguistique et la reconstruction haute fidélité. Ses principales fonctionnalités incluent un encodeur de flux causal pour une utilisation à faible latence, une tokenisation à double voie pour une génération en aval flexible, et une intégration prête à l’emploi avec de grands modèles de parole tels que Moshi.

Vous pouvez trouver les points de contrôle originaux de Mimi sous l'organisation Kyutai.

Ce modèle a été contribué par ylacombe.

Cliquez sur les modèles Mimi dans la barre latérale droite pour plus d'exemples sur la façon d'appliquer Mimi.

L'exemple ci-dessous montre comment encoder et décoder de l'audio avec la classe AutoModel.

AutoModel
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, MimiModel


librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

# load model and feature extractor
model = MimiModel.from_pretrained("kyutai/mimi", device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/mimi")

# load audio sample
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
audio_values = model.decode(encoder_outputs.audio_codes, inputs["padding_mask"])[0]
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values

MimiConfig

classe transformers.MimiConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Paramètres

  • sampling_rate (int, facultatif, par défaut 24000) — Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).
  • audio_channels (int, facultatif, valeur par défaut 1) — Nombre de canaux dans les données audio. Soit 1 pour le mono, soit 2 pour le stéréo.
  • hidden_size (int, facultatif, par défaut 512) — Dimension des représentations cachées.
  • num_filters (int, facultatif, par défaut 64) — Nombre de noyaux de convolution de la première couche de sous-échantillonnage MimiConv1d.
  • num_residual_layers (int, facultatif, par défaut 1) — Nombre de couches résiduelles.
  • upsampling_ratios (Sequence[int], facultatif) — Rapports de taille de noyau et de pas. L’encodeur utilise des rapports de rétrécissement au lieu de rapports d’agrandissement, il utilisera donc les rapports dans l’ordre inverse de ceux spécifiés ici, qui doivent correspondre à l’ordre du décodeur. Si non spécifié, la valeur par défaut est [8, 6, 5, 4]
  • kernel_size (int, facultatif, par défaut 7) — La taille du noyau de convolution.
  • last_kernel_size (int, facultatif, valeur par défaut 3) — Taille du noyau pour la dernière couche de convolution.
  • residual_kernel_size (int, facultatif, valeur par défaut 3) — Taille du noyau pour les couches résiduelles.
  • dilation_growth_rate (int, facultatif, valeur par défaut 2) — Facteur d'augmentation de la dilatation à chaque couche.
  • use_causal_conv (bool, facultatif, par défaut True) — Indique s'il faut utiliser une convolution entièrement causale.
  • pad_mode (str, facultatif, par défaut "constant") — Mode de bourrage pour les convolutions.
  • compress (int, facultatif, par défaut 2) — Dimension réduite dans les branches résiduelles.
  • trim_right_ratio (float, facultatif, valeur par défaut 1.0) — Ratio de rognage à droite de la convolution transposée dans la configuration use_causal_conv = True. S'il est égal à 1.0, cela signifie que tout le rognage est effectué à droite.
  • codebook_size (int, facultatif, par défaut 2048) — Le nombre de codebooks parallèles utilisés par le modèle.
  • codebook_dim (int, facultatif, par défaut 256) — Dimension de chaque vecteur d'embedding du codebook.
  • num_quantizers (int, facultatif, valeur par défaut 32) — Nombre de canaux de quantificateur, ou de codebooks, dans le quantificateur.
  • use_conv_shortcut (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser une couche de convolution comme connexion de « saut » dans le bloc MimiResnetBlock. Si la valeur est False, une fonction identité est utilisée, ce qui donne une connexion résiduelle générique.
  • vector_quantization_hidden_dimension (int, facultatif, valeur par défaut 256) — Dimension de la représentation intermédiaire dans l'espace de quantification vectorielle résiduelle.
  • num_semantic_quantizers (int, facultatif, valeur par défaut 1) — Nombre de canaux de quantificateur sémantique, ou de codebooks, dans le quantificateur sémantique. Doit être inférieur à num_quantizers.
  • upsample_groups (int, facultatif, valeur par défaut 512) — Si frame_rate!=encodec_frame_rate, indique le nombre de groupes utilisés dans l'opération de suréchantillonnage pour passer d'un taux à l'autre.
  • num_hidden_layers (int, facultatif, par défaut 8) — Nombre de couches cachées dans le décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 2048) — Dimension des représentations du MLP.
  • num_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_key_value_heads (int, facultatif, valeur par défaut 8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si num_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), si num_key_value_heads=1 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera num_attention_heads.
  • head_dim (int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, facultatif, par défaut 8000) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • norm_eps (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • use_cache (bool, facultatif, valeur par défaut False) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • use_streaming (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser le mode streaming. Si True, la méthode d'encodage du modèle renverra le cache de bourrage qui peut être utilisé lors d'un appel ultérieur à la méthode d'encodage.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.
  • sliding_window (int, facultatif, par défaut 250) — Taille de la fenêtre d'attention glissante. Si None, aucune fenêtre glissante n'est appliquée.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • layer_scale_initial_scale (float, facultatif, par défaut 0.01) — É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.
  • attention_bias (bool, facultatif, par défaut False) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un MimiModel. Elle est utilisée pour instancier un modèle Mimi 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 kyutai/mimi

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 MimiModel, MimiConfig

>>> # Initializing a "kyutai/mimi" style configuration
>>> configuration = MimiConfig()

>>> # Initializing a model (with random weights) from the "kyutai/mimi" style configuration
>>> model = MimiModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MimiEncoderConfig

classe transformers.MimiEncoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Configuration de la moitié encodeur de Mimi (encodeur SEANet, transformeur encodeur et sous-échantillonnage). Il partage tous les champs avec MimiConfig (voir sa documentation pour les arguments), il peut donc être chargé directement à partir d'un point de contrôle Mimi complet.

MimiDecoderConfig

classe transformers.MimiDecoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Configuration de la moitié décodeur de Mimi (remontée en échantillonnage, transformateur décodeur et décodeur SEANet). Elle partage tous les champs avec MimiConfig (voir sa documentation pour les arguments), elle peut donc être chargée directement depuis un point de contrôle Mimi complet.

MimiModel

classe transformers.MimiModel

< >

( config: MimiConfig )

Paramètres

  • config (MimiConfig) — 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 Mimi.

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

< >

( audio_codes: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonedecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Décode les trames données en une forme d’onde audio de sortie : les codes sont déquantifiés en latents de MimiDecoderModel.forward().

encode

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonenum_quantizers: float | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Encode la forme d’onde audio d’entrée en codes discrets de forme (batch_size, num_quantizers, frames) : les latents de MimiEncoderModel.forward(), quantifiés.

forward

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonenum_quantizers: int | None = Noneaudio_codes: typing.Optional[torch.Tensor] = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonedecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiOutput or tuple(torch.Tensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, channels, sequence_length), facultatif) — Entrée audio brute convertie en Float.
  • padding_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indique quelles entrées doivent être ignorées en raison du bourrage, où les éléments sont soit 1 pour non masqué soit 0 pour masqué.
  • num_quantizers (int, facultatif) — Nombre de quantificateurs (c.-à-d. de codebooks) à utiliser. Par défaut, tous les quantificateurs sont utilisés.
  • audio_codes (torch.LongTensor de forme (batch_size, num_quantizers, codes_length), facultatif) — Incrustations de codes discrets calculées à l'aide de model.encode.
  • encoder_past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés pour accélérer le décodage séquentiel du transformeur encodeur. Cela consiste généralement en les past_key_values retournés par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

  • decoder_past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés pour accélérer le décodage séquentiel du transformeur décodeur. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

Retourne

MimiOutput ou tuple(torch.Tensor)

Un MimiOutput 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 (MimiConfig) et des entrées.

La méthode forward du MimiModel 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 Module plutô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.

  • audio_codes (torch.LongTensor de forme (batch_size, num_quantizers, codes_length), facultatif) — Incrustations de codes discrets calculées à l'aide de model.encode.

  • audio_values (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Valeurs audio décodées, obtenues à l’aide de la partie décodeur de Mimi.

  • encoder_past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés pour accélérer le décodage séquentiel du transformeur encodeur. Cela consiste généralement en past_key_values retournés par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

  • decoder_past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés pour accélérer le décodage séquentiel du transformeur décodeur. Cela consiste généralement en past_key_values retournés par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

Exemples :

>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, MimiModel

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model_id = "kyutai/mimi"
>>> model = MimiModel.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> inputs = feature_extractor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values

MimiEncoderModel

classe transformers.MimiEncoderModel

< >

( config: MimiEncoderConfig )

Paramètres

  • config (MimiEncoderConfig) — 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.

La moitié encodeur de Mimi : encodeur SEANet, transformeur encodeur et sous-échantillonnage, de l’audio aux latents 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.

forward

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiEncoderModelOutput or tuple(torch.Tensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, channels, sequence_length)) — Valeurs flottantes de la forme d'onde audio d'entrée.
  • padding_mask (torch.Tensor de forme (batch_size, channels, sequence_length), facultatif) — Indique quelles entrées doivent être ignorées en raison du bourrage, où les éléments sont soit 1 pour non masqué soit 0 pour masqué.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur encodeur, utilisés pour accélérer l'encodage en flux.
  • padding_cache (MimiConv1dPaddingCache, facultatif) — Cache de bourrage des convolutions causales, utilisé pour l’encodage en flux.
  • use_streaming (bool, facultatif) — Indique s'il faut encoder en mode streaming, en renvoyant les caches à passer à l'appel suivant.
  • Encodes la forme d'onde audio d'entrée en latents continus de forme (batch_size, latent_dim, frames). —

Retourne

MimiEncoderModelOutput ou tuple(torch.Tensor)

Un MimiEncoderModelOutput 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 (MimiConfig) et des entrées.

La méthode forward du modèle MimiEncoderModel 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 Module plutô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.

  • latents (torch.Tensor de forme (batch_size, latent_dim, frames)) — Latents continus de l'audio, une trame par config.frame_size échantillons audio.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur encodeur, renvoyés lors du streaming.
  • padding_cache (MimiConv1dPaddingCache, facultatif) — Cache de bourrage pour les convolutions causales MimiConv1d afin de prendre en charge le streaming via le bourrage du cache.
  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True) — États cachés du transformeur encodeur à la sortie de chaque couche ainsi que son entrée.
  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de chaque couche du transformeur encodeur.

MimiDecoderModel

classe transformers.MimiDecoderModel

< >

( config: MimiDecoderConfig )

Paramètres

  • config (MimiDecoderConfig) — 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.

La moitié décodeur de Mimi : suréchantillonnage, transformeur décodeur et décodeur SEANet, des latents continus à l'audio.

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

< >

( latents: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiDecoderOutput or tuple(torch.Tensor)

Paramètres

  • latents (torch.Tensor de forme (batch_size, hidden_size, frames)) — Latents continus à décoder, tels que calculés par MimiModel.decode().
  • padding_mask (torch.Tensor de forme (batch_size, channels, sequence_length), facultatif) — Indique quelles entrées doivent être ignorées en raison du bourrage, où les éléments sont soit 1 pour non masqué soit 0 pour masqué.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur décodeur, utilisés pour accélérer le décodage en flux.
  • Decodes les images données en une forme d'onde audio de sortie. Notez que la sortie peut être légèrement plus grande que la —
  • input. Dans ce cas, les étapes supplémentaires à la fin peuvent être supprimées. —

Retourne

MimiDecoderOutput ou tuple(torch.Tensor)

Un MimiDecoderOutput 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 (MimiConfig) et des entrées.

La méthode forward du modèle MimiDecoderModel 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 Module plutô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.

  • audio_values (torch.Tensor de forme (batch_size, audio_channels, num_samples), facultatif) — Valeurs audio décodées, obtenues à l’aide de la partie décodeur de Mimi.

  • decoder_past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés pour accélérer le décodage séquentiel du transformeur décodeur. Cela consiste généralement en past_key_values retournés par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True) — États cachés du transformeur décodeur à la sortie de chaque couche ainsi que son entrée.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de chaque couche du transformeur décodeur.

Update on GitHub

←LASR MMS→