# Moshi

## Aperçu

Le modèle Moshi a été proposé dans [Moshi: a speech-text foundation model for real-time dialogue](https://huggingface.co/papers/2410.00037) par Alexandre Défossez, Laurent Mazaré, Manu Orsini, Amélie Royer, Patrick Pérez, Hervé Jégou, Edouard Grave et Neil Zeghidour.

Moshi est un modèle de fondation pour le texte et la parole qui conçoit le dialogue oral comme une génération de parole à parole. À partir d’un squelette de modèle de langage textuel, Moshi génère la parole sous forme de jetons issus du quantificateur résiduel d’un codec audio neuronal, tout en modélisant séparément sa propre parole et celle de l’utilisateur dans des flux parallèles. Cela permet de supprimer les tours de parole explicites et de modéliser des dynamiques conversationnelles arbitraires. Moshi prédit également des jetons de texte alignés dans le temps comme préfixe aux jetons audio. Cette méthode « Inner Monologue » améliore considérablement la qualité linguistique de la parole générée et fournit une reconnaissance vocale en flux et une synthèse vocale. En conséquence, Moshi est le premier grand modèle de langage oral full-duplex en temps réel, avec une latence théorique de 160 ms, et de 200 ms en pratique.

L'abstract de l'article est le suivant :

*Nous présentons Moshi, un modèle de fondation pour le texte-parlé et un cadre de dialogue oral en duplex intégral. Les systèmes actuels de dialogue oral reposent sur des pipelines de composants indépendants, à savoir la détection d’activité vocale, la reconnaissance vocale, le dialogue textuel et la synthèse vocale. De tels cadres ne peuvent pas reproduire l’expérience d’une conversation réelle. D’une part, leur complexité induit une latence de plusieurs secondes entre les interactions. D’autre part, le texte étant la modalité intermédiaire du dialogue, les informations non linguistiques qui modifient le sens — telles que l’émotion ou les sons non vocaux — sont perdues lors de l’interaction. Enfin, ils reposent sur une segmentation en tours de parole, qui ne prend pas en compte les chevauchements de parole, les interruptions et les interjections. Moshi résout ces problèmes indépendants de manière globale en formulant le dialogue oral comme une génération de parole à partir de la parole. À partir d’un socle de modèle de langage textuel, Moshi génère la parole sous forme de jetons issus du quantificateur résiduel d’un codec audio neuronal, tout en modélisant séparément sa propre parole et celle de l’utilisateur dans des flux parallèles. Cela permet de supprimer les tours de parole explicites et de modéliser des dynamiques conversationnelles arbitraires. Nous étendons en outre la génération hiérarchique de jetons sémantiques à acoustiques du travail précédent afin de prédire d’abord des jetons de texte alignés dans le temps comme préfixe aux jetons audio. Non seulement cette méthode « Inner Monologue » améliore considérablement la qualité linguistique de la parole générée, mais nous illustrons également comment elle peut fournir la reconnaissance vocale en flux et la synthèse vocale. Notre modèle résultant est le premier grand modèle de langage oral en duplex intégral en temps réel, avec une latence théorique de 160 ms, 200 ms en pratique, et est disponible sur github.com/kyutai-labs/moshi.*

Moshi gère 3 flux d'informations :

1. L'audio de l'utilisateur
2. L'audio de Moshi
3. Sortie textuelle de Moshi

De manière similaire à [~MusicgenModel](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenModel), l'audio est représenté par des codebooks audio, qui peuvent être interprétés comme des jetons. La principale différence entre les jetons de texte et les codebooks audio est que les codebooks audio introduisent une dimension d'information supplémentaire. Les jetons de texte sont généralement de dimension `(batch_size, sequence_length)`, tandis que les jetons audio sont de dimension `(batch_size, num_codebooks, sequence_length)`.

Moshi est composé de 3 composants :

**1. Le décodeur principal (Helium dans l'article)**

Il correspond à [MoshiForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForCausalLM). Il s'agit strictement d'un LLM de texte classique, qui utilise une architecture similaire à celle de [~GemmaForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/gemma#transformers.GemmaForCausalLM). Autrement dit, il prend des jetons de texte, les encode, les fait passer par le décodeur et une tête de langage, afin d'obtenir des logits de texte.

**2. Le décodeur de profondeur**

À lui seul, c'est aussi un LLM classique, mais cette fois, au lieu de générer sur la dimension temporelle, il génère sur la dimension du codebook.

Cela signifie également que sa longueur de contexte est `num_codebooks`, il ne peut donc pas générer plus de `num_codebooks`.

Notez que chaque horodatage - c'est-à-dire chaque codebook - possède son propre ensemble de Linear Layers et d'Embeddings.

**3. [MimiModel](/docs/transformers/v5.23.0/fr/model_doc/mimi#transformers.MimiModel)**

Il s'agit de l'encodeur audio de Kyutai, récemment intégré à Transformers, qui sert à « tokeniser » l'audio. Il remplit la même fonction que [~EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel) dans [~MusicgenModel](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenModel).

## Astuces

Les points de contrôle d'origine peuvent être convertis à l'aide du script de conversion `src/transformers/models/moshi/convert_moshi_transformers.py`

### Comment utiliser le modèle

Cette implémentation poursuit deux objectifs principaux :

1. tester rapidement la génération d'un modèle en simplifiant l'API d'origine
2. simplifier l’entraînement. Un guide d’entraînement sera bientôt disponible, mais les contributions des utilisateurs sont les bienvenues !

Elle est conçue pour un usage intermédiaire. Nous recommandons vivement d'utiliser l'[implémentation](https://github.com/kyutai-labs/moshi) originale pour inférer le modèle en streaming en temps réel.

**1. Génération du modèle**

Moshi est un modèle auto-régressif en streaming doté de deux flux audio. Autrement dit, un flux audio correspond à ce que le modèle a dit/ira dire et l'autre flux audio correspond à ce que l'utilisateur a dit/ira dire.

[MoshiForConditionalGeneration.generate()](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForConditionalGeneration.generate) nécessite donc 3 entrées :

1. `input_ids` - correspondant à l'historique des jetons de texte
2. `moshi_input_values` ou `moshi_audio_codes` - correspondant à l'historique audio du modèle
3. `user_input_values` ou `user_audio_codes` - correspondant à l'historique audio de l'utilisateur

Ces trois entrées doivent être synchronisées. Autrement dit, leurs longueurs doivent correspondre au même nombre de jetons.

Vous pouvez utiliser dynamiquement les 3 entrées en fonction de ce que vous souhaitez tester :

1. Il suffit de vérifier la réponse du modèle à un prompt utilisateur : dans ce cas, `input_ids` peut être rempli de jetons de bourrage et `user_input_values` peut être un tenseur nul de la même forme que le prompt utilisateur.
2. Tester un comportement plus complexe - dans ce cas, vous devez faire attention à la manière dont les jetons d'entrée sont synchronisés avec les audios.

Le modèle original est un texte synchronisé avec l'audio en ajoutant des espaces de remplissage entre chaque énonciation de jeton.

Pour suivre l'exemple de l'image ci-dessous, `"Hello, I'm Moshi"` pourrait être transformé en `"Hello,<pad><unk>I'm Moshi"`.

[MoshiForConditionalGeneration.generate()](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForConditionalGeneration.generate) alimente ensuite de manière auto-régressive son propre flux audio, mais comme il n'a pas accès au flux d'entrée de l'utilisateur lors de l'utilisation de `transformers`, il **suppose donc que l'utilisateur produit un audio vide**.

```python
import math

import torch
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, AutoTokenizer

librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/moshiko-pytorch-bf16")
tokenizer = AutoTokenizer.from_pretrained("kyutai/moshiko-pytorch-bf16")
dtype = torch.bfloat16

# prepare user input audio
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
user_input_values = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(device=device, dtype=dtype)

# prepare moshi input values - we suppose moshi didn't say anything while the user spoke
moshi_input_values = torch.zeros_like(user_input_values.input_values)

# prepare moshi input ids - we suppose moshi didn't say anything while the user spoke
num_tokens = math.ceil(moshi_input_values.shape[-1] * waveform_to_token_ratio)
input_ids = torch.ones((1, num_tokens), device=device, dtype=torch.int64) * tokenizer.encode("<pad>")[0]

# generate 25 new tokens (around 2s of audio)
output = model.generate(input_ids=input_ids, user_input_values=user_input_values.input_values, moshi_input_values=moshi_input_values, max_new_tokens=25)

text_tokens = output.sequences
audio_waveforms = output.audio_sequences
```

**2. Entraînement du modèle**

La majeure partie du travail doit être effectuée lors de la création/prétraitement des données, en raison de la nécessité d’aligner/synchroniser les flux.

Une fois terminé, il suffit de transmettre `text_labels` et `audio_labels` à [MoshiForConditionalGeneration.forward()](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForConditionalGeneration.forward), en plus des entrées habituelles, pour obtenir la perte du modèle.

Un guide d'entraînement sera bientôt disponible, mais les contributions des utilisateurs sont les bienvenues !

### Comment le modèle transmet-il les entrées / génère

1. Les flux d'entrée sont intégrés et combinés dans `inputs_embeds`.

2. `inputs_embeds` est transmis au décodeur principal, qui le traite comme un LLM classique le ferait.

3. Le décodeur principal produit des `text logits` mais aussi son `last hidden state`, appelé `temporal context` dans l'article.

3. Le décodeur de profondeur bascule la dimension sur laquelle nous effectuons le passage avant / la génération (les codebooks au lieu du temps). Il utilise le jeton généré à partir des `text logits` et du `temporal context` pour générer de manière auto-régressive les codebooks audio.

Ce modèle a été contribué par [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe).

Le code original peut être trouvé [ici](https://github.com/kyutai-labs/moshi).

## MoshiConfig[[transformers.MoshiConfig]]

#### transformers.MoshiConfig[[transformers.MoshiConfig]]

```python
transformers.MoshiConfig(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, vocab_size: int = 32000, hidden_size: int = 4096, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int | None = None, audio_vocab_size: int | None = None, max_position_embeddings: int = 3000, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, hidden_act: str = 'silu', head_dim: int | None = None, initializer_range: float = 0.02, use_cache: bool = True, sliding_window: int = 3000, attention_dropout: float | int = 0.0, ffn_dim: int = 22528, rms_norm_eps: float = 1e-08, num_codebooks: int = 8, tie_word_embeddings: bool = False, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, audio_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, depth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/configuration_moshi.py#L93)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `32000`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `32`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `32`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*) : C'est le nombre de têtes de key_value à utiliser pour implémenter l'attention par requêtes groupées (Grouped Query Attention). Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention multi-têtes (Multi Head Attention, MHA) ; si `num_key_value_heads=1`, il utilisera l'attention multi-requête (Multi Query Attention, MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête de clé et de valeur du 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`.

audio_vocab_size (`int`, *facultatif*) : Taille du vocabulaire de la partie audio du modèle. Définit le nombre de jetons différents qui peuvent être représentés par les `audio_codes` passés lors de l'appel des modèles Moshi.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `3000`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

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.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

head_dim (`int`, *facultatif*) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads

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.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : 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.

sliding_window (`int`, *facultatif*, valeur par défaut `3000`) : 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.

ffn_dim (`int`, *facultatif*, par défaut 22528) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du bloc décodeur principal. Doit être un nombre pair.

rms_norm_eps (`float`, *facultatif*, par défaut `1e-08`) : L'épsilon utilisé par les couches de normalisation rms.

num_codebooks (`int`, *facultatif*, valeur par défaut `8`) : Le nombre de codebooks parallèles utilisés par le modèle.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

audio_encoder_config (`PreTrainedConfig | dict`, *facultatif*) : Configuration de l'encodeur audio.

depth_decoder_config (`PreTrainedConfig | dict`, *facultatif*) : Configuration du décodeur de profondeur.

Ceci est la classe de configuration destinée à stocker la configuration d'un MoshiModel. Elle est utilisée pour instancier un modèle Moshi 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 [kmhf/hf-moshika](https://huggingface.co/kmhf/hf-moshika)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import (
...     MoshiConfig,
...     MoshiForConditionalGeneration,
... )

>>> configuration = MoshiConfig()

>>> # Initializing a MoshiForConditionalGeneration (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiForConditionalGeneration(configuration)

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

>>> # Saving the model, including its configuration
>>> model.save_pretrained("kmhf/hf-moshika")

>>> # loading model and config from pretrained folder
>>> moshi_config = MoshiConfig.from_pretrained("kmhf/hf-moshika")
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika", config=moshi_config)
```

#### from_audio_encoder_config[[transformers.MoshiConfig.from_audio_encoder_config]]

```python
from_audio_encoder_config(audio_encoder_config: PreTrainedConfig, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/configuration_moshi.py#L199)

**Retourne :** [MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)

Une instance d'un objet de configuration

Instanciez un [MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig) (ou une classe dérivée) à partir d'une configuration d'encodeur audio.

## MoshiDepthConfig[[transformers.MoshiDepthConfig]]

#### transformers.MoshiDepthConfig[[transformers.MoshiDepthConfig]]

```python
transformers.MoshiDepthConfig(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, vocab_size: int = 32000, hidden_size: int = 1024, input_size: int = 4096, num_hidden_layers: int = 6, num_attention_heads: int = 16, num_key_value_heads: int | None = None, audio_vocab_size: int = 2048, max_position_embeddings: int = 9, hidden_act: str = 'silu', head_dim: int | None = None, initializer_range: float = 0.02, use_cache: bool = True, sliding_window: int = 8, attention_dropout: float | int = 0.0, ffn_dim: int = 5632, rms_norm_eps: float = 1e-08, num_codebooks: int = 8, tie_word_embeddings: bool = False, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/configuration_moshi.py#L26)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `32000`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

input_size (`int`, *facultatif*, valeur par défaut 4096) : Dimension des états cachés d'entrée. Utilisé pour connecter le décodeur principal au décodeur de profondeur.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*) : C'est le nombre de têtes de key_value à utiliser pour implémenter l'attention par requêtes groupées (Grouped Query Attention). Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention multi-têtes (Multi Head Attention, MHA) ; si `num_key_value_heads=1`, il utilisera l'attention multi-requête (Multi Query Attention, MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête de clé et de valeur du 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`.

audio_vocab_size (`int`, *facultatif*, valeur par défaut 2048) : Taille du vocabulaire de la partie audio du modèle. Définit le nombre de jetons différents qui peuvent être représentés par les `audio_codes` passés lors de l'appel des modèles Moshi.

max_position_embeddings (`int`, *facultatif*, par défaut `9`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

head_dim (`int`, *facultatif*) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads

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.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : 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.

sliding_window (`int`, *facultatif*, valeur par défaut `8`) : 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.

ffn_dim (`int`, *facultatif*, valeur par défaut 5632) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du bloc du décodeur de profondeur. Doit être un nombre pair.

rms_norm_eps (`float`, *facultatif*, par défaut `1e-08`) : L'épsilon utilisé par les couches de normalisation rms.

num_codebooks (`int`, *facultatif*, valeur par défaut `8`) : Le nombre de codebooks parallèles utilisés par le modèle.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

Ceci est la classe de configuration destinée à stocker la configuration d'un MoshiModel. Elle est utilisée pour instancier un modèle Moshi 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 [kmhf/hf-moshika](https://huggingface.co/kmhf/hf-moshika)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import (
...     MoshiDepthConfig,
...     MoshiDepthDecoder,
... )

>>> configuration = MoshiDepthConfig()

>>> # Initializing a MoshiDepthDecoder (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiDepthDecoder(configuration)

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

## MoshiModel[[transformers.MoshiModel]]

#### transformers.MoshiModel[[transformers.MoshiModel]]

```python
transformers.MoshiModel(config: MoshiConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L735)

**Paramètres :**

config ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Moshi brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.MoshiModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L754)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. 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`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) et les entrées.

La méthode forward du [MoshiModel](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiModel) 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.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## MoshiForCausalLM[[transformers.MoshiForCausalLM]]

#### transformers.MoshiForCausalLM[[transformers.MoshiForCausalLM]]

```python
transformers.MoshiForCausalLM(config: MoshiConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L807)

**Paramètres :**

config ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle décodeur Moshi avec une tête de modélisation de langage textuel en haut. Utilisable uniquement pour le texte.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.MoshiForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L820)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. 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`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage causale. Les indices doivent être dans `[-100, 0, ..., config.vocab_size]` (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans `[0, ..., config.vocab_size]`. Les étiquettes sont **décalées en interne** de sorte que `labels[..., 1:]` sont utilisés pour prédire `logits[..., :-1, :]`. Transmettez des étiquettes non décalées correspondant à `input_ids` (c'est-à-dire `labels = input_ids`). Ne **décalez pas** vous-même les étiquettes avant de les transmettre. Si les étiquettes sont déjà décalées (par exemple avec le parallélisme de séquence), transmettez-les en tant qu'argument mot-clé `shift_labels` et elles seront utilisées telles quelles. Il faut toujours transmettre `labels` pour que la perte soit calculée.

logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

**Retourne :** `MoshiCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Un `MoshiCausalLMOutputWithPast` 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 ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) et les entrées.

La méthode forward de [MoshiForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForCausalLM) 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.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoTokenizer, MoshiForCausalLM

>>> model = MoshiForCausalLM.from_pretrained("kmhf/hf-moshika")
>>> tokenizer = AutoTokenizer.from_pretrained("kmhf/hf-moshika")

>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"
```

## MoshiForConditionalGeneration[[transformers.MoshiForConditionalGeneration]]

#### transformers.MoshiForConditionalGeneration[[transformers.MoshiForConditionalGeneration]]

```python
transformers.MoshiForConditionalGeneration(config: MoshiConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L884)

**Paramètres :**

config ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Moshi d'origine, avec un encodeur audio, un décodeur de profondeur Moshi et un décodeur Moshi, pour la conversion de la parole en parole.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.MoshiForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, user_input_values: typing.Optional[torch.Tensor] = None, user_audio_codes: typing.Optional[torch.Tensor] = None, moshi_input_values: typing.Optional[torch.Tensor] = None, moshi_audio_codes: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, text_labels: typing.Optional[torch.LongTensor] = None, audio_labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L911)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

user_input_values (`torch.Tensor `de forme `(batch_size, 1, audio_sequence_length), *facultatif*) : Les formes d'onde audio utilisées comme invite utilisateur audio pour la génération.

user_audio_codes (`torch.Tensor `of shape `(batch_size, num_codebooks, sequence_length), *optional*) : The audio codes used as audio user prompt for the generation. Has priority over `user_input_values` and represents the audio "tokens" of `user_input_values` once passed through the audio encoder.

moshi_input_values (`torch.Tensor `de forme `(batch_size, 1, audio_sequence_length), *facultatif*) : Les formes d'onde audio utilisées comme invite audio Moshi pour la génération.

moshi_audio_codes (`torch.Tensor `of shape `(batch_size, num_codebooks, sequence_length), *optional*) : The audio codes used as audio Moshi prompt for the generation. Has priority over `moshi_input_values` and represents the audio "tokens" of `moshi_input_values` once passed through the audio encoder.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. 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`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la façon de convertir les indices `input_ids` en vecteurs associés que la matrice de recherche d'intégration interne du modèle. Si `input_ids` et `inputs_embeds` sont tous deux non définis, `inputs_embeds` prend la valeur de `inputs_embeds`.

text_labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le modélisation de langage sur le texte. Notez que les étiquettes **sont décalées** à l'intérieur du modèle, c'est-à-dire que vous pouvez définir `labels = input_ids` Les indices sont sélectionnés dans `[-100, 0, ..., config.vocab_size]` Toutes les étiquettes définies sur `-100` sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans `[0, ..., config.vocab_size]`

audio_labels (`torch.LongTensor` de forme `(batch_size, num_codebooks, sequence_length)`, *facultatif*) : Étiquettes pour le modélisation du langage. Notez que les étiquettes **sont décalées** à l'intérieur du modèle, c'est-à-dire que vous pouvez définir `labels = input_ids` Les indices sont sélectionnés dans `[-100, 0, ..., config.vocab_size]` Toutes les étiquettes définies sur `-100` sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans `[0, ..., config.audio_vocab_size]`

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** `MoshiConditionalGenerationOutputWithPast` ou `tuple(torch.Tensor)`

Un `MoshiConditionalGenerationOutputWithPast` 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 ([MoshiConfig](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiConfig)) et les entrées.

La méthode forward de [MoshiForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/moshi#transformers.MoshiForConditionalGeneration) 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.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `text_labels` est fourni) -- Perte de modélisation du langage du texte (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage textuel (scores pour chaque jeton du vocabulaire avant SoftMax).
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **depth_loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `audio_labels` est fourni) -- Perte de modélisation du langage audio (pour la prédiction du jeton suivant).
- **audio_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction des têtes de modélisation du langage audio.
- **depth_past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Clés-valeurs passées du décodeur de profondeur.
- **depth_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- États cachés du décodeur de profondeur
- **depth_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Poids des attentions du décodeur de profondeur après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :
```python
>>> from transformers import MoshiForConditionalGeneration
>>> import torch

>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")
>>> inputs = moshi.get_unconditional_inputs()

>>> logits = model(**inputs, ).logits
>>> logits.shape  # (bsz, seq_len, text_vocab_size)
torch.Size([1, 1, 32000])
```

#### generate[[transformers.MoshiForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, user_input_values: typing.Optional[torch.Tensor] = None, user_audio_codes: typing.Optional[torch.Tensor] = None, moshi_input_values: typing.Optional[torch.Tensor] = None, moshi_audio_codes: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, return_audio_waveforms: bool | None = True, return_audio_codes: bool | None = None, concat_unconditional_inputs: bool | None = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L1203)

**Paramètres :**

input_ids (`torch.Tensor `de forme `(batch_size, sequence_length), *facultatif*) : La séquence utilisée comme invite de texte pour la génération.

user_input_values (`torch.Tensor `de forme `(batch_size, 1, audio_sequence_length), *facultatif*) : Les formes d'onde audio utilisées comme invite utilisateur audio pour la génération.

user_audio_codes (`torch.Tensor `of shape `(batch_size, num_codebooks, sequence_length), *optional*) : The audio codes used as audio user prompt for the generation. Has priority over `user_input_values` and represents the audio "tokens" of `user_input_values` once passed through the audio encoder.

moshi_input_values (`torch.Tensor `de forme `(batch_size, 1, audio_sequence_length), *facultatif*) : Les formes d'onde audio utilisées comme invite audio Moshi pour la génération.

moshi_audio_codes (`torch.Tensor `of shape `(batch_size, num_codebooks, sequence_length), *optional*) : The audio codes used as audio Moshi prompt for the generation. Has priority over `moshi_input_values` and represents the audio "tokens" of `moshi_input_values` once passed through the audio encoder.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids` et les entrées audio, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des entrées en vecteurs associés que la matrice de recherche d'intégration interne du modèle.

return_audio_waveforms (`bool`, *facultatif*, par défaut `True`) : Si `False`, les formes d'onde audio ne seront pas générées.

return_audio_codes (`bool`, *facultatif*) : Si `True`, renvoie également les codes audio générés, c'est-à-dire les « tokens » audio intermédiaires qui se transforment en `audio_sequences` une fois passés par le décodeur audio.

concat_unconditional_inputs (`bool`, *facultatif*, valeur par défaut `True`) : Si `False`, les jetons audio et texte initiaux ne seront pas concaténés.

kwargs (`dict[str, Any]`, *facultatif*) : Dictionnaire restant des arguments par mot-clé transmis à la méthode `generate`. Reportez-vous aux [`generate` docstrings](https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate) d’origine pour plus d’informations sur leur utilisation. Notez que les mots-clés préfixés par *depth_* seront utilisés en entrée pour la méthode `generate` du décodeur de profondeur. Sinon, ce dernier utilisera sa configuration de génération par défaut.

**Retourne :**

`MoshiConditionalGenerationGenerateOutput`

Génère des séquences d’identifiants de jetons de texte et d’identifiants de jetons audio.

#### get_unconditional_inputs[[transformers.MoshiForConditionalGeneration.get_unconditional_inputs]]

```python
get_unconditional_inputs(num_samples = 1)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/moshi/modeling_moshi.py#L1632)

**Paramètres :**

num_samples (int, *facultatif*) : Nombre d'échantillons audio à générer inconditionnellement.

max_new_tokens (int, *facultatif*) : Nombre de jetons à générer pour chaque échantillon. Plus il y a de jetons, plus les échantillons audio sont longs, au détriment d'un temps d'inférence plus long (puisque davantage de jetons audio doivent être générés par échantillon).

Fonction utilitaire pour obtenir des entrées nulles pour la génération non conditionnelle, permettant d'utiliser le modèle sans extracteur de caractéristiques ni tokeniseur.

Exemple :
```python
>>> from transformers import MoshiForConditionalGeneration

>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")

>>> # get the unconditional (or 'null') inputs for the model
>>> unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
>>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)
```