# MiniCPM-V 4.7

[MiniCPM-V](https://huggingface.co/papers/2509.18154) es una serie de modelos de lenguaje multimodales eficientes desarrollados por [OpenBMB](https://github.com/OpenBMB). Al igual que [MiniCPM-V 4.6](./minicpmv4_6), la arquitectura de MiniCPM-V 4.7 combina un codificador visual [SigLIP](./siglip) con un fusionador de atención por ventanas y un modelo de lenguaje base [Qwen3.5](./qwen3_5), y admite tanto los modos de submuestreo visual 4x como 16x.

La principal novedad respecto a la versión 4.6 es *canvas M-RoPE*: en lugar de numerar los tokens visuales a lo largo de una secuencia unidimensional, el modelo dispone cada imagen en un lienzo bidimensional y asigna a cada token visual una posición `(temporal, height, width)`, de modo que las porciones de la misma imagen conservan su relación espacial y los fotogramas de un video mantienen su orden temporal.

Este modelo fue aportado por [OpenBMB](https://huggingface.co/openbmb). El código original se puede encontrar [aquí](https://github.com/OpenBMB/MiniCPM-V).

> [!NOTE]
> Pasar `use_image_id` a un procesador numerará varias imágenes en un solo prompt para que el texto pueda referirse a ellas individualmente. Se aplica solo a imágenes: un video es una secuencia temporal única de fotogramas y no varios visuales direccionables, que es la forma en que se entrenó el modelo, por lo que la configuración se ignora para entradas de video.

## Ejemplo de uso

### Inferencia con Pipeline

```python
from transformers import pipeline

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

pipe = pipeline("image-text-to-text", model="openbmb/MiniCPM-V-4.7-1B")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]
```

### Inferencia en una sola imagen

```python
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "openbmb/MiniCPM-V-4.7-1B"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, 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."},
        ],
    }
]

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

output = model.generate(**inputs, max_new_tokens=100)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)
```

### Modo de reducción de muestreo

MiniCPM-V 4.7 admite dos modos de submuestreo visual:

- **16x** (predeterminado): submuestreo más agresivo, menos tokens visuales, inferencia más rápida.
- **4x**: Menos submuestreo, más tokens visuales, mejor para tareas con muchos detalles.

Puede cambiar el modo de muestreo descendente en tiempo de ejecución pasando `downsample_mode` a través de `processor_kwargs` y a `model.generate`:

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    processor_kwargs={"downsample_mode": "4x"},
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=100, downsample_mode="4x")
```

### Modo de razonamiento

El modelo admite un modo de razonamiento controlado por `enable_thinking` en la plantilla de chat. Cuando está habilitado, el modelo genera razonamiento interno antes de proporcionar la respuesta final:

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    enable_thinking=True,
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=1024)
```

Para desactivar el razonamiento (predeterminado para la evaluación):

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    enable_thinking=False,
).to(model.device, dtype=model.dtype)
```

### Inferencia de video

MiniCPM-V 4.7 admite la comprensión de videos.

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "path/to/video.mp4"},
            {"type": "text", "text": "Describe what happens in this video."},
        ],
    }
]

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

output = model.generate(**inputs, max_new_tokens=200)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)
```

## MiniCPMV4_7Config[[transformers.MiniCPMV4_7Config]]

#### transformers.MiniCPMV4_7Config[[transformers.MiniCPMV4_7Config]]

