# FalconMamba

[FalconMamba](https://huggingface.co/papers/2410.05355) est un grand modèle de langage de 7B, disponible en variantes pré-entraînées et ajustées par instructions, basé sur [Mamba](./mamba). Ce modèle implémente une conception purement Mamba qui se concentre sur l’efficacité computationnelle tout en maintenant de solides performances. FalconMamba est nettement plus rapide à l’inférence et nécessite nettement moins de mémoire pour la génération de séquences longues. Les modèles sont pré-entraînés sur un jeu de données diversifié de 5,8T jetons incluant [RefinedWeb](https://huggingface.co/datasets/tiiuae/falcon-refinedweb), du contenu technique, du code et des données mathématiques.

Vous pouvez trouver les points de contrôle officiels de FalconMamba dans la collection [FalconMamba 7B](https://huggingface.co/collections/tiiuae/falconmamba-7b-66b9a580324dd1598b0f6d4a).

> [!TIP]
> Cliquez sur les modèles FalconMamba dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer FalconMamba à différentes tâches de langage.

Les exemples ci-dessous montrent comment générer du texte avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel) et depuis la ligne de commande.

```python
from transformers import pipeline

pipeline = pipeline(
    "text-generation",
    model="tiiuae/falcon-mamba-7b-instruct",
    device=0
)
pipeline(
    "Explain the difference between transformers and SSMs",
    max_length=100,
    do_sample=True,
    temperature=0.7
)
```

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b-instruct")
model = AutoModelForCausalLM.from_pretrained(
    "tiiuae/falcon-mamba-7b-instruct",
    device_map="auto"
)

input_ids = tokenizer("Explain the difference between transformers and SSMs", return_tensors="pt").to(model.device)

output = model.generate(**input_ids, max_new_tokens=100, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

```bash
transformers chat tiiuae/falcon-mamba-7b-instruct --dtype auto --device 0
```

La quantification réduit la charge mémoire des grands modèles en représentant les poids avec une précision inférieure. Reportez-vous à l'aperçu de la [Quantization](../quantization/overview) pour plus d'informations sur les backends de quantification disponibles.

L'exemple ci-dessous utilise [bitsandbytes](../quantization/bitsandbytes) pour quantiser les poids sur 4 bits.

```python
from transformers import AutoTokenizer, BitsAndBytesConfig, FalconMambaForCausalLM

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = FalconMambaForCausalLM.from_pretrained(
    "tiiuae/falcon-mamba-7b",
    device_map="auto",
    quantization_config=quantization_config,
)

inputs = tokenizer("Explain the concept of state space models in simple terms", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## Notes

- Utilisez le padding à gauche pour la génération par lots. Voir [Padding side](../llm_tutorial#padding-side).

## FalconMambaConfig[[transformers.FalconMambaConfig]]

#### transformers.FalconMambaConfig[[transformers.FalconMambaConfig]]

```python
transformers.FalconMambaConfig(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 = 50280, hidden_size: int = 768, state_size: int = 16, num_hidden_layers: int = 32, layer_norm_epsilon: float = 1e-05, pad_token_id: int | None = 0, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 0, expand: int = 2, conv_kernel: int = 4, use_bias: bool = False, use_conv_bias: bool = True, hidden_act: str = 'silu', initializer_range: float = 0.1, residual_in_fp32: bool = True, time_step_rank: str | int = 'auto', time_step_scale: float = 1.0, time_step_min: float = 0.001, time_step_max: float = 0.1, time_step_init_scheme: str = 'random', time_step_floor: float = 0.0001, rescale_prenorm_residual: bool = False, use_cache: bool = True, use_mambapy: bool = False, use_associative_scan: bool = True, tie_word_embeddings: bool = True, mixer_rms_eps: float = 1e-06)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/configuration_falcon_mamba.py#L30)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `50280`) : 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*, par défaut `768`) : Dimension des représentations cachées.

state_size (`int`, *facultatif*, valeur par défaut `16`) : Taille de l'état SSM (dimension de l'état latent) dans les couches Mamba.

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

layer_norm_epsilon (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

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

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

expand (`int`, *facultatif*, valeur par défaut : 2) : Facteur d'expansion utilisé pour déterminer la taille intermédiaire.

conv_kernel (`int`, *facultatif*, valeur par défaut : 4) : Taille du noyau de convolution.

use_bias (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser un biais dans ["in_proj", "out_proj"] du bloc mixer

use_conv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais dans la couche de convolution du bloc mixer.

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.

initializer_range (`float`, *facultatif*, valeur par défaut `0.1`) : L'écart-type de truncated_normal_initializer pour l'initialisation de toutes les matrices de poids.

residual_in_fp32 (`bool`, *facultatif*, valeur par défaut `True`) : Indique si les résidus doivent être en `float32`. Si défini sur `False`, les résidus conservent le même `dtype` que le reste du modèle

time_step_rank (`Union[str, int]`, *facultatif*, valeur par défaut `auto`) : Rang de la projection du delta (pas de temps). Peut être `"auto"` pour le définir automatiquement.

time_step_scale (`float`, *facultatif*, valeur par défaut `1.0`) : Échelle appliquée à l'incrément de temps avant la discrétisation.

time_step_min (`float`, *facultatif*, valeur par défaut `0.001`) : valeur minimale de `time_step` utilisée pour borner `dt_proj.bias`.

time_step_max (`float`, *facultatif*, valeur par défaut `0.1`) : `time_step` maximal utilisé pour borner `dt_proj.bias`.

time_step_init_scheme (`str`, *facultatif*, par défaut `random`) : Schéma d'initialisation pour le delta de l'étape temporelle. Peut être `"random"` ou `"uniform"`.

time_step_floor (`float`, *facultatif*, valeur par défaut `0.0001`) : Valeur minimale autorisée pour l'étape de temps discrète delta après l'activation softplus.

rescale_prenorm_residual (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non réécheler les poids de `out_proj` lors de l'initialisation.

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.

use_mambapy (`bool`, *facultatif*, valeur par défaut `False`) : Détermine la stratégie de repli lors de l'entraînement si l'implémentation officielle de Mamba basée sur CUDA n'est pas disponible. Si `True`, l'implémentation mamba.py est utilisée. Si `False`, l'implémentation naïve et plus lente est utilisée. Pensez à passer à la version naïve si la mémoire est limitée.

use_associative_scan (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser `torch._higher_order_ops.associative_scan` de PyTorch pour le balayage parallèle au lieu de l'implémentation séquentielle naïve. Le balayage associatif n'est actif que lors du traçage de `torch.compile` et nécessite torch >= 2.9.0. Les deux chemins sont testés pour produire des résultats numériquement identiques (voir `test_associative_scan_matches_sequential`). Définissez la valeur sur `False` pour revenir à la boucle séquentielle.

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.

mixer_rms_eps (`float`, *facultatif*, valeur par défaut 1e-06) : La valeur epsilon de la norme RMS utilisée dans la norme RMS du Mixer pour les états B, C et dt.

Ceci est la classe de configuration destinée à stocker la configuration d'un FalconMambaModel. Elle est utilisée pour instancier un modèle Falcon Mamba 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 [tiiuae/falcon-mamba-7b](https://huggingface.co/tiiuae/falcon-mamba-7b)

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 FalconMambaConfig, FalconMambaModel

>>> # Initializing a FalconMamba configuration
>>> configuration = FalconMambaConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = FalconMambaModel(configuration)

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

## FalconMambaModel[[transformers.FalconMambaModel]]

#### transformers.FalconMambaModel[[transformers.FalconMambaModel]]

```python
transformers.FalconMambaModel(config: FalconMambaConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/modeling_falcon_mamba.py#L653)

**Paramètres :**

config ([FalconMambaConfig](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaConfig)) : 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 Falcon Mamba brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.

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.FalconMambaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, cache_params: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, attention_mask: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/modeling_falcon_mamba.py#L673)

**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/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

inputs_embeds (`torch.LongTensor` 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.

cache_params (`Cache`, *facultatif*) : s'il est transmis, le modèle utilise l'état précédent dans tous les blocs (ce qui produira la sortie pour les `input_ids` fournis comme si le modèle avait ajouté `state_input_ids + input_ids` comme contexte).

use_cache (`bool`, *facultatif*) : Si défini sur `True`, `cache_params` est renvoyé et peut être utilisé pour générer rapidement les logits suivants.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

attention_mask (`torch.LongTensor` 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)

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

Un `FalconMambaOutput` 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 ([FalconMambaConfig](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaConfig)) et les entrées.

La méthode forward du modèle [FalconMambaModel](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaModel) surcharge 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)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **cache_params** (`~cache_utils.Cache`, *facultatif*) -- L'état du modèle à la dernière étape de temps. Peut être utilisé dans une méthode forward avec les `input_ids` suivants pour éviter de fournir les anciens `input_ids`.

  Comprend à la fois les matrices d'état du modèle d'espace d'état après le balayage sélectif et les états convolutifs
- **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.

## FalconMambaLMHeadModel[[transformers.FalconMambaForCausalLM]]

#### transformers.FalconMambaForCausalLM[[transformers.FalconMambaForCausalLM]]

```python
transformers.FalconMambaForCausalLM(config: FalconMambaConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/modeling_falcon_mamba.py#L743)

**Paramètres :**

config ([FalconMambaConfig](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaConfig)) : 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 transformer FALCON_MAMBA avec une tête de modélisation de langage au sommet (couche linéaire dont les poids sont liés aux plongements d'entrée).

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.FalconMambaForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, cache_params: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/modeling_falcon_mamba.py#L784)

**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/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/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.LongTensor` 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)

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.

cache_params (`Cache`, *facultatif*) : s'il est transmis, le modèle utilise l'état précédent dans tous les blocs (ce qui produira la sortie pour les `input_ids` fournis comme si le modèle avait ajouté `state_input_ids + input_ids` comme contexte).

labels (`torch.LongTensor` de forme `(batch_size, 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.vocab_size]`

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, `cache_params` est renvoyé et peut être utilisé pour générer rapidement les logits suivants.

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 :** `FalconMambaCausalLMOutput` ou `tuple(torch.Tensor)`

Un `FalconMambaCausalLMOutput` 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 ([FalconMambaConfig](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaConfig)) et les entrées.

La méthode forward de [FalconMambaForCausalLM](/docs/transformers/main/fr/model_doc/falcon_mamba#transformers.FalconMambaForCausalLM) 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).
- **cache_params** (`~cache_utils.Cache`, *facultatif*) -- L'état du modèle à la dernière étape de temps. Peut être utilisé dans une méthode forward avec les `input_ids` suivants pour éviter de fournir les anciens `input_ids`.

  Comprend à la fois les matrices d'état du modèle d'espace d'état après le balayage sélectif et les états convolutifs
- **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.

Exemple :

```python
```