# Code World Model (CWM)
## Aperçu
Le modèle Code World Model (CWM) a été proposé dans [CWM: An Open-Weights LLM for Research on Code Generation with World Models](https://ai.facebook.com/research/publications/cwm) par l'équipe CodeGen de Meta FAIR. CWM est un LLM dédié à la génération de code et au raisonnement sur le code, qui a notamment été entraîné pour mieux représenter et raisonner sur la manière dont le code et les commandes affectent l'état d'un programme ou d'un système. Plus précisément, nous avons effectué un mid-training de CWM sur un grand nombre de trajectoires observation-action issues de traces d'exécution Python et d'interactions agentiques dans des environnement conteneurisés. Nous avons ensuite réalisé un post-training avec un RL multi-tâches étendu dans des environnements de codage vérifiable, de mathématiques et d'ingénierie logicielle multi-tours.
L'abstract de l'article est le suivant :
> *Nous publions Code World Model (CWM), un LLM à poids ouverts de 32 milliards de paramètres, afin de faire progresser la recherche
on la génération de code avec des modèles du monde. Pour améliorer la compréhension du code au-delà de ce qui peut être appris à partir de l’entraînement sur du code statique uniquement, nous entraînons CWM en cours de route sur un grand volume de trajectoires observation-action issues d’interpréteurs Python et d’environnements Docker agentiques, et nous réalisons un RL de raisonnement multi-tâches approfondi dans des environnements de codage vérifiable, de mathématiques et de génie logiciel multi-tours. Avec CWM, nous offrons un solide banc d’essai permettant aux chercheurs d’explorer les opportunités offertes par la modélisation du monde pour améliorer la génération de code grâce au raisonnement et à la planification dans des environnements de calcul. Nous présentons les premières étapes de la manière dont les modèles du monde peuvent bénéficier au codage agentique, permettre la simulation étape par étape de l’exécution de code Python, et nous montrons des résultats préliminaires sur la façon dont le raisonnement peut bénéficier de cette simulation. CWM est un LLM dense, décodeur uniquement, entraîné avec une taille de contexte allant jusqu’à 131 k jetons. Indépendamment de ses capacités de modélisation du monde, CWM offre de solides performances sur des tâches générales de codage et de mathématiques : il atteint des scores pass@1 de 65,8 % sur SWE-bench Verified (avec mise à l’échelle au moment du test), 68,9 % sur LiveCodeBench, 96,6 % sur Math-500 et 76,0 % sur AIME 2024. Pour soutenir la recherche supplémentaire sur la modélisation du monde du code, nous publions les points de contrôle du modèle après l’entraînement intermédiaire, le SFT et le RL.*
Astuces :
CWM nécessite un prompt système dédié pour fonctionner de manière optimale lors de l'inférence. Sans une configuration appropriée du prompt, la qualité de la sortie de CWM peut être considérablement dégradée. Le prompt suivant sert de prompt système par défaut pour les tâches de raisonnement. Pour les flux de travail agentiques, ajoutez les spécifications d'outils pertinentes après ce prompt de base. Consultez le dépôt de code original pour plus de détails.
```text
You are a helpful AI assistant. You always reason before responding, using the following format:
your internal reasoning
your external response
```
Ce modèle a été contribué par [Meta FAIR CodeGen Team](https://huggingface.co/facebook). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/cwm).
## Exemples d'utilisation
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = 'facebook/cwm'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map="auto"
)
system_prompt = """
You are a helpful AI assistant. You always reason before responding, using the following format:
your internal reasoning
your external response
""".strip()
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": "Write a haiku about recursion in programming."}
]
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True, # Switches between thinking and non-thinking modes. Default is True.
preserve_previous_think=True, # Switches between keeping thinking blocks from previous messages or not. Default is True.
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(
**model_inputs,
max_new_tokens=1024
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
print(tokenizer.decode(output_ids))
```
Produit la sortie suivante :
Bon, il me faut écrire un haïku sur la récursivité en programmation. Commençons par rappeler ce qu’est la récursivité. La récursivité est une technique de programmation où une fonction s’appelle elle-même dans sa propre définition, souvent utilisée pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes plus petits et similaires.
Un haïku est un poème en trois vers dont le nombre de syllabes suit la structure 5-7-5. Il me faut donc capturer l'essence de la récursivité de manière concise et poétique. Réfléchissons aux éléments clés de la récursivivité : la fonction qui s'appelle elle-même, le cas de base qui arrête la récursivité, et l'idée de décomposer les problèmes en parties plus petites.
Je pourrais peut-être utiliser des images liées aux miroirs ou aux reflets, car la récursion implique souvent qu'une fonction se reflète ou se répète. Alternativement, je pourrais recourir à des images naturelles comme une spirale ou un arbre, qui suggèrent des motifs auto-similaires.
Laissez-moi essayer de trouver quelques idées. Par exemple, « La fonction s'appelle elle-même » pourrait être un point de départ. Mais comment en faire un haïku ? Peut-être quelque chose comme :
Appels de fonction Cas de base qui met fin à la boucle infinie Spirale de code
Hmm, c'est un début. Mais je pourrais peut-être le rendre plus poétique. Réfléchissons à l'idée d'une fonction qui s'appelle elle-même comme une sorte de boucle infinie, mais avec un cas de base qui l'arrête. C'est comme une spirale qui se dévide au centre.
Un autre angle : la récursivité est souvent utilisée pour des problèmes qui ont une structure récursive, comme les parcours d'arbres ou les calculs de factorielles. Peut-être que je peux utiliser une image naturelle pour représenter cela.
Que diriez-vous de :
Les branches se divisent à nouveau
Les feuilles se déploient en danse infinie
Les racines maintiennent le cas de base
C'est un peu plus poétique. Les branches qui se divisent représentent les appels récursifs, les feuilles qui se déploient peuvent représenter le traitement de chaque sous-problème, et les racines qui maintiennent le cas de base sont ce qui arrête la récursion.
Sinon, peut-être quelque chose de plus simple :
Miroir dans le miroir Réflexions infiniment profondes Le cas de base brise le verre
Ceci utilise la métaphore du miroir pour représenter l'appel récursif de la fonction, le cas de base étant le point où la récursivité s'arrête, brisant la réflexion infinie.
Je pense que j'aime mieux l'idée du miroir. Laissez-moi l'affiner :
Miroir dans le miroir Des reflets infinis dansent Le cas de base brise le verre
Oui, cela semble bien capturer l'idée de la récursivité. Le miroir représente la fonction qui s'appelle elle-même, les reflets infinis sont les appels récursifs, et le cas de base qui brise le verre est ce qui arrête la récursivité.
Vérifions le nombre de syllabes :
Miroir dans le miroir (5 syllabes : Mi-roi-dans-le-mi-roi) Des reflets infinis dansent (7 syllabes : Des-re-flets-in-fi-nis-dan-sent) Le cas de base brise le verre (5 syllabes : Le-cas-de-ba-se)
Oui, cela correspond à la structure 5-7-5. Je pense que c'est un bon haïku sur la récursivité.
Miroir dans le miroir Des reflets infinis dansent Le cas de base brise le verre<|eot_id|>
## CwmConfig[[transformers.CwmConfig]]
#### transformers.CwmConfig[[transformers.CwmConfig]]
```python
transformers.CwmConfig(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 = 128256, hidden_size: int = 6144, intermediate_size: int = 21504, num_hidden_layers: int = 64, num_attention_heads: int = 48, num_key_value_heads: int = 8, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int = 128000, eos_token_id: int | list[int] | None = None, pretraining_tp: int = 1, tie_word_embeddings: bool = False, rope_parameters: dict | None = None, attention_dropout: float | int = 0.0, mlp_bias: bool = False, head_dim: int = 128, sliding_window: int = 8192, layer_types: list[str] | None = None)
```
[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cwm/configuration_cwm.py#L30)
**Paramètres :**
vocab_size (`int`, *facultatif*, valeur par défaut `128256`) : 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 `6144`) : Dimension des représentations cachées.
intermediate_size (`int`, *facultatif*, par défaut `21504`) : Dimension des représentations MLP.
num_hidden_layers (`int`, *facultatif*, valeur par défaut `64`) : Nombre de couches cachées dans le décodeur Transformer.
num_attention_heads (`int`, *facultatif*, valeur par défaut `48`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
num_key_value_heads (`int`, *facultatif*, valeur par défaut `8`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.
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.
max_position_embeddings (`int`, *facultatif*, valeur par défaut `131072`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.
rms_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation rms.
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.
pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.
bos_token_id (`int`, *facultatif*, valeur par défaut `128000`) : Identifiant du 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.
pretraining_tp (`int`, *facultatif*, valeur par défaut `1`) : Fonctionnalité expérimentale. Rang du parallélisme de tenseurs utilisé lors du pré-entraînement. Veuillez consulter [ce document](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) pour en savoir plus. Cette valeur est nécessaire pour garantir la reproductibilité exacte des résultats du pré-entraînement. Veuillez consulter [cette question](https://github.com/pytorch/pytorch/issues/76232).
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.
rope_parameters (`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.
attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.
mlp_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches up_proj, down_proj et gate_proj des couches MLP.
head_dim (`int`, *facultatif*, valeur par défaut `128`) : La dimension des têtes d'attention. Si None, la valeur par défaut est hidden_size // num_attention_heads
sliding_window (`int`, *facultatif*, valeur par défaut `8192`) : Taille de la fenêtre de l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée.
layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration.
Ceci est la classe de configuration destinée à stocker la configuration d'un CwmModel. Elle est utilisée pour instancier un modèle Cwm 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 [facebook/cwm](https://huggingface.co/facebook/cwm)
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.
```python
>>> from transformers import CwmModel, CwmConfig
>>> # Initializing a Cwm cwm-7b style configuration
>>> configuration = CwmConfig()
>>> # Initializing a model from the cwm-7b style configuration
>>> model = CwmModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```
## CwmPreTrainedModel[[transformers.CwmPreTrainedModel]]
#### transformers.CwmPreTrainedModel[[transformers.CwmPreTrainedModel]]
```python
transformers.CwmPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```
[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cwm/modeling_cwm.py#L303)
**Paramètres :**
config ([PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig)) : 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.
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.CwmPreTrainedModel.forward]]
```python
forward(*args, **kwargs)
```
Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.
## CwmModel[[transformers.CwmModel]]
#### transformers.CwmModel[[transformers.CwmModel]]
```python
transformers.CwmModel(config: CwmConfig)
```
[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cwm/modeling_cwm.py#L326)
**Paramètres :**
config ([CwmConfig](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmConfig)) : 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 Cwm 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/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.CwmModel.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: *)
```
[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cwm/modeling_cwm.py#L345)
**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.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/main/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/main/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 :** `CwmModelOutputWithPast` ou `tuple(torch.Tensor)`
Un `CwmModelOutputWithPast` 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 ([CwmConfig](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmConfig)) et les entrées.
La méthode forward de [CwmModel](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmModel) 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/main/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.
## CwmForCausalLM[[transformers.CwmForCausalLM]]
#### transformers.CwmForCausalLM[[transformers.CwmForCausalLM]]
```python
transformers.CwmForCausalLM(config: CwmConfig)
```
[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cwm/modeling_cwm.py#L408)
**Paramètres :**
config ([CwmConfig](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmConfig)) : 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 Cwm pour la modélisation de langage causale.
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.CwmForCausalLM.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, labels: typing.Optional[torch.LongTensor] = 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/cwm/modeling_cwm.py#L423)
**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.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/main/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/main/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.
labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (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 comprise dans `[0, ..., config.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`).
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 :** [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`
Un [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 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 ([CwmConfig](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmConfig)) et les entrées.
La méthode forward de [CwmForCausalLM](/docs/transformers/main/fr/model_doc/cwm#transformers.CwmForCausalLM) 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).
- **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/main/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, CwmForCausalLM
>>> model = CwmForCausalLM.from_pretrained("meta-cwm/Cwm-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-cwm/Cwm-2-7b-hf")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> 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]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
```