Transformers documentation
Code World Model (CWM)
<— Copyright 2025 l'équipe HuggingFace. Tous droits réservés.
Sous licence Apache License, Version 2.0 (la « Licence ») ; vous ne pouvez utiliser ce fichier qu’en conformité avec la Licence. Vous pouvez obtenir une copie de la Licence à
http://www.apache.org/licenses/LICENSE-2.0
Sauf exigence légale ou accord écrit, le logiciel distribué sous la Licence est distribué sur une base « EN L’ÉTAT », SANS AUCUNE GARANTIE NI CONDITION, expresse ou implicite. Consultez la Licence pour les dispositions spécifiques régissant les autorisations et les limitations au titre de la Licence.
⚠️ Notez que ce fichier est au format Markdown mais contient une syntaxe spécifique pour notre outil de génération de documentation (similaire à MDX) qui peut ne pas s’afficher correctement dans votre visionneuse Markdown.
—> Ce modèle a été contribué à Hugging Face Transformers le 2025-10-09.
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 par l'équipe CodeGen de Meta FAIR. CWM est un LLM pour la génération de code et le 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 effectué 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 sur 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 (mid-training) sur une grande quantité 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 d'ingénierie logicielle multi-tours. Avec CWM, nous offrons un banc d'essai solide 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 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 les 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 texte 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.
You are a helpful AI assistant. You always reason before responding, using the following format: <think> your internal reasoning </think> your external response
Ce modèle a été contribué par Meta FAIR CodeGen Team. Le code d'origine peut être trouvé ici.
Exemples d'utilisation
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:
<think>
your internal reasoning
</think>
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))Produces the following output:
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 avec un nombre de syllabes de 5-7-5. Il 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 récursifs 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 la glace
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 Réflexions infinies 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) Réflexions infinies dansent (7 syllabes : Ré-flec-tions-in-fi-nies-dan-sent) Cas de base brise la glace (5 syllabes : Cas-de-ba-se-bri-se)
Oui, cela correspond à la structure 5-7-5. Je pense que c'est un bon haïku sur la récursivité.
</think> Mirror within mirror Infinite reflections dance Base case shatters glass<|eot_id|>CwmConfig
classe transformers.CwmConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 128256hidden_size: int = 6144intermediate_size: int = 21504num_hidden_layers: int = 64num_attention_heads: int = 48num_key_value_heads: int = 8hidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int = 128000eos_token_id: int | list[int] | None = Nonepretraining_tp: int = 1tie_word_embeddings: bool = Falserope_parameters: dict | None = Noneattention_dropout: float | int = 0.0mlp_bias: bool = Falsehead_dim: int = 128sliding_window: int = 8192layer_types: list[str] | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut128256) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut6144) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut21504) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut64) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut48) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif, valeur par défaut8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut seranum_attention_heads. - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - max_position_embeddings (
int, facultatif, par défaut131072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut128000) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - pretraining_tp (
int, facultatif, valeur par défaut1) — Fonctionnalité expérimentale. Rang de parallélisme de tenseurs utilisé lors du pré-entraînement. Veuillez consulter ce document 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. - tie_word_embeddings (
bool, facultatif, valeur par défautFalse) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - rope_parameters (
dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - mlp_bias (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser un biais dans les couches up_proj, down_proj et gate_proj des couches MLP. - head_dim (
int, facultatif, par défaut128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - sliding_window (
int, facultatif, par défaut8192) — Taille de la fenêtre d'attention glissante. SiNone, 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/cwm
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
>>> 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.configCwmPreTrainedModel
classe transformers.CwmPreTrainedModel
< source >( config: PreTrainedConfig*inputs**kwargs )
Paramètres
- config (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() pour charger les poids du modèle.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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.
Valeur factice pour un chemin pointé (par exemple 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 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
classe transformers.CwmModel
< source >( config: CwmConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CwmModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde 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 masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_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 en fonction de la configuration (CwmConfig) et des entrées.
La méthode forward de 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
Moduleplutô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.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
CwmForCausalLM
classe transformers.CwmForCausalLM
< source >( config: CwmConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde 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 masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_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 économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela 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 ou tuple(torch.Tensor)
Un CausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (CwmConfig) et des entrées.
La méthode forward de 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> 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."