```python
transformers.MiniCPMV4_7Config(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, insert_layer_id: int = 6, image_size: int = 448, image_token_id: int | None = None, video_token_id: int | None = None, tie_word_embeddings: bool = False, downsample_mode: str = '16x', merge_kernel_size: tuple[int, int] | list[int] = (2, 2), merger_times: int = 1, image_start_id: int | None = None, image_end_id: int | None = None, slice_start_id: int | None = None, slice_end_id: int | None = None, newline_id: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/configuration_minicpmv4_7.py#L66)

**Parámetros:**

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

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

insert_layer_id (`int`, *opcional*, valor predeterminado: 6) : Índice de la capa del codificador de visión después de la cual se aplica el fusionador de atención por ventana.

image_size (`int`, *opcional*, valor predeterminado `448`) : El tamaño (resolución) de cada imagen.

image_token_id (`int`, *opcional*) : El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada.

video_token_id (`int`, *opcional*) : El índice de token de video utilizado como marcador de posición para los videos de entrada.

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.

downsample_mode (`str`, *opcional*, valor predeterminado `"16x"`) : Relación de reducción de tokens visuales. `"4x"` conserva 4 veces más tokens.

merge_kernel_size (`tuple[int, int]`, *opcional*, valor predeterminado `(2, 2)`) : Tamaño del kernel `(h, w)` para fusionar parches visuales adyacentes en el Merger.

merger_times (`int`, *opcional*, valor predeterminado 1) : Número de rondas iterativas de fusión en el Merger.

image_start_id (`int`, *opcional*) : Id del token del marcador de inicio de imagen (`<image>`). Canvas M-RoPE lo fija en el halo justo fuera de la esquina superior izquierda del lienzo de la imagen. Se resuelve desde el tokenizer mediante el script de conversión y se almacena en `config.json`; es obligatorio para entradas de imagen o video.

image_end_id (`int`, *opcional*) : Id del token del marcador de fin de imagen (`</image>`). Canvas M-RoPE lo fija en la esquina más alejada del lienzo de la imagen. Se resuelve desde el tokenizador mediante el script de conversión y se almacena en `config.json`; es obligatorio para entradas de imagen o vídeo.

slice_start_id (`int`, *opcional*) : Id del token del marcador de inicio de la porción (`<slice>`). Canvas M-RoPE lo fija en la esquina superior izquierda de la porción que abre. Se resuelve desde el tokenizador mediante el script de conversión y se almacena en `config.json`; es obligatorio para entradas de imagen o vídeo.

slice_end_id (`int`, *opcional*) : Id del token del marcador de fin de segmento (`</slice>`). Canvas M-RoPE lo fija en la esquina inferior derecha del segmento que cierra. Se resuelve desde el tokenizador mediante el script de conversión y se almacena en `config.json`; es obligatorio para entradas de imagen o vídeo.

newline_id (`int`, *opcional*) : Id del token de salto de línea (`"\n"`) que separa las filas de la matriz. Canvas M-RoPE lo fija justo más allá del borde derecho de la fila en la que termina. Se resuelve desde el tokenizador mediante el script de conversión y se almacena en `config.json`; es obligatorio para entradas de imagen o vídeo.

Esta es la clase de configuración para almacenar la configuración de un MiniCPMV4_7Model. Se utiliza para instanciar un modelo Minicpmv4 7 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 [openbmb/MiniCPM-V-4.7-1B](https://huggingface.co/openbmb/MiniCPM-V-4.7-1B)

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

## MiniCPMV4_7VisionConfig[[transformers.MiniCPMV4_7VisionConfig]]

#### transformers.MiniCPMV4_7VisionConfig[[transformers.MiniCPMV4_7VisionConfig]]

```python
transformers.MiniCPMV4_7VisionConfig(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 = 768, intermediate_size: int = 3072, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, insert_layer_id: int = 6, window_kernel_size: tuple[int, int] | list[int] = (2, 2))
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/configuration_minicpmv4_7.py#L31)

**Parámetros:**

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

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

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

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

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

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `224`) : El tamaño (resolución) de cada imagen.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

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.

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

insert_layer_id (`int`, *opcional*, valor predeterminado: 6) : Índice de la capa del codificador de visión después de la cual se aplica el fusionador de atención por ventana.

window_kernel_size (`tuple[int, int]`, *opcional*, valor predeterminado `(2, 2)`) : Tamaño de la ventana `(h, w)` para el merger de atención por ventana intermedio.

