# Molmo2

[Molmo2](https://huggingface.co/papers/2601.10611) es una familia de modelos de visión-lenguaje de pesos abiertos de AllenAI que se encuentran a la vanguardia entre los modelos de código abierto, con capacidades excepcionales en anclaje dirigido por puntos para tareas de imagen única, múltiples imágenes y video. La arquitectura combina un Vision Transformer (ViT) para el procesamiento de imágenes con una capa de adaptador que conecta las modalidades de visión y texto, y un decodificador de texto basado en la arquitectura de transformers con embeddings de posición rotatorios.

El resumen del artículo es el siguiente:

*Los modelos de video y lenguaje (VLM) más potentes de hoy en día siguen siendo propietarios. Los modelos de pesos abiertos más fuertes dependen de datos sintéticos generados por VLM propietarios, lo que equivale a destilar de ellos, o bien no divulgan sus datos de entrenamiento ni su receta. Como resultado, la comunidad de código abierto carece de las bases necesarias para mejorar el estado del arte en los modelos de lenguaje de video (e imagen). Es crucial que muchas aplicaciones de nivel inferior requieren más que una comprensión de alto nivel del video; requieren anclaje, ya sea mediante punteo o seguimiento en píxeles. Incluso los modelos propietarios carecen de esta capacidad. Presentamos Molmo2, una nueva familia de VLM que se encuentra en el estado del arte entre los modelos de código abierto y demuestra capacidades excepcionales y novedosas en el anclaje impulsado por punteo en tareas de imagen única, múltiples imágenes y video. Nuestra contribución clave es una colección de 7 nuevos conjuntos de datos de video y 2 de múltiples imágenes, que incluye un conjunto de datos de descripciones de video altamente detalladas para el preentrenamiento, un conjunto de datos de preguntas y respuestas de video en formato libre para el ajuste fino, un nuevo conjunto de datos de seguimiento de objetos con consultas complejas y un innovador nuevo conjunto de datos de punteo en video, todos recopilados sin el uso de VLM cerrados. También presentamos una receta de entrenamiento para estos datos que utiliza un esquema de empaquetado eficiente y codificación de árbol de mensajes, y mostramos que la atención bidireccional en los tokens de visión y una estrategia novedosa de ponderación de tokens mejoran el rendimiento. Nuestro mejor modelo de 8B supera a otros en la clase de modelos de pesos y datos abiertos en videos cortos, conteo y descripción, y es competitivo en videos largos. En el anclaje de video, Molmo2 supera significativamente a los modelos de pesos abiertos existentes como Qwen3-VL (35,5 frente a 29,6 de precisión en el conteo de video) y supera a los modelos propietarios como Gemini 3 Pro en algunas tareas (38,4 frente a 20,0 de F1 en el punteo de video y 56,2 frente a 41,1 de J&F en el seguimiento de video).*

Puedes encontrar todos los puntos de control originales de Molmo2 en la colección [Molmo2](https://huggingface.co/collections/allenai/molmo2-693c9c798794a7b34ef23dfc).

## Ejemplo de uso

### Generación de imagen y texto a texto

El siguiente ejemplo demuestra cómo generar texto a partir de una imagen con [Pipeline](/docs/transformers/v5.24.0/es/main_classes/pipelines#transformers.Pipeline) o la clase [AutoModel](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipeline = pipeline(
    task="image-text-to-text",
    model="allenai/Molmo2-8B",
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]
pipeline(text=messages, max_new_tokens=128, return_full_text=False)
```

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

processor = AutoProcessor.from_pretrained("allenai/Molmo2-8B")
model = AutoModelForImageTextToText.from_pretrained(
    "allenai/Molmo2-8B",
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image."},
            {"type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
)

generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_text = processor.decode(
    generated_ids[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
)
print(generated_text)
# In this captivating image, a snow leopard is captured ...
```

### Apuntado con video

Molmo2 también puede generar puntos con referencia para entradas de video. Los puntos se devuelven en el texto generado como un payload `<points coords="...">`, donde cada grupo de coordenadas contiene un timestamp seguido de ids de puntos y coordenadas de imagen normalizadas.

```python
import torch

from transformers import AutoModelForImageTextToText, AutoProcessor

model_id = "allenai/Molmo2-8B"
video_url = "https://storage.googleapis.com/oe-training-public/demo_videos/many_penguins.mp4"

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Point to the penguins."},
            {"type": "video", "video": video_url},
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
)

generated_ids = model.generate(**inputs, max_new_tokens=128, do_sample=False)

input_len = inputs["input_ids"].shape[1]
generated_text = processor.decode(generated_ids[0][input_len:], skip_special_tokens=True)
print(generated_text)
```

## Molmo2Config[[transformers.Molmo2Config]]

#### transformers.Molmo2Config[[transformers.Molmo2Config]]

```python
transformers.Molmo2Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, adapter_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_start_token_id: int = 151936, low_res_image_start_token_id: int = 151940, image_end_token_id: int = 151937, image_patch_id: int = 151938, frame_start_token_id: int = 151943, frame_end_token_id: int = 151944, initializer_range: float = 0.02, tie_word_embeddings: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/configuration_molmo2.py#L170)

**Parámetros:**

vision_config (`Molmo2VisionConfig`, *opcional*) : Configuración del backbone del transformer de visión.

adapter_config (`Molmo2AdapterConfig`, *opcional*) : Configuración del adaptador de visión a lenguaje.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

image_start_token_id (`int`, *opcional*, valor predeterminado 151936) : ID de token que marca el inicio de una región de imagen.

low_res_image_start_token_id (`int`, *opcional*, valor predeterminado 151940) : ID de token que marca el inicio de un recorte de imagen de baja resolución.

image_end_token_id (`int`, *opcional*, valor predeterminado 151937) : ID de token que marca el final de una región de imagen.

image_patch_id (`int`, *opcional*, valor predeterminado 151938) : ID de token para parches de imagen.

frame_start_token_id (`int`, *opcional*, valor predeterminado 151943) : ID de token que marca el inicio de un fotograma de video.

frame_end_token_id (`int`, *opcional*, valor predeterminado 151944) : ID de token que marca el final de un fotograma de video.

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

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Indica si los embeddings de palabras de entrada y salida del modelo deben estar vinculados.

Esta es la clase de configuración para almacenar la configuración de un Molmo2Model. Se utiliza para instanciar un modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.24.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.24.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Molmo2VisionConfig[[transformers.Molmo2VisionConfig]]

#### transformers.Molmo2VisionConfig[[transformers.Molmo2VisionConfig]]

```python
transformers.Molmo2VisionConfig(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, hidden_size: int = 1152, intermediate_size: int = 4304, num_hidden_layers: int = 25, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 72, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-06, image_size: list[int] | None = None, patch_size: int = 14, num_position_embeddings: int | None = None, num_channels: int = 3, attention_dropout: float = 0.0, attention_bias: bool = True, initializer_range: float = 0.02)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/configuration_molmo2.py#L30)

**Parámetros:**

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

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

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

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

num_key_value_heads (`int`, *opcional*, valor predeterminado `16`) : 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 promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulte [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

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

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

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

image_size (`list[int]`, *opcional*) : Tamaño de la imagen de entrada como (altura, ancho), `[378, 378]` si no se proporciona.

patch_size (`int`, *opcional*, valor predeterminado `14`) : El tamaño (resolución) de cada parche.

num_position_embeddings (`int`, *opcional*) : Número de incrustaciones posicionales, una por parche de imagen. Se deriva de `image_size` y `patch_size` cuando no se proporciona.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

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

attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

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

Esta es la clase de configuración para almacenar la configuración de un Molmo2Model. Se utiliza para instanciar un modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.24.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.24.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Molmo2AdapterConfig[[transformers.Molmo2AdapterConfig]]

#### transformers.Molmo2AdapterConfig[[transformers.Molmo2AdapterConfig]]

```python
transformers.Molmo2AdapterConfig(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, vision_feature_layer: list[int] | None = None, hidden_size: int = 1152, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 72, attention_dropout: float = 0.0, attention_bias: bool = True, hidden_act: str = 'silu', intermediate_size: int = 18944, text_hidden_size: int = 3584, mlp_bias: bool = False, initializer_range: float = 0.02)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/configuration_molmo2.py#L75)

**Parámetros:**

vision_feature_layer (`list[int]`, *opcional*) : Índices de las capas de ViT cuyas salidas se concatenan y se agrupan, `[24, 18]` si no se proporcionan. Los índices negativos se cuentan desde la última capa.

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

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

num_key_value_heads (`int`, *opcional*, valor predeterminado `16`) : 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 promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulte [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

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

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

attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

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.

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

text_hidden_size (`int`, *opcional*, valor predeterminado 3584) : Tamaño oculto del modelo de texto (utilizado para la proyecció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.

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

Esta es la clase de configuración para almacenar la configuración de un Molmo2Model. Se utiliza para instanciar un modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.24.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.24.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Molmo2TextConfig[[transformers.Molmo2TextConfig]]

#### transformers.Molmo2TextConfig[[transformers.Molmo2TextConfig]]

```python
transformers.Molmo2TextConfig(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, hidden_size: int = 4096, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int = 128, vocab_size: int = 151936, additional_vocab_size: int = 128, attention_bias: bool = False, qk_norm_type: str = 'qwen3', num_hidden_layers: int = 36, intermediate_size: int = 12288, hidden_act: str = 'silu', attention_dropout: float = 0.0, max_position_embeddings: int = 36864, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, rope_scaling_layers: list[int] | None = None, rms_norm_eps: float = 1e-06, norm_after: bool = False, initializer_range: float = 0.02, use_cache: bool = True, tie_word_embeddings: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/configuration_molmo2.py#L111)

**Parámetros:**

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

num_attention_heads (`int`, *opcional*, valor predeterminado `32`) : Número de cabezas de atención para cada capa de atención en el decodificador del 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`.

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

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

additional_vocab_size (`int`, *opcional*, valor predeterminado 128) : Número de tokens adicionales del vocabulario más allá del vocabulario base.

attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

qk_norm_type (`str`, *opcional*, valor predeterminado `"qwen3"`) : Disposición de normalización de consulta/clave utilizada por el punto de control. `"qwen3"` normaliza por cabeza; `"olmo"` normaliza los tensores de consulta/clave proyectados completos.

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

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

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.

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

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

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, 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 largas.

rope_scaling_layers (`list[int]`, *opcional*) : Índices de las capas que aplican el RoPE escalado descrito por `rope_parameters`. Las capas restantes utilizan un RoPE no escalado con el mismo theta. Si no se proporciona, todas las capas se escalan.

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

norm_after (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar la normalización de capas después de los bloques de atención/FFN en lugar de antes.

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

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.

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.

Esta es la clase de configuración para almacenar la configuración de un Molmo2Model. Se utiliza para instanciar un modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.24.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.24.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Molmo2Processor[[transformers.Molmo2Processor]]

#### transformers.Molmo2Processor[[transformers.Molmo2Processor]]

```python
transformers.Molmo2Processor(image_processor = None, video_processor = None, tokenizer = None, chat_template: str | None = None, image_use_col_tokens: bool | None = True, use_single_crop_col_tokens: bool | None = None, use_single_crop_start_token: bool | None = True, video_use_col_tokens: bool | None = False, use_frame_special_tokens: bool | None = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/processing_molmo2.py#L33)

**Parámetros:**

image_processor (`Molmo2ImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio.

video_processor (`Molmo2VideoProcessor`) : El procesador de video es un parámetro de entrada obligatorio.

tokenizer (`TokenizersBackend`) : El tokenizador es una entrada obligatoria.

chat_template (`str`, *opcional*) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

image_use_col_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben añadir tokens separadores de columna (`<im_col>`) después de cada fila de parches de la vista de imagen de alta resolución.

use_single_crop_col_tokens (`bool`, *opcional*) : Indica si se deben añadir tokens separadores de columnas después de cada fila de parches de la vista de imagen de baja resolución (un solo recorte). Si es `None`, se utiliza `image_use_col_tokens` como valor predeterminado.

use_single_crop_start_token (`bool`, *opcional*, valor predeterminado `True`) : Si se inicia la vista de imagen de baja resolución con `<low_res_im_start>` en lugar de `<im_start>` regular.

video_use_col_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben añadir tokens separadores de columnas después de cada fila de parches de los fotogramas de video.

use_frame_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe envolver cada fotograma del video con los tokens `<frame_start>` / `<frame_end>`. Si es `False`, se recurre a `<im_start>` / `<im_end>`.

Construye un Molmo2Processor que encapsula un procesador de imágenes, un procesador de video y un tokenizador en un único procesador.

[Molmo2Processor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Processor) ofrece todas las funcionalidades de [Molmo2ImageProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor), [Molmo2VideoProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor) y [TokenizersBackend](/docs/transformers/v5.24.0/es/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~Molmo2ImageProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor), [~Molmo2VideoProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor) y [~TokenizersBackend](/docs/transformers/v5.24.0/es/main_classes/tokenizer#transformers.TokenizersBackend) para obtener más información.

#### __llamada__[[transformers.Molmo2Processor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/processing_molmo2.py#L93)

**Parámetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/v5.24.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

## Molmo2ImageProcessor[[transformers.Molmo2ImageProcessor]]

#### transformers.Molmo2ImageProcessor[[transformers.Molmo2ImageProcessor]]

```python
transformers.Molmo2ImageProcessor(**kwargs: *<class 'transformers.models.molmo2.image_processing_molmo2.Molmo2ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/image_processing_molmo2.py#L193)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 378, 'width': 378}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

max_crops (`int`, *kwargs*, *opcional*, valor predeterminado 8) : Número máximo de recortes a utilizar por imagen.

overlap_margins (`list[int]`, *kwargs*, *opcional*, valor predeterminado `[4, 4]`) : Márgenes de superposición (en parches) para la extracción de recortes superpuestos.

patch_size (`int`, *kwargs*, *opcional*, valor predeterminado 14) : El tamaño de parche espacial del codificador de visión.

pooling_size (`list[int]`, *kwargs*, *opcional*, valor predeterminado `[2, 2]`) : El tamaño de agrupación del adaptador de visión.

Construye un procesador de imágenes Molmo2ImageProcessor.

#### __llamada__[[transformers.Molmo2ImageProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/image_processing_utils.py#L215)

Preprocesa una imagen o un lote de imágenes.

#### preprocess[[transformers.Molmo2ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.molmo2.image_processing_molmo2.Molmo2ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/image_processing_molmo2.py#L353)

**Parámetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

max_crops (`int`, *kwargs*, *opcional*, valor predeterminado 8) : Número máximo de recortes a utilizar por imagen.

overlap_margins (`list[int]`, *kwargs*, *opcional*, valor predeterminado `[4, 4]`) : Márgenes de superposición (en parches) para la extracción de recortes superpuestos.

patch_size (`int`, *kwargs*, *opcional*, valor predeterminado 14) : El tamaño de parche espacial del codificador de visión.

pooling_size (`list[int]`, *kwargs*, *opcional*, valor predeterminado `[2, 2]`) : El tamaño de agrupación del adaptador de visión.

**Devuelve:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

## Molmo2VideoProcessor[[transformers.Molmo2VideoProcessor]]

#### transformers.Molmo2VideoProcessor[[transformers.Molmo2VideoProcessor]]

```python
transformers.Molmo2VideoProcessor(**kwargs: *<class 'transformers.models.molmo2.video_processing_molmo2.Molmo2VideoProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/video_processing_molmo2.py#L148)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 378, 'width': 378}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos objetivo a muestrear por segundo cuando `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*, por defecto `64`) : Número máximo de fotogramas a muestrear cuando `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe devolver o no la metadatos del video. Los metadatos del video son un objeto que contiene información sobre la duración del video, los fps, el backend de decodificación, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

patch_size (`int`, *kwargs*, *opcional*) : Longitud en píxeles de cada parche de ViT para los fotogramas de video.

pooling_size (`list[int]`, *kwargs*, *opcional*) : `[pool_h, pool_w]` ventana de pooling aplicada a las características de parches de video.

max_fps (`int`, *kwargs*, *opcional*) : Tasa de muestreo máxima en fotogramas por segundo para videos cortos.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video Molmo2VideoProcessor.

#### __llamada__[[transformers.Molmo2VideoProcessor.__call__]]

```python
__call__(videos, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/video_processing_utils.py#L86)

## Molmo2Model[[transformers.Molmo2Model]]

#### transformers.Molmo2Model[[transformers.Molmo2Model]]

```python
transformers.Molmo2Model(config: Molmo2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L720)

**Parámetros:**

config ([Molmo2Config](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Config)) : 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.24.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Molmo2, que consta de un backbone de visión, un adaptador de pooling y un modelo de lenguaje, sin una cabeza de modelado de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.24.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.Molmo2Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, image_token_pooling: typing.Optional[torch.Tensor] = None, image_grids: typing.Optional[torch.Tensor] = None, image_num_crops: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_token_pooling: typing.Optional[torch.Tensor] = None, video_grids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L790)

**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.24.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando `image_processor_class`. Consulte `image_processor_class.__call__` para obtener más detalles (`processor_class` utiliza `image_processor_class` para procesar las imágenes).

image_token_pooling (`torch.Tensor` de forma `(num_image_tokens, pool_h * pool_w)`, *opcional*) : Índices en la secuencia de parches de imagen aplanada recopilados por cada token de imagen agrupado, donde `-1` marca los espacios de relleno. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

image_grids (`torch.Tensor` de forma `(num_images, 4)`, *opcional*) : Cuadrícula de tokens agrupados `[low_res_h, low_res_w, high_res_h, high_res_w]` por imagen. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

image_num_crops (`torch.Tensor` de forma `(num_images,)`, *opcional*) : Número de recortes por imagen, incluida la vista de baja resolución. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel para los videos se pueden obtener usando `video_processor_class`. Consulte `video_processor_class.__call__` para más detalles (`processor_class` usa `video_processor_class` para procesar videos).

video_token_pooling (`torch.Tensor` de forma `(num_video_tokens, pool_h * pool_w)`, *opcional*) : Índices en la secuencia aplanada de parches de fotogramas de vídeo recopilados por cada token de vídeo agrupado, donde `-1` marca las posiciones de relleno. Se puede obtener mediante [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

video_grids (`torch.Tensor` de forma `(num_videos, 3)`, *opcional*) : Cuadrícula de tokens `[num_frames, pooled_h, pooled_w]` por video. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

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

cache (`~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 pueden usarse para acelerar la decodificación secuencial. Esto suele consistir en la `cache` devuelta 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.24.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasa ninguna `cache`, [DynamicCache](/docs/transformers/v5.24.0/es/internal/generation_utils#transformers.DynamicCache) se inicializará de forma predeterminada.  El modelo devolverá el mismo formato de cache que se le haya proporcionado como entrada.  Si se usan `cache`, se espera que el usuario introduzca solo `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor pasados a este modelo) de forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` de forma `(batch_size, sequence_length)`.

mm_token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada que corresponden a cada modalidad. Por ejemplo, texto (0), imagen (1), vídeo (2). Los ids de tipo de token multimodal se pueden obtener mediante [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para obtener más detalles.

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 de `cache` y pueden usarse para acelerar la decodificación (ver `cache`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

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

Un `Molmo2ModelOutputWithPast` 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 (`None`) y las entradas.

El método forward de [Molmo2Model](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Model) 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.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo de lenguaje base. Si se usa `cache`, solo se devuelve el último estado oculto de las secuencias, de forma `(batch_size, 1, hidden_size)`.
- **cache** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.24.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 usarse (consulte la entrada `cache`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 de lenguaje base en la salida de cada capa más las salidas de embedding iniciales opcionales.
- **attentions** (`tuple(torch.FloatTensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del modelo de lenguaje base, después del softmax de atención.
- **image_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de imágenes: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesaron imágenes.
- **video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de video: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesaron videos.
- **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de audio: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesó audio.

## Molmo2TextModel[[transformers.Molmo2TextModel]]

#### transformers.Molmo2TextModel[[transformers.Molmo2TextModel]]

```python
transformers.Molmo2TextModel(config: Molmo2TextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L629)

**Parámetros:**

config ([Molmo2TextConfig](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2TextConfig)) : 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.24.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

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

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.24.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.Molmo2TextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, cache: 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.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L654)

**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.24.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.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)

cache (`~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 pueden usarse para acelerar la decodificación secuencial. Esto suele consistir en la `cache` devuelta 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.24.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasa ninguna `cache`, [DynamicCache](/docs/transformers/v5.24.0/es/internal/generation_utils#transformers.DynamicCache) se inicializará de forma predeterminada.  El modelo devolverá el mismo formato de cache que se le haya proporcionado como entrada.  Si se usan `cache`, se espera que el usuario introduzca solo `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor pasados a este modelo) de forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` de 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 de `cache` y pueden usarse para acelerar la decodificación (ver `cache`).

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

Un [BaseModelOutputWithPast](/docs/transformers/v5.24.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 (`None`) y las entradas.

El método forward de [Molmo2TextModel](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2TextModel) 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 `cache`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **cache** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.24.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 `cache`) 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.

## Molmo2Adapter[[transformers.Molmo2Adapter]]

#### transformers.Molmo2Adapter[[transformers.Molmo2Adapter]]

```python
transformers.Molmo2Adapter(config: Molmo2AdapterConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L579)

**Parámetros:**

config ([Molmo2AdapterConfig](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2AdapterConfig)) : 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.24.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El adaptador de visión de Molmo2: agrupa las características de parches de ViT mediante una capa de atención cruzada y las proyecta en el espacio de incrustaciones del modelo de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.24.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.Molmo2Adapter.forward]]

```python
forward(image_features: Tensor, pooled_patches_idx: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L592)

**Parámetros:**

image_features (`torch.Tensor` de forma `(num_crops, num_patches, hidden_size * len(vision_feature_layer))`) : Características intermedias de ViT concatenadas de cada recorte.

pooled_patches_idx (`torch.Tensor` de forma `(num_tokens, pool_h * pool_w)`) : Índices en la secuencia de parches aplanada agrupada por cada token de salida; `-1` marca los espacios de relleno.

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

Un [BaseModelOutput](/docs/transformers/v5.24.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 ([Molmo2Config](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Config)) y las entradas.

El método forward de [Molmo2Adapter](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Adapter) 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.
- **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.

## Molmo2VisionModel[[transformers.Molmo2VisionModel]]

#### transformers.Molmo2VisionModel[[transformers.Molmo2VisionModel]]

```python
transformers.Molmo2VisionModel(config: Molmo2VisionConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L520)

**Parámetros:**

config ([Molmo2VisionConfig](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2VisionConfig)) : 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.24.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

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

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.24.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.Molmo2VisionModel.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L540)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Molmo2ImageProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor). Consulte [Molmo2ImageProcessor.__call__()](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([Molmo2Processor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Processor) utiliza [Molmo2ImageProcessor](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor) para procesar las imágenes).

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

Un [BaseModelOutputWithPooling](/docs/transformers/v5.24.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Molmo2Config](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Config)) y las entradas.

El método forward de [Molmo2VisionModel](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2VisionModel) 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.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **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.

## Molmo2ForConditionalGeneration[[transformers.Molmo2ForConditionalGeneration]]

#### transformers.Molmo2ForConditionalGeneration[[transformers.Molmo2ForConditionalGeneration]]

```python
transformers.Molmo2ForConditionalGeneration(config: Molmo2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L900)

**Parámetros:**

config ([Molmo2Config](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2Config)) : 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.24.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Molmo2, que consta de un backbone de visión, un adaptador de pooling y un modelo de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.24.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.Molmo2ForConditionalGeneration.forward]]

```python
forward(input_ids: LongTensor = None, pixel_values: typing.Optional[torch.Tensor] = None, image_token_pooling: typing.Optional[torch.Tensor] = None, image_grids: typing.Optional[torch.Tensor] = None, image_num_crops: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_token_pooling: typing.Optional[torch.Tensor] = None, video_grids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, cache: list[torch.Tensor] | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = 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, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.24.0/src/transformers/models/molmo2/modeling_molmo2.py#L937)

**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.24.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.24.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.24.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando `image_processor_class`. Consulte `image_processor_class.__call__` para obtener más detalles (`processor_class` utiliza `image_processor_class` para procesar las imágenes).

image_token_pooling (`torch.Tensor` de forma `(num_image_tokens, pool_h * pool_w)`, *opcional*) : Índices en la secuencia de parches de imagen aplanada recopilados por cada token de imagen agrupado, donde `-1` marca los espacios de relleno. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

image_grids (`torch.Tensor` de forma `(num_images, 4)`, *opcional*) : Cuadrícula de tokens agrupados `[low_res_h, low_res_w, high_res_h, high_res_w]` por imagen. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

image_num_crops (`torch.Tensor` de forma `(num_images,)`, *opcional*) : Número de recortes por imagen, incluida la vista de baja resolución. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel para los videos se pueden obtener usando `video_processor_class`. Consulte `video_processor_class.__call__` para más detalles (`processor_class` usa `video_processor_class` para procesar videos).

video_token_pooling (`torch.Tensor` de forma `(num_video_tokens, pool_h * pool_w)`, *opcional*) : Índices en la secuencia aplanada de parches de fotogramas de vídeo recopilados por cada token de vídeo agrupado, donde `-1` marca las posiciones de relleno. Se puede obtener mediante [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

video_grids (`torch.Tensor` de forma `(num_videos, 3)`, *opcional*) : Cuadrícula de tokens `[num_frames, pooled_h, pooled_w]` por video. Se puede obtener usando [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

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)

cache (`list[torch.Tensor]`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto suele consistir en la `cache` devuelta 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.24.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 pasa ninguna `cache`, se inicializará [DynamicCache](/docs/transformers/v5.24.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se le haya proporcionado como entrada.  Si se usan `cache`, se espera que el usuario introduzca solo `input_ids` sin procesar (aquellos que no tienen sus estados de clave y valor pasados a este modelo) de forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` de forma `(batch_size, sequence_length)`.

mm_token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada que corresponden a cada modalidad. Por ejemplo, texto (0), imagen (1), vídeo (2). Los ids de tipo de token multimodal se pueden obtener mediante [AutoProcessor](/docs/transformers/v5.24.0/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/v5.24.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para obtener más detalles.

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 de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

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

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

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

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

Un `Molmo2CausalLMOutputWithPast` 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 (`None`) y las entradas.

El método forward de [Molmo2ForConditionalGeneration](/docs/transformers/v5.24.0/es/model_doc/molmo2#transformers.Molmo2ForConditionalGeneration) 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.FloatTensor` 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.FloatTensor` 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).
- **cache** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.24.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 usarse (consulte la entrada `cache`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 de lenguaje base en la salida de cada capa más las salidas de embedding iniciales opcionales.
- **attentions** (`tuple(torch.FloatTensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del modelo de lenguaje base, después del softmax de atención.
- **image_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de imágenes: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesaron imágenes.
- **video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de video: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesaron videos.
- **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de audio: `last_hidden_state`, `pooler_output`, `hidden_states` y `attentions`. `None` si no se procesó audio.

Ejemplo:

```python
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Molmo2ForConditionalGeneration

>>> model = Molmo2ForConditionalGeneration.from_pretrained("allenai/Molmo2-8B")
>>> processor = AutoProcessor.from_pretrained("allenai/Molmo2-8B")

>>> prompt = "What's the content of the image?"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> messages = [{"role": "user", "content": [{"type": "text", "text": prompt}, {"type": "image", "image": image}]}]

>>> inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", return_dict=True)

>>> # Generate
>>> generated_ids = model.generate(**inputs, max_new_tokens=15)
>>> generated_tokens = generated_ids[:, inputs['input_ids'].size(1):]
>>> processor.post_process_image_text_to_text(generated_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"The image shows a bustling street scene in what appears to be a Chinatown area. There's ..."
```

