# MiniCPM-OCR MiniCPM-OCR es un modelo de comprensión de documentos de la familia [MiniCPM-V](https://huggingface.co/papers/2509.18154) desarrollado por [OpenBMB](https://github.com/OpenBMB). Mantiene la arquitectura de [MiniCPM-V 4.6](./minicpmv4_6) -- un codificador visual [SigLIP](./siglip) con un fusionador de atención por ventana delante de un modelo de lenguaje [Qwen3.5](./qwen3_5) -- y lo especializa para leer imágenes con mucha densidad de texto, como páginas escaneadas, capturas de pantalla, recibos y tablas. Este modelo fue aportado por [OpenBMB](https://huggingface.co/openbmb). El código original se puede encontrar [aquí](https://github.com/openbmb/MiniCPM-OCR). ## Ejemplo de uso ```python from transformers import pipeline messages = [ { "role": "user", "content": [ { "type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_receipt.jpeg", }, {"type": "text", "text": "Transcribe all the text in this document."}, ], }, ] pipe = pipeline("image-text-to-text", model="openbmb/MiniCPM-OCR-1.0") outputs = pipe(text=messages, max_new_tokens=256, return_full_text=False) print(outputs[0]["generated_text"]) # # # Document No : TD01167104 # Date : 25/12/2018 8:13:39 PM # Cashier : MANIS # Member : # CASH BILL # CODE/DESC PRICE Disc AMOUNT # QTY RM RM # 9556939040118 KF MODELLING CLAY KIDDY FISH # 1 PC * 9.00 0.00 9.00 # Total : 9.00 # Rounding Adjustment : 0.00 # Round-d Total (RM) : 9.00 ``` ```python from transformers import AutoModelForImageTextToText, AutoProcessor model_id = "openbmb/MiniCPM-OCR-1.0" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto") messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"}, {"type": "text", "text": "Convert this page to markdown."}, ], } ] 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=512) decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) print(decoded_output) # ```markdown # R&D QUALITY IMPROVEMENT # SUGGESTION/SOLUTION FORM # # Name/Phone Ext.: M. Hamann, P. Harper, P. Martinez Date: 9/3/92 # # Supervisor/Manager: J. S. Wigand R&D Group: Licensee # ... # ``` ``` La plantilla de chat del punto de control publicado deshabilita el razonamiento de forma predeterminada. Pasa `enable_thinking=True` a `apply_chat_template` para habilitarlo explícitamente. MiniCPM-OCR admite ambos modos de submuestreo visual de la familia MiniCPM-V: - **4x** (predeterminado): Menos submuestreo, más tokens visuales, lo que se necesita para la transcripción de documentos y capturas de pantalla. - **16x**: Submuestreo más agresivo, menos tokens visuales, inferencia más rápida en imágenes naturales. El modo debe pasarse al procesador y a `model.generate` a la vez, porque el procesador cuenta los marcadores de posición visuales que se espera que produzca la torre de visión: ```python from transformers import AutoModelForImageTextToText, AutoProcessor model_id = "openbmb/MiniCPM-OCR-1.0" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto") messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"}, {"type": "text", "text": "Convert this page to markdown."}, ], } ] 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=512, downsample_mode="4x") print((inputs["input_ids"] == model.config.image_token_id).sum().item()) # 1260 visual tokens; the same page in `"16x"` mode is 315 instead ``` Un `downsample_mode` por llamada se aplica solo a esa llamada y deja el procesador sin cambios, por lo que el mismo procesador puede atender ambos modos de forma concurrente. Al llamar al procesador directamente en lugar de pasar por `apply_chat_template`, pásalo como un argumento de palabra clave normal: ```python inputs = processor(images=[image], text=[text], return_tensors="pt", downsample_mode="4x") ``` Para establecer un modo como predeterminado, configúrelo al cargar el procesador: ```python processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0", downsample_mode="4x") ``` Las imágenes demasiado pequeñas para dividirse se escalan por defecto a `scale_resolution`, que es la configuración con la que se entrenó el punto de control publicado. Las capturas de pantalla y los recortes suelen conservarse mejor en su resolución nativa, ya que el escalado solo difumina los glifos, por lo que `small_image_upsize` permite elegir entre ambas opciones: - `"always"` (predeterminado): se amplían hasta `scale_resolution`. - `"never"`: manténgalos en su resolución nativa, alineados solo a la cuadrícula de parches. - `"adaptive"`: decide por imagen y por rebanada, en función del tamaño y la densidad del glifo. ```python from transformers import AutoProcessor from transformers.image_utils import load_image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_receipt.jpeg" image = load_image(url).resize((224, 224)) processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0") messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Read the text."}]}] text = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=False) print(processor(images=[image], text=[text], return_tensors="pt")["target_sizes"].tolist()) # [[32, 32]] -- upscaled to `scale_resolution` processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0", small_image_upsize="never") print(processor(images=[image], text=[text], return_tensors="pt")["target_sizes"].tolist()) # [[16, 16]] -- 224 / 14 patches per side, no upscaling ``` `"adaptive"` aumenta la escala del texto denso de tamaño pequeño hasta `scale_resolution`, las imágenes de menos de 6272 píxeles hasta 84, y mantiene el resto en su resolución nativa; en una porción, nunca consume más tokens que la tesela de referencia. La altura y la densidad de los glifos se miden mediante un umbral de Otsu seguido de un análisis de componentes conectados, por lo que requiere [OpenCV](https://pypi.org/project/opencv-python/) y lanza una excepción si no está disponible, en lugar de aplicar silenciosamente una regla alternativa. ```python processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0", small_image_upsize="adaptive") print(processor(images=[image], text=[text], return_tensors="pt")["target_sizes"].tolist()) # [[32, 32]] -- dense text detected, so this one is upscaled anyway ``` Al igual que `downsample_mode`, también se puede sobrescribir en cada llamada, lo que permite mantener el recibo de 224x224 en su resolución nativa sin recargar el procesador: ```python inputs = processor(images=[image], text=[text], return_tensors="pt", small_image_upsize="never") print(inputs["target_sizes"].tolist()) # [[16, 16]] -- 224 / 14 patches per side, no upscaling ``` ```python from transformers import AutoModelForImageTextToText, AutoProcessor model_id = "openbmb/MiniCPM-OCR-1.0" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto") messages = [ [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_receipt.jpeg"}, {"type": "text", "text": "Transcribe all the text in this document."}, ], } ], [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"}, {"type": "text", "text": "Transcribe all the text in this document."}, ], } ], ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", processor_kwargs={"padding": True}, ).to(model.device, dtype=model.dtype) output = model.generate(**inputs, max_new_tokens=256) decoded_outputs = processor.batch_decode(output[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True) print(decoded_outputs[0]) # Document No : TD01167104 # Date : 25/12/2018 8:13:39 PM # Cashier : MANIS # ... print(decoded_outputs[1]) # R&D QUALITY IMPROVEMENT # SUGGESTION/SOLUTION FORM # # Name/Phone Ext.: M. Hamann P. Harper P. Martinez Date: 9/3/92 # Supervisor/Manager: J. S. Wigand R&D Group: Licensee # ... ``` Las dos páginas se redimensionan de forma independiente, por lo que sus prompts tienen longitudes diferentes. `padding` debe solicitarse a través de `processor_kwargs` para que `apply_chat_template` lo reenvíe al procesador, y el procesador rellena a la izquierda para que `generate` siga generando desde el final de cada prompt. ## MiniCPMOcrConfig[[transformers.MiniCPMOcrConfig]] #### transformers.MiniCPMOcrConfig[[transformers.MiniCPMOcrConfig]] ```python transformers.MiniCPMOcrConfig(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_token_id: int | None = None, video_token_id: int | None = None, tie_word_embeddings: bool = True, downsample_mode: str = '4x', merge_kernel_size: tuple[int, int] | list[int] = (2, 2), merger_times: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/configuration_minicpm_ocr.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_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 `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo. downsample_mode (`str`, *opcional*, valor predeterminado `"4x"`) : Relación de reducción de tokens visuales. `"4x"` conserva 4 veces más tokens que `"16x"`, que es la relación con la que se leen las imágenes de documentos con mucho texto. 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 MiniCPMOcrModel. Se utiliza para instanciar un modelo Minicpm Ocr 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-OCR-1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) 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. ## MiniCPMOcrVisionConfig[[transformers.MiniCPMOcrVisionConfig]] #### transformers.MiniCPMOcrVisionConfig[[transformers.MiniCPMOcrVisionConfig]] ```python transformers.MiniCPMOcrVisionConfig(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/minicpm_ocr/configuration_minicpm_ocr.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 MiniCPMOcrModel. Se utiliza para instanciar un modelo Minicpm Ocr 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-OCR-1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) 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. ## MiniCPMOcrVisionPreTrainedModel[[transformers.MiniCPMOcrVisionPreTrainedModel]] #### transformers.MiniCPMOcrVisionPreTrainedModel[[transformers.MiniCPMOcrVisionPreTrainedModel]] ```python transformers.MiniCPMOcrVisionPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L396) #### forward[[transformers.MiniCPMOcrVisionPreTrainedModel.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. ## MiniCPMOcrVisionModel[[transformers.MiniCPMOcrVisionModel]] #### transformers.MiniCPMOcrVisionModel[[transformers.MiniCPMOcrVisionModel]] ```python transformers.MiniCPMOcrVisionModel(config: MiniCPMOcrVisionConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L410) #### forward[[transformers.MiniCPMOcrVisionModel.forward]] ```python forward(pixel_values, target_sizes: typing.Optional[torch.IntTensor] = None, use_vit_merger: bool = True, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L442) **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 mediante [MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor). Consulte [MiniCPMOcrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([MiniCPMOcrProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) utiliza [MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor) 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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) y las entradas. El método forward de [MiniCPMOcrVisionModel](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrVisionModel) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. ## MiniCPMOcrModel[[transformers.MiniCPMOcrModel]] #### transformers.MiniCPMOcrModel[[transformers.MiniCPMOcrModel]] ```python transformers.MiniCPMOcrModel(config: MiniCPMOcrConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L593) **Parámetros:** config ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) : 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 MiniCPMOcr, 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.MiniCPMOcrModel.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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.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/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_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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) y las entradas. El método forward de [MiniCPMOcrModel](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrModel) 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.MiniCPMOcrModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, target_sizes: IntTensor, downsample_mode: str | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.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 usando [MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor). Consulte [MiniCPMOcrImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MiniCPMOcrProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) utiliza [MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor) 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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) 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.MiniCPMOcrModel.get_video_features]] ```python get_video_features(pixel_values_videos: Tensor, target_sizes_videos: IntTensor, downsample_mode: str | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L743) **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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) 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. ## MiniCPMOcrForConditionalGeneration[[transformers.MiniCPMOcrForConditionalGeneration]] #### transformers.MiniCPMOcrForConditionalGeneration[[transformers.MiniCPMOcrForConditionalGeneration]] ```python transformers.MiniCPMOcrForConditionalGeneration(config: MiniCPMOcrConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L779) **Parámetros:** config ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) : 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 Minicpm Ocr 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.MiniCPMOcrForConditionalGeneration.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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.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/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_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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) y las entradas. El método forward de [MiniCPMOcrForConditionalGeneration](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrForConditionalGeneration) 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, MiniCPMOcrForConditionalGeneration >>> model = MiniCPMOcrForConditionalGeneration.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> 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.MiniCPMOcrForConditionalGeneration.get_image_features]] ```python get_image_features(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L854) **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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) 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, MiniCPMOcrForConditionalGeneration >>> model = MiniCPMOcrForConditionalGeneration.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> 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.MiniCPMOcrForConditionalGeneration.get_video_features]] ```python get_video_features(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L858) **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 ([MiniCPMOcrConfig](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) 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, MiniCPMOcrForConditionalGeneration >>> model = MiniCPMOcrForConditionalGeneration.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0") >>> 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] ``` ## MiniCPMOcrProcessor[[transformers.MiniCPMOcrProcessor]] #### transformers.MiniCPMOcrProcessor[[transformers.MiniCPMOcrProcessor]] ```python transformers.MiniCPMOcrProcessor(image_processor = None, video_processor = None, tokenizer = None, chat_template = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/processing_minicpm_ocr.py#L46) **Parámetros:** image_processor (`MiniCPMOcrImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio. video_processor (`MiniCPMOcrVideoProcessor`) : 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 MiniCPMOcrProcessor que encapsula un procesador de imágenes, un procesador de video y un tokenizador en un único procesador. [MiniCPMOcrProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) ofrece todas las funcionalidades de [MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor), [MiniCPMOcrVideoProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrVideoProcessor) y [TokenizersBackend](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~MiniCPMOcrImageProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor), [~MiniCPMOcrVideoProcessor](/docs/transformers/main/es/model_doc/minicpm_ocr#transformers.MiniCPMOcrVideoProcessor) y [~TokenizersBackend](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend) para obtener más información. #### __llamada__[[transformers.MiniCPMOcrProcessor.__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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/processing_minicpm_ocr.py#L82) **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 (`N`) 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. ## MiniCPMOcrImageProcessor[[transformers.MiniCPMOcrImageProcessor]] #### transformers.MiniCPMOcrImageProcessor[[transformers.MiniCPMOcrImageProcessor]] ```python transformers.MiniCPMOcrImageProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/image_processing_minicpm_ocr.py#L139) **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 *{"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 *"4x"*) : Modo de reducción de tokens visuales. *"4x"* conserva 4 veces más tokens que *"16x"*, que aplica la fusión completa. Se admite la sobrescritura en cada llamada. use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`N`) 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. small_image_upsize (*str*, *kwargs*, *opcional*, valor predeterminado *"always"*) : Cómo se redimensionan las imágenes y las secciones que no superan *scale_resolution* al cuadrado. *"always"* las escala hacia arriba hasta *scale_resolution*, *"never"* mantiene su resolución nativa alineada con la cuadrícula de parches, y *"adaptive"* selecciona por imagen y por sección en función del tamaño y la densidad del glifo (requiere OpenCV, ver [*adaptive_upsize_resolution*]). Construye un procesador de imágenes MiniCPMOcrImageProcessor. #### preprocess[[transformers.MiniCPMOcrImageProcessor.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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/image_processing_minicpm_ocr.py#L246) **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 *{"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 *"4x"*) : Modo de reducción de tokens visuales. *"4x"* conserva 4 veces más tokens que *"16x"*, que aplica la fusión completa. Se admite la sobrescritura en cada llamada. use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`N`) 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. small_image_upsize (*str*, *kwargs*, *opcional*, valor predeterminado *"always"*) : Cómo se redimensionan las imágenes y las secciones que no superan *scale_resolution* al cuadrado. *"always"* las escala hacia arriba hasta *scale_resolution*, *"never"* mantiene su resolución nativa alineada con la cuadrícula de parches, y *"adaptive"* selecciona por imagen y por sección en función del tamaño y la densidad del glifo (requiere OpenCV, ver [*adaptive_upsize_resolution*]). **Devuelve:** `*~feature_extraction_utils.BatchFeature*` - **data** (*dict*, *opcional*) -- Diccionario de listas/arrays/tensores devueltos por los métodos __call__/pad ('input_values', 'attention_mask', 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. - **skip_tensor_conversion** (*list[str]* o *set[str]*, *opcional*) -- Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especifica *tensor_type*. ## MiniCPMOcrVideoProcessor[[transformers.MiniCPMOcrVideoProcessor]] #### transformers.MiniCPMOcrVideoProcessor[[transformers.MiniCPMOcrVideoProcessor]] ```python transformers.MiniCPMOcrVideoProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/video_processing_minicpm_ocr.py#L77) **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 *"4x"*) : Modo de reducción de tokens visuales. *"4x"* conserva 4 veces más tokens que *"16x"*, que aplica la fusión completa. use_image_id (*bool*, *kwargs*, *opcional*, valor predeterminado *True*) : Indica si se debe añadir una etiqueta de identificador de imagen (`N`) 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 MiniCPMOcrVideoProcessor. #### preprocess[[transformers.MiniCPMOcrVideoProcessor.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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/video_processing_minicpm_ocr.py#L292) **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:** `~feature_extraction_utils.BatchFeature` - **data** (`dict`, *opcional*) -- Diccionario de listas/arrays/tensores devueltos por los métodos __call__/pad ('input_values', 'attention_mask', 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. - **skip_tensor_conversion** (`list[str]` o `set[str]`, *opcional*) -- Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especifica `tensor_type`.