Esta es la clase de configuración para almacenar la configuración de un MiniCPMV4_7Model. Se utiliza para instanciar un modelo Minicpmv4 7 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 [openbmb/MiniCPM-V-4.7-1B](https://huggingface.co/openbmb/MiniCPM-V-4.7-1B)

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

## MiniCPMV4_7VisionPreTrainedModel.[[transformers.MiniCPMV4_7VisionPreTrainedModel]]

#### transformers.MiniCPMV4_7VisionPreTrainedModel[[transformers.MiniCPMV4_7VisionPreTrainedModel]]

```python
transformers.MiniCPMV4_7VisionPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L401)

#### forward[[transformers.MiniCPMV4_7VisionPreTrainedModel.forward]]

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

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

## MiniCPMV4_7VisionModel[[transformers.MiniCPMV4_7VisionModel]]

#### transformers.MiniCPMV4_7VisionModel[[transformers.MiniCPMV4_7VisionModel]]

```python
transformers.MiniCPMV4_7VisionModel(config: MiniCPMV4_7VisionConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L415)

#### forward[[transformers.MiniCPMV4_7VisionModel.forward]]

```python
forward(pixel_values, target_sizes: typing.Optional[torch.IntTensor] = None, use_vit_merger: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L447)

**Parámetros:**

pixel_values (`` of shape `(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 utilizando [MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor). Consulte [MiniCPMV4_6ImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MiniCPMV4_7Processor](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) utiliza [MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor) para procesar las imágenes).

target_sizes (`torch.IntTensor` de forma `(batch_size, 2)`, *opcional*) : Tamaños de la cuadrícula de parches `(h, w)` para calcular los embeddings de posición.

use_vit_merger (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar el fusionador de atención por ventana de ViT después del codificador.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

El método forward de [MiniCPMV4_7VisionModel](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7VisionModel) reemplaza 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.

## MiniCPMV4_7Model[[transformers.MiniCPMV4_7Model]]

#### transformers.MiniCPMV4_7Model[[transformers.MiniCPMV4_7Model]]

```python
transformers.MiniCPMV4_7Model(config: MiniCPMV4_7Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L598)

**Parámetros:**

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

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

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, target_sizes: typing.Optional[torch.IntTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, target_sizes_videos: typing.Optional[torch.IntTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: list[torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, downsample_mode: str | None = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = 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/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L668)

**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/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/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`, *opcional*) : Patches de valores de píxel para imágenes, empaquetados con NaViT.

target_sizes (`torch.IntTensor`, *opcional*) : Altura y ancho (en parches) para cada imagen.

pixel_values_videos (`torch.Tensor`, *opcional*) : Patches de valores de píxel para los fotogramas del vídeo, empaquetados con NaViT.

target_sizes_videos (`torch.IntTensor`, *opcional*) : Altura y ancho (en parches) para cada fotograma del video.

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

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

past_key_values (`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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca únicamente los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

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

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

downsample_mode (`str`, *opcional*) : `"4x"` conserva 4 veces más tokens visuales; el valor predeterminado `"16x"` aplica la fusión completa.

mm_token_type_ids (`torch.IntTensor` 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/main/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/main/es/main_classes/processors#transformers.ProcessorMixin.__call__) para obtener más detalles.

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:** [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

El método forward de [MiniCPMV4_7Model](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Model) reemplaza el método especial `__call__`.

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

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

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

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

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

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

#### get_image_features[[transformers.MiniCPMV4_7Model.get_image_features]]

```python
get_image_features(pixel_values: Tensor, target_sizes: IntTensor, downsample_mode: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L608)

**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 usando [MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor). Consulte [MiniCPMV4_6ImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MiniCPMV4_7Processor](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) utiliza [MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor) para procesar las imágenes).

target_sizes (`torch.IntTensor` de forma `(num_images, 2)`) : Altura y ancho (en parches) de cada imagen.

downsample_mode (`str`, *opcional*) : Cuando se establece en `"4x"`, se omite el `vit_merger` intermedio, de modo que cada imagen conserva `4×` más tokens visuales. El modo predeterminado `"16x"` aplica el pipeline de fusión completo.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

Extraer características de imagen: codificador visual, insertar fusionador, luego fusionador MLP.

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

#### get_video_features[[transformers.MiniCPMV4_7Model.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, target_sizes_videos: IntTensor, downsample_mode: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L762)

**Parámetros:**

pixel_values_videos (`torch.Tensor` de forma `(1, channels, patch_size, seq_len)`) : Píxeles en parches empaquetados con NaViT para todos los fotogramas del vídeo. El procesador de vídeo concatena los parches de cada fotograma a lo largo de la última dimensión en una única secuencia con dim-0 = 1, idéntica al formato de empaquetado de imágenes.

target_sizes_videos (`torch.IntTensor` de forma `(num_patches, 2)`) : Altura y ancho (en parches) de cada unidad visual.

downsample_mode (`str`, *opcional*) : Cuando se establece en `"4x"`, se omite el `vit_merger` intermedio, de modo que cada cuadro conserva `4×` más tokens visuales. El modo predeterminado `"16x"` aplica el pipeline de fusión completo.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

Extraer características de video: reempaquetar los fotogramas en formato NaViT y luego aplicar el codificador de visión y el merger.

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

## MiniCPMV4_7ForConditionalGeneration[[transformers.MiniCPMV4_7ForConditionalGeneration]]

#### transformers.MiniCPMV4_7ForConditionalGeneration[[transformers.MiniCPMV4_7ForConditionalGeneration]]

```python
transformers.MiniCPMV4_7ForConditionalGeneration(config: MiniCPMV4_7Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1213)

**Parámetros:**

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

El modelo Minicpmv4 7 para la generación de tokens condicionada en otras modalidades (p. ej., generación de texto a partir de imagen y texto).

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, target_sizes: typing.Optional[torch.IntTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, target_sizes_videos: typing.Optional[torch.IntTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: list[torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, downsample_mode: str | None = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = 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/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1224)

**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/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/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`, *opcional*) : Patches de valores de píxel para imágenes, empaquetados con NaViT.

