# Modelo de mundo de código (CWM)

## Resumen

El modelo Code World Model (CWM) fue propuesto en [CWM: An Open-Weights LLM for Research on Code Generation with World Models](https://ai.facebook.com/research/publications/cwm) por el equipo CodeGen de Meta FAIR. CWM es un LLM para la generación de código y el razonamiento sobre código que, en particular, ha sido entrenado para representar y razonar mejor sobre cómo el código y los comandos afectan el estado de un programa o sistema. Específicamente, realizamos un entrenamiento intermedio (mid-training) de CWM con un gran número de trayectorias de observación-acción derivadas de trazas de ejecución de Python e interacciones agénticas en entornos contenerizados. A continuación, realizamos un entrenamiento posterior (post-training) con RL multitarea extensivo en entornos de codificación verificable, matemáticas e ingeniería de software de múltiples turnos.

El resumen del artículo es el siguiente:

> *Publicamos Code World Model (CWM), un LLM de pesos abiertos con 32 mil millones de parámetros, para avanzar en la investigación
en la generación de código con modelos de mundo. Para mejorar la comprensión del código más allá de lo que se puede aprender únicamente del entrenamiento con código estático, realizamos un entrenamiento intermedio de CWM con una gran cantidad de trayectorias de observación-acción procedentes de intérpretes de Python y entornos Docker agénticos, y llevamos a cabo un RL de razonamiento multitarea extensivo en entornos de codificación verificable, matemáticas e ingeniería de software de múltiples turnos. Con CWM, proporcionamos un entorno de pruebas sólido para que los investigadores exploren las oportunidades que ofrece la modelización del mundo para mejorar la generación de código mediante el razonamiento y la planificación en entornos computacionales. Presentamos los primeros pasos de cómo los modelos de mundo pueden beneficiar la codificación agéntica, permitir la simulación paso a paso de la ejecución de código Python y mostrar resultados preliminares de cómo el razonamiento puede beneficiarse de esta última. CWM es un LLM denso, solo decodificador, entrenado con un tamaño de contexto de hasta 131 k tokens. Independientemente de sus capacidades de modelización del mundo, CWM ofrece un rendimiento sólido en tareas generales de codificación y matemáticas: alcanza puntuaciones pass@1 del 65,8 % en SWE-bench Verified (con escalado en tiempo de prueba), 68,9 % en LiveCodeBench, 96,6 % en Math-500 y 76,0 % en AIME 2024. Para apoyar la investigación adicional sobre la modelización del mundo del código, publicamos los puntos de control del modelo después del entrenamiento intermedio, SFT y RL.*

Consejos:

CWM requiere un prompt de sistema dedicado para funcionar de manera óptima durante la inferencia. Sin una configuración adecuada del prompt, la calidad de la salida de CWM puede degradarse significativamente. Lo siguiente sirve como prompt de sistema predeterminado para tareas de razonamiento. Para flujos de trabajo agénticos, agregue las especificaciones de herramientas relevantes después de este prompt base. Consulte el repositorio de código original para obtener más detalles.

```text
You are a helpful AI assistant. You always reason before responding, using the following format:

<think>
your internal reasoning
</think>
your external response
```

Este modelo fue aportado por [Meta FAIR CodeGen Team](https://huggingface.co/facebook). El código original se puede encontrar [aquí](https://github.com/facebookresearch/cwm).

## Ejemplos de uso

```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:

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

Genera la siguiente salida:

    Vale, necesito escribir un haiku sobre la recursión en programación. Empecemos recordando qué es la recursión. La recursión es una técnica de programación en la que una función se llama a sí misma en su propia definición, y se utiliza a menudo para resolver problemas que pueden dividirse en subproblemas más pequeños y similares.

    Un haiku es un poema de tres líneas con un recuento de sílabas de 5-7-5. Por lo tanto, necesito capturar la esencia de la recursión de manera concisa y poética. Pensemos en los elementos clave de la recursión: la función que se llama a sí misma, el caso base que detiene la recursión y la idea de dividir los problemas en partes más pequeñas.

    Quizás pueda usar imágenes relacionadas con espejos o reflejos, ya que la recursión a menudo implica que una función se refleja o se repite a sí misma. Alternativamente, podría usar imágenes naturales como una espiral o un árbol, que sugieren patrones autorreplicantes.

    Déjame intentar proponer algunas ideas. Por ejemplo, "La función se llama a sí misma" podría ser un punto de partida. Pero, ¿cómo convertir eso en un haiku? Quizás algo como:

    Llamadas a funciones Caso base detiene el bucle infinito Espiral de código

    Hmm, eso es un comienzo. Pero tal vez pueda hacerlo más poético. Pensemos en la idea de una función que se llama a sí misma como un tipo de bucle infinito, pero con un caso base que lo detiene. Es como una espiral que se desenrolla en el centro.

    Otro ángulo: la recursión se usa a menudo para problemas que tienen una estructura recursiva, como recorridos de árboles o cálculos de factoriales. Quizás pueda usar una imagen natural para representar eso.

    ¿Qué tal:

    Las ramas se dividen de nuevo Las hojas se despliegan en una danza infinita Las raíces sostienen el caso base

    Eso es un poco más poético. Las ramas que se dividen representan las llamadas recursivas, las hojas que se despliegan podrían representar el procesamiento de cada subproblema, y las raíces que sostienen el caso base son lo que detiene la recursión.

    Alternativamente, tal vez algo más simple:

    Espejo dentro de espejo Reflejos infinitos y profundos El caso base rompe el cristal

    Esto utiliza la metáfora del espejo para representar la función llamándose a sí misma, donde el caso base es el punto donde se detiene la recursión, rompiendo la reflexión infinita.

    Creo que me gusta más la idea del espejo. Déjame afinarla:

    Espejo dentro de espejo Reflejos infinitos danzan El caso base rompe el cristal

    Sí, eso parece captar bien la idea de la recursión. El espejo representa a la función llamándose a sí misma, las reflexiones infinitas son las llamadas recursivas, y el caso base que rompe el vidrio es lo que detiene la recursión.

    Déjame comprobar el número de sílabas:

    Espejo dentro de espejo (5 sílabas: Espe-jo-den-tro-es-pe-jo) Reflejos infinitos danzan (7 sílabas: Re-fle-jos-in-fi-ni-tos-dan-zan) El caso base rompe el cristal (5 sílabas: El-ca-so-ba-se-rom-pe-el-cris-tal)

    Sí, encaja con la estructura 5-7-5. Creo que es un buen haiku sobre la recursión.
    
    Espejo dentro de espejo Reflejos infinitos danzan El caso base rompe el cristal<|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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/configuration_cwm.py#L30)

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `128256`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

hidden_size (`int`, *opcional*, valor predeterminado `6144`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `21504`) : Dimensión de las representaciones MLP.

num_hidden_layers (`int`, *opcional*, valor predeterminado `64`) : Número de capas ocultas en el decodificador Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `48`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

num_key_value_heads (`int`, *opcional*, valor predeterminado `8`) : Este es el número de cabezas de key_value que se deben utilizar para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo utilizará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, valor predeterminado `131072`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

bos_token_id (`int`, *opcional*, valor predeterminado `128000`) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario.

pretraining_tp (`int`, *opcional*, valor predeterminado `1`) : Función experimental. Rango de paralelismo de tensores utilizado durante el preentrenamiento. Consulte [este documento](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) para obtener más información al respecto. Este valor es necesario para garantizar la reproducibilidad exacta de los resultados del preentrenamiento. Consulte [esta incidencia](https://github.com/pytorch/pytorch/issues/76232).

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

mlp_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas up_proj, down_proj y gate_proj de las capas MLP.

head_dim (`int`, *opcional*, valor predeterminado `128`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads

sliding_window (`int`, *opcional*, valor predeterminado `8192`) : Tamaño de la ventana de atención deslizante. Si es `None`, no se aplica ninguna ventana deslizante.

layer_types (`list[str]`, *opcional*) : Una lista que mapea explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración.

Esta es la clase de configuración para almacenar la configuración de un CwmModel. Se utiliza para instanciar un modelo Cwm según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/cwm](https://huggingface.co/facebook/cwm)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/modeling_cwm.py#L303)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.CwmPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.

## CwmModel[[transformers.CwmModel]]

#### transformers.CwmModel[[transformers.CwmModel]]

```python
transformers.CwmModel(config: CwmConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/modeling_cwm.py#L326)

**Parámetros:**

config ([CwmConfig](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Cwm básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/modeling_cwm.py#L345)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

**Devuelve:** `CwmModelOutputWithPast` o `tuple(torch.Tensor)`

Un `CwmModelOutputWithPast` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([CwmConfig](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmConfig)) y las entradas.

El método forward de [CwmModel](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## CwmForCausalLM[[transformers.CwmForCausalLM]]

#### transformers.CwmForCausalLM[[transformers.CwmForCausalLM]]

```python
transformers.CwmForCausalLM(config: CwmConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/modeling_cwm.py#L408)

**Parámetros:**

config ([CwmConfig](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Cwm para el modelado de lenguaje causal.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/cwm/modeling_cwm.py#L423)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida del modelado de lenguaje causal. Los índices deben estar en `[-100, 0, ..., config.vocab_size]` (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. Las etiquetas se **desplazan internamente** para que `labels[..., 1:]` se utilicen para predecir `logits[..., :-1, :]`. Pase etiquetas sin desplazar que coincidan con `input_ids` (es decir, `labels = input_ids`). No **desplace** usted mismo las etiquetas antes de pasarlas. Si las etiquetas ya están desplazadas (por ejemplo, con paralelismo de secuencia), páselas como el argumento de palabra clave `shift_labels` y se usarán tal cual. Todavía debe pasar `labels` para que se calcule la pérdida.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([CwmConfig](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmConfig)) y las entradas.

El método forward de [CwmForCausalLM](/docs/transformers/v5.23.0/es/model_doc/cwm#transformers.CwmForCausalLM) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```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."
```

