# Mimi [Mimi](https://huggingface.co/papers/2410.00037) 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](https://huggingface.co/kyutai/models?search=mimi). >[!TIP] > Ce modèle a été contribué par [ylacombe](https://huggingface.co/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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel). ```python 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[[transformers.MimiConfig]] #### transformers.MimiConfig[[transformers.MimiConfig]] ```python transformers.MimiConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/configuration_mimi.py#L28) **Paramètres :** sampling_rate (`int`, *facultatif*, valeur 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*, valeur 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*) : Ratios de taille de noyau et de pas. L'encodeur utilise des ratios de sous-échantillonnage au lieu de ratios de sur-échantillonnage, il utilisera donc les ratios dans l'ordre inverse de ceux spécifiés ici, qui doivent correspondre à l'ordre du décodeur. S'ils ne sont pas spécifiés, 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) : Amplitude de l'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*, valeur par défaut `"constant"`) : Mode de bourrage pour les convolutions. compress (`int`, *facultatif*, valeur par défaut : 2) : Dimensionnalité 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*, valeur 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 convolutive comme connexion « skip » 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*, valeur par défaut `8`) : Nombre de couches cachées dans le décodeur Transformer. intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations 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`) : C'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`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `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) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *facultatif*, valeur par défaut `8000`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. norm_eps (`float`, *facultatif*, valeur 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). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. use_streaming (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser le mode de streaming. Si `True`, la méthode d'encodage du modèle renverra le cache de bourrage (padding) 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*, valeur par défaut `250`) : Taille de la fenêtre de l'attention à fenêtre 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*, valeur 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*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention. tie_word_embeddings (`bool`, *facultatif*, valeur 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, 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 [kyutai/mimi](https://huggingface.co/kyutai/mimi) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> 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[[transformers.MimiEncoderConfig]] #### transformers.MimiEncoderConfig[[transformers.MimiEncoderConfig]] ```python transformers.MimiEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/configuration_mimi.py#L249) Configuration de la moitié encodeur de Mimi (encodeur SEANet, transformeur encodeur et sous-échantillonnage). Elle partage tous les champs avec [MimiConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiConfig) (voir sa documentation pour les arguments), ce qui permet de la charger directement depuis un point de contrôle Mimi complet. ## MimiDecoderConfig[[transformers.MimiDecoderConfig]] #### transformers.MimiDecoderConfig[[transformers.MimiDecoderConfig]] ```python transformers.MimiDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/configuration_mimi.py#L277) 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](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiConfig) (voir sa documentation pour les arguments), ce qui permet de la charger directement depuis un point de contrôle Mimi complet. ## MimiModel[[transformers.MimiModel]] #### transformers.MimiModel[[transformers.MimiModel]] ```python transformers.MimiModel(config: MimiConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1346) **Paramètres :** config ([MimiConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle de codec audio neuronal Mimi. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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. #### decode[[transformers.MimiModel.decode]] ```python decode(audio_codes: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1430) 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()](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiDecoderModel.forward). #### encode[[transformers.MimiModel.encode]] ```python encode(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, num_quantizers: float | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1394) Encode la forme d’onde audio d’entrée en codes discrets de forme `(batch_size, num_quantizers, frames)` : les latents de [MimiEncoderModel.forward()](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiEncoderModel.forward), quantifiés. #### forward[[transformers.MimiModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, num_quantizers: int | None = None, audio_codes: typing.Optional[torch.Tensor] = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1453) **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. Il s'agit généralement des `past_key_values` renvoyé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 que celui fourni en entrée. Si des `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 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. Il s'agit généralement des `past_key_values` renvoyé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 que celui 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 selon la configuration ([MimiConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiConfig)) et les entrées. La méthode forward du [MimiModel](/docs/transformers/main/fr/model_doc/mimi#transformers.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. Il s'agit généralement des `past_key_values` renvoyé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 dont les états de clés 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. Il s'agit généralement des `past_key_values` renvoyé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 dont les états de clés passées n'ont pas été fournis à ce modèle). Exemples : ```python >>> 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[[transformers.MimiEncoderModel]] #### transformers.MimiEncoderModel[[transformers.MimiEncoderModel]] ```python transformers.MimiEncoderModel(config: MimiEncoderConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1147) **Paramètres :** config ([MimiEncoderConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MimiEncoderModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1208) **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é* ou 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 continu. 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 à transmettre à l'appel suivant. Encode 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 selon la configuration ([MimiConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiConfig)) et les entrées. La méthode forward du modèle [MimiEncoderModel](/docs/transformers/main/fr/model_doc/mimi#transformers.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[[transformers.MimiDecoderModel]] #### transformers.MimiDecoderModel[[transformers.MimiDecoderModel]] ```python transformers.MimiDecoderModel(config: MimiDecoderConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1279) **Paramètres :** config ([MimiDecoderConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MimiDecoderModel.forward]] ```python forward(latents: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mimi/modeling_mimi.py#L1306) **Paramètres :** latents (`torch.Tensor` de forme `(batch_size, hidden_size, frames)`) : Latents continus à décoder, tels que calculés par [MimiModel.decode()](/docs/transformers/main/fr/model_doc/mimi#transformers.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é* ou 0 pour *masqué*. past_key_values (`Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) du transformeur décodeur, utilisés pour accélérer le décodage en flux. Décode les images données en une forme d'onde audio de sortie. Notez que la sortie peut être un peu 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 selon la configuration ([MimiConfig](/docs/transformers/main/fr/model_doc/mimi#transformers.MimiConfig)) et les entrées. La méthode forward du modèle [MimiDecoderModel](/docs/transformers/main/fr/model_doc/mimi#transformers.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. Il s'agit généralement des `past_key_values` renvoyé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 dont les états de clés 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.