# MiniCPM-V

[MiniCPM-V](https://huggingface.co/papers/2509.18154) es una serie de modelos de lenguaje multimodales eficientes desarrollados por [OpenBMB](https://github.com/OpenBMB). La arquitectura de MiniCPM-V 4.6 utiliza 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.

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

## 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_6")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]
```

### Inferencia en una sola imagen

> [!NOTE]
> El modelo se ha entrenado con un formato de prompt específico para chatear. Use `processor.apply_chat_template(my_conversation_dict)` para formatear correctamente sus prompts.

```python
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "openbmb/MiniCPM-V-4_6"
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.6 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)
```

### Backend de procesamiento de imágenes

MiniCPM-V 4.6 ofrece dos backends de procesamiento de imágenes:

- **torchvision** (predeterminado): Utiliza `torchvision.transforms` para redimensionar imágenes.
- **pil**: Utiliza `PIL.Image.resize`, coincidiendo con la implementación original.

Para usar el backend PIL:

```python
from transformers import AutoProcessor, AutoImageProcessor

processor = AutoProcessor.from_pretrained(model_checkpoint)
processor.image_processor = AutoImageProcessor.from_pretrained(model_checkpoint, backend="pil")
```

### Inferencia de video

MiniCPM-V 4.6 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)
```

Si ya tienes la cadena de texto del prompt renderizado, puedes llamar directamente a `processor(text=..., videos=[...])` en su lugar.

## MiniCPMV4_6Config[[transformers.MiniCPMV4_6Config]]

#### transformers.MiniCPMV4_6Config[[transformers.MiniCPMV4_6Config]]

```python
transformers.MiniCPMV4_6Config(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, drop_vision_last_layer: bool = False, 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/configuration_minicpmv4_6.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) : Resolución base para el preprocesamiento de imágenes.

drop_vision_last_layer (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe eliminar la última capa del codificador de visión.

image_token_id (`int`, *opcional*) : Id del token utilizado como marcador de posición de la imagen.

video_token_id (`int`, *opcional*) : Id del token utilizado como marcador de posición del vídeo.

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.

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

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

## MiniCPMV4_6VisionConfig[[transformers.MiniCPMV4_6VisionConfig]]

#### transformers.MiniCPMV4_6VisionConfig[[transformers.MiniCPMV4_6VisionConfig]]

```python
transformers.MiniCPMV4_6VisionConfig(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/v5.23.0/src/transformers/models/minicpmv4_6/configuration_minicpmv4_6.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_6Model. Se utiliza para instanciar un modelo Minicpmv4 6 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.6](https://huggingface.co/openbmb/MiniCPM-V-4.6)

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

## MiniCPMV4_6Model[[transformers.MiniCPMV4_6Model]]

#### transformers.MiniCPMV4_6Model[[transformers.MiniCPMV4_6Model]]

```python
transformers.MiniCPMV4_6Model(config: MiniCPMV4_6Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.py#L593)

**Parámetros:**

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

El modelo MiniCPMV4_6, 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

#### forward[[transformers.MiniCPMV4_6Model.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_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.py#L662)

**Parámetros:**

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

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/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca ú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_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/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.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 ([MiniCPMV4_6Config](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6Config)) y las entradas.

El método forward de [MiniCPMV4_6Model](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6Model) 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/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

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

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

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

#### get_image_features[[transformers.MiniCPMV4_6Model.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/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.py#L602)

**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 utilizando [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor). Consulte [MiniCPMV4_6ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MiniCPMV4_6Processor](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6Processor) utiliza [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/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/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.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 ([MiniCPMV4_6Config](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6Config)) 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.

## MiniCPMV4_6ForConditionalGeneration[[transformers.MiniCPMV4_6ForConditionalGeneration]]

#### transformers.MiniCPMV4_6ForConditionalGeneration[[transformers.MiniCPMV4_6ForConditionalGeneration]]

```python
transformers.MiniCPMV4_6ForConditionalGeneration(config: MiniCPMV4_6Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.py#L779)

**Parámetros:**

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

El modelo Minicpmv4 6 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

#### forward[[transformers.MiniCPMV4_6ForConditionalGeneration.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_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.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.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca ú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_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/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

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

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

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

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

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

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

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

Ejemplo:

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

>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")

>>> 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_6ForConditionalGeneration.get_image_features]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/modeling_minicpmv4_6.py#L854)

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

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.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 ([MiniCPMV4_6Config](/docs/transformers/v5.23.0/es/model_doc/minicpmv4_6#transformers.MiniCPMV4_6Config)) 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_6ForConditionalGeneration

>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")

>>> 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_6Processor[[transformers.MiniCPMV4_6Processor]]

#### transformers.MiniCPMV4_6Processor[[transformers.MiniCPMV4_6Processor]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/processing_minicpmv4_6.py#L38)

**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_6Processor que encapsula un procesador de imágenes, un procesador de video y un tokenizador en un único procesador.

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

#### __llamada__[[transformers.MiniCPMV4_6Processor.__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_6.processing_minicpmv4_6.MiniCPMV4_6ProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/processing_minicpmv4_6.py#L74)

**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 lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si pasa una entrada pretokenizada, establezca *is_split_into_words=True* para evitar ambigüedad con las entradas por lotes.

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]]]*, *optional*) : Video a preprocesar. 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.

