# Mamba 2

[Mamba 2](https://huggingface.co/papers/2405.21060) repose sur le cadre de dualité des espaces d'état (SSD), qui relie les modèles d'espace d'état structurés (SSM) aux variantes de l'attention. Il utilise un algorithme SSD plus efficace, 2 à 8 fois plus rapide que Mamba, et modifie l'architecture pour permettre le parallélisme de tenseurs et une structure de tête d'attention à valeurs groupées (GVA).

Vous pouvez trouver tous les points de contrôle originaux de Mamba 2 sous l’organisation [State Space Models](https://huggingface.co/state-spaces), mais les exemples présentés ci-dessous utilisent [mistralai/Mamba-Codestral-7B-v0.1](https://huggingface.co/mistralai/Mamba-Codestral-7B-v0.1), car une implémentation Hugging Face n’est pas encore prise en charge pour les points de contrôle originaux.

Les autres architectures basées sur Mamba 2 incluent [Bamba](./bamba), [FalconH1](./falcon_h1) et [Zamba2](./zamba2).

> [!TIP]
> Ce modèle a été contribué par [ArthurZ](https://huggingface.co/ArthurZ). Cliquez sur les modèles Mamba dans la barre latérale droite pour plus d’exemples sur l’application de Mamba à différentes tâches de langage.

L'exemple ci-dessous montre comment générer du texte avec [Pipeline](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModel) et depuis la ligne de commande.

```python
from transformers import pipeline

pipeline = pipeline(
    task="text-generation",
    model="mistralai/Mamba-Codestral-7B-v0.1",
    device=0
)
pipeline("Plants create energy through a process known as")
```

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mamba-Codestral-7B-v0.1")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mamba-Codestral-7B-v0.1", device_map="auto")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to(model.device)

output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

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 [torchao](../quantization/torchao) pour quantiser uniquement les poids en entiers sur 4 bits.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, TorchAoConfig

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mamba-Codestral-7B-v0.1")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mamba-Codestral-7B-v0.1", quantization_config=quantization_config, device_map="auto")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to(model.device)

output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

## Notes

- Codestral Mamba possède `groups=8`, qui sont similaires au nombre de têtes kv dans un modèle basé sur l'attention.
- Codestral Mamba dispose de deux passes avant différentes, `torch_forward` ou `cuda_kernels_forward`, et leurs résultats sont censés être légèrement différents.
  - `torch_forward` sans compilation est 3 à 4 fois plus rapide que `cuda_kernels_forward`.
  - `cuda_kernels_forward` utilise les noyaux CUDA d’origine s’ils sont disponibles dans votre environnement. Il est plus lent lors du préremplissage car il nécessite une « exécution de mise en route » en raison de la surcharge CPU plus élevée (voir [ces](https://github.com/state-spaces/mamba/issues/389#issuecomment-2171755306) [commentaires](https://github.com/state-spaces/mamba/issues/355#issuecomment-2147597457) pour plus de détails).

- Ce modèle ne comporte pas d'embeddings positionnels, mais il possède un `attention_mask` et une logique spécifique pour masquer les états cachés à deux endroits lors de la génération par lots (voir ce [commentaire](https://github.com/state-spaces/mamba/issues/66#issuecomment-1863563829) pour plus de détails). Cela (ainsi que l'ajout des noyaux Mamba 2 réimplémentés) entraîne une légère divergence entre la génération par lots et la génération mise en cache.

- L'algorithme SSM repose fortement sur des contractions de tenseurs, qui ont des équivalents en matmul, mais l'ordre des opérations est légèrement différent. Cela accentue l'écart à des précisions plus faibles.

- Le padding n'est testé qu'avec un padding à gauche. Le padding à droite met à jour le cache avec les positions de padding et donne des résultats peu fiables. Définissez `tokenizer.padding_side="left"` pour la génération par lots. Voir [Côté de padding](../llm_tutorial#padding-side).

- L'exemple ci-dessous montre comment effectuer le fine-tuning de Mamba 2 avec [PEFT](https://huggingface.co/docs/peft).

```python
from datasets import load_dataset
from peft import LoraConfig
from trl import SFTConfig, SFTTrainer

model_id = "mistralai/Mamba-Codestral-7B-v0.1"
dataset = load_dataset("Abirate/english_quotes", split="train")
training_args = SFTConfig(dataset_text_field="quote", gradient_checkpointing=True, per_device_train_batch_size=4)
lora_config =  LoraConfig(target_modules=["x_proj", "embeddings", "in_proj", "out_proj"])
trainer = SFTTrainer(
    model=model_id,
    args=training_args,
    train_dataset=dataset,
    peft_config=lora_config,
)
trainer.train()
```

## Mamba2Config[[transformers.Mamba2Config]]

#### transformers.Mamba2Config[[transformers.Mamba2Config]]

```python
transformers.Mamba2Config(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, num_heads: int = 128, head_dim: int = 64, vocab_size: int = 32768, hidden_size: int = 4096, state_size: int = 128, num_hidden_layers: int = 64, layer_norm_epsilon: float = 1e-05, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, expand: int = 2, conv_kernel: int = 4, n_groups: int = 8, 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_min: float = 0.001, time_step_max: float = 0.1, time_step_floor: float = 0.0001, time_step_limit: list[float] | tuple[float, ...] = (0.0, inf), rescale_prenorm_residual: bool = False, use_cache: bool = True, chunk_size: int = 256, tie_word_embeddings: bool = False)
```

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

**Paramètres :**

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

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

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

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

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

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

pad_token_id (`int`, *facultatif*, valeur par défaut `1`) : 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 `2`) : 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*, par défaut `4`) : La taille du noyau de convolution.

n_groups (`int`, *facultatif*, valeur par défaut : 8) : Nombre de groupes pour les matrices d'évolution de mamba 2.

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_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_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.

time_step_limit (`Union[list[float], tuple[float, ...]]`, *facultatif*, valeur par défaut `(0.0, inf)`) : Plage de valeurs d'étapes de temps acceptée pour le clampage.

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.

chunk_size (`int`, *facultatif*, valeur par défaut : 256) : Taille des blocs qui composeront la séquence.

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.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un Mamba2Model. Elle est utilisée pour instancier un modèle Mamba2 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 [state-spaces/mamba2-2.8b](https://huggingface.co/state-spaces/mamba2-2.8b)

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 Mamba2Config, Mamba2Model

>>> # Initializing a Mamba2 configuration
>>> configuration = Mamba2Config()

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

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

## Mamba2Model[[transformers.Mamba2Model]]

#### transformers.Mamba2Model[[transformers.Mamba2Model]]

```python
transformers.Mamba2Model(config: Mamba2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mamba2/modeling_mamba2.py#L736)

**Paramètres :**

config ([Mamba2Config](/docs/transformers/v5.23.0/fr/model_doc/mamba2#transformers.Mamba2Config)) : 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 Mamba2 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.Mamba2Model.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.Tensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mamba2/modeling_mamba2.py#L761)

**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)

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/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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)

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

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

La méthode forward de [Mamba2Model](/docs/transformers/v5.23.0/fr/model_doc/mamba2#transformers.Mamba2Model) 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)`, *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.

## Mamba2LMHeadModel[[transformers.Mamba2ForCausalLM]]

#### transformers.Mamba2ForCausalLM[[transformers.Mamba2ForCausalLM]]

```python
transformers.Mamba2ForCausalLM(config: Mamba2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mamba2/modeling_mamba2.py#L839)

**Paramètres :**

config ([Mamba2Config](/docs/transformers/v5.23.0/fr/model_doc/mamba2#transformers.Mamba2Config)) : 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 MAMBA2, un transformateur doté d'une tête de modélisation de langage au sommet (couche linéaire dont les poids ne sont pas liés aux plongements d'entrée).

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

```python
forward(input_ids: 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, attention_mask: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mamba2/modeling_mamba2.py#L880)

**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)

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/v5.23.0/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.

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)

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

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

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