target_sizes (`torch.IntTensor`, *opcional*) : Altura y ancho (en parches) para cada imagen.

pixel_values_videos (`torch.Tensor`, *opcional*) : Patches de valores de píxel para los fotogramas del vídeo, empaquetados con NaViT.

target_sizes_videos (`torch.IntTensor`, *opcional*) : Altura y ancho (en parches) para cada fotograma del video.

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

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

past_key_values (`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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca únicamente los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

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

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida 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 `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

downsample_mode (`str`, *opcional*) : `"4x"` conserva 4 veces más tokens visuales; el valor predeterminado `"16x"` aplica la fusión completa.

mm_token_type_ids (`torch.IntTensor` 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/main/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/main/es/main_classes/processors#transformers.ProcessorMixin.__call__) para obtener más detalles.

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:** [CausalLMOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

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

El método forward de [MiniCPMV4_7ForConditionalGeneration](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7ForConditionalGeneration) sobrescribe el método especial `__call__`.

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

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

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

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

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

Ejemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### get_image_features[[transformers.MiniCPMV4_7ForConditionalGeneration.get_image_features]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1294)

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

Extraer características de imagen: codificador visual, insertar fusionador, luego fusionador MLP.

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

Ejemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### get_video_features[[transformers.MiniCPMV4_7ForConditionalGeneration.get_video_features]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1298)

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MiniCPMV4_7Config](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) y las entradas.

Extraer características de video: reempaquetar los fotogramas en formato NaViT y luego aplicar el codificador de visión y el merger.

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

Ejemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

## MiniCPMV4_7Processor[[transformers.MiniCPMV4_7Processor]]

#### transformers.MiniCPMV4_7Processor[[transformers.MiniCPMV4_7Processor]]

```python
transformers.MiniCPMV4_7Processor(image_processor = None, video_processor = None, tokenizer = None, chat_template = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/processing_minicpmv4_7.py#L46)

**Parámetros:**

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

video_processor (`MiniCPMV4_6VideoProcessor`) : El procesador de video es una entrada obligatoria.

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

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

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

[MiniCPMV4_7Processor](/docs/transformers/main/es/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) ofrece todas las funcionalidades de [MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor), [MiniCPMV4_6VideoProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6VideoProcessor) y [TokenizersBackend](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~MiniCPMV4_6ImageProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor), [~MiniCPMV4_6VideoProcessor](/docs/transformers/main/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6VideoProcessor) y [~TokenizersBackend](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend) para obtener más información.

#### __llamada__[[transformers.MiniCPMV4_7Processor.__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.models.minicpmv4_7.processing_minicpmv4_7.MiniCPMV4_7ProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpmv4_7/processing_minicpmv4_7.py#L69)

**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_tensors (`str` o [TensorType](/docs/transformers/main/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/main/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.