use_image_id (*bool*, *kwargs*, *opcional*) : Si se debe anteponer una etiqueta de id de imagen (`<image_id>N</image_id>`) antes de cada marcador de posición de imagen. Si no se establece, el valor predeterminado es *use_image_id* del procesador de imágenes.

return_tensors (*str* o [*~utils.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*], *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.

## MiniCPMV4_6ImageProcessor[[transformers.MiniCPMV4_6ImageProcessor]]

#### transformers.MiniCPMV4_6ImageProcessor[[transformers.MiniCPMV4_6ImageProcessor]]

```python
transformers.MiniCPMV4_6ImageProcessor(**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/image_processing_minicpmv4_6.py#L68)

**Parámetros:**

do_convert_rgb (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica 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*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe usar una imagen cuadrada de forma predeterminada al redimensionar, si size 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 *3*) : 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*, *optional*, por defecto *True*) : 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*) : Indica 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 que se usará para la normalización. Solo tiene efecto si *do_normalize* está establecido en *True*.

do_pad (*bool*, *kwargs*, *optional*) : 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 *&amp;lcub;"height": int, "width" int}* al que rellener 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 debería establecerse como un atributo del procesador.

max_slice_nums (*int*, *kwargs*, *optional*, valor predeterminado 9) : Número máximo de fragmentos al dividir una imagen de alta resolución.

scale_resolution (*int*, *kwargs*, *optional*, valor predeterminado 448) : Resolución objetivo para las rebanadas individuales.

patch_size (*int*, *kwargs*, *optional*, valor predeterminado 14) : Tamaño del parche espacial del codificador de visión.

slice_mode (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Si se deben dividir las imágenes en varias porciones para obtener una mayor resolución.

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

use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`<image_id>N</image_id>`) antes de cada marcador de posición de imagen. La usa el Processor para generar los marcadores de posición, no el propio pipeline de procesamiento de imágenes.

Construye un procesador de imágenes MiniCPMV4_6ImageProcessor.

#### preprocess[[transformers.MiniCPMV4_6ImageProcessor.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.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/image_processing_minicpmv4_6.py#L174)

**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*) : Indica 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 se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int.

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*) : Indica 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*) : Indica 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*, *optional*) : 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 *&amp;lcub;"height": int, "width" int}* al que rellener 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 debería establecerse como un atributo del procesador.

max_slice_nums (*int*, *kwargs*, *optional*, valor predeterminado 9) : Número máximo de fragmentos al dividir una imagen de alta resolución.

scale_resolution (*int*, *kwargs*, *optional*, valor predeterminado 448) : Resolución objetivo para las rebanadas individuales.

patch_size (*int*, *kwargs*, *optional*, valor predeterminado 14) : Tamaño del parche espacial del codificador de visión.

slice_mode (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Si se deben dividir las imágenes en varias porciones para obtener una mayor resolución.

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

use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`<image_id>N</image_id>`) antes de cada marcador de posición de imagen. La usa el Processor para generar los marcadores de posición, no el propio pipeline de procesamiento de imágenes.

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

## MiniCPMV4_6ImageProcessorPil[[transformers.MiniCPMV4_6ImageProcessorPil]]

#### transformers.MiniCPMV4_6ImageProcessorPil[[transformers.MiniCPMV4_6ImageProcessorPil]]

```python
transformers.MiniCPMV4_6ImageProcessorPil(**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/image_processing_pil_minicpmv4_6.py#L69)

**Parámetros:**

- ****kwargs** (`MiniCPMV4_6ImageProcessorPilKwargs`, *opcional*) : Opciones adicionales de preprocesamiento de imágenes. Los kwargs específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de imágenes MiniCPMV4_6ImageProcessor.

#### preprocess[[transformers.MiniCPMV4_6ImageProcessorPil.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.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/image_processing_pil_minicpmv4_6.py#L173)

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

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

- ****kwargs** (`MiniCPMV4_6ImageProcessorPilKwargs`, *opcional*) : Opciones adicionales de preprocesamiento de imágenes. Los kwargs específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

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

## MiniCPMV4_6VideoProcessor[[transformers.MiniCPMV4_6VideoProcessor]]

#### transformers.MiniCPMV4_6VideoProcessor[[transformers.MiniCPMV4_6VideoProcessor]]

```python
transformers.MiniCPMV4_6VideoProcessor(**kwargs: *<class 'transformers.models.minicpmv4_6.video_processing_minicpmv4_6.MiniCPMV4_6VideoProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/video_processing_minicpmv4_6.py#L84)

**Parámetros:**

do_convert_rgb (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica 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*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe usar una imagen cuadrada de forma predeterminada al redimensionar, si size es un entero.

resample (*Annotated[Union[int, PILImageResampling, NoneType], None]*, *kwargs*, por defecto *3*) : 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*, *optional*, por defecto *True*) : 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*) : Indica 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 que se usará 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*, *optional*) : 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á 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*) : Número máximo de fotogramas a muestrear cuando *do_sample_frames=True*.

return_metadata (*bool*, *kwargs*, *optional*, por defecto *False*) : Indica si se deben devolver los metadatos del vídeo o no. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, 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 en particular. Los valores aceptables son:  - *'pt'*: Devuelve objetos *torch.Tensor* de PyTorch. - *'np'*: Devuelve objetos *np.ndarray* de NumPy.

max_num_frames (*int*, *kwargs*, *optional*, valor predeterminado 128) : Número máximo de fotogramas principales a muestrear por video.

stack_frames (*int*, *kwargs*, *optional*, valor predeterminado 1) : Subtramas por segundo para apilar. `1` desactiva el apilamiento.

max_slice_nums (*int*, *kwargs*, *optional*, valor predeterminado 9) : Número máximo de fragmentos al dividir una imagen de alta resolución.

scale_resolution (*int*, *kwargs*, *optional*, valor predeterminado 448) : Resolución objetivo para las rebanadas individuales.

patch_size (*int*, *kwargs*, *optional*, valor predeterminado 14) : Tamaño del parche espacial del codificador de visión.

slice_mode (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Si se deben dividir las imágenes en varias porciones para obtener una mayor resolución.

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

use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`<image_id>N</image_id>`) antes de cada marcador de posición de imagen. La usa el Processor para generar los marcadores de posición, no el propio pipeline de procesamiento de imágenes.

- ****kwargs** ([*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 MiniCPMV4_6VideoProcessor.

#### preprocess[[transformers.MiniCPMV4_6VideoProcessor.preprocess]]

```python
preprocess(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]]], **kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_6/video_processing_minicpmv4_6.py#L299)

**Parámetros:**

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]]]`) : 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`.

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.

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_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*) : Indica si se deben muestrear fotogramas del vídeo antes de procesarlo o si se debe procesar el vídeo 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*) : Número máximo de fotogramas a muestrear cuando `do_sample_frames=True`.

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

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.

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

