# MiniCPM-OCR MiniCPM-OCR é um modelo de compreensão de documentos da família [MiniCPM-V](https://huggingface.co/papers/2509.18154), desenvolvido pela [OpenBMB](https://github.com/OpenBMB). Ele mantém a arquitetura do [MiniCPM-V 4.6](./minicpmv4_6) -- um codificador de visão [SigLIP](./siglip) com um mesclador de atenção por janela à frente de um modelo de linguagem [Qwen3.5](./qwen3_5) -- e o especializa para a leitura de imagens densas em texto, como páginas digitalizadas, capturas de tela, recibos e tabelas. Este modelo foi contribuído por [OpenBMB](https://huggingface.co/openbmb). O código original pode ser encontrado [aqui](https://github.com/openbmb/MiniCPM-OCR). ## Exemplo 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 # ... # ``` ``` O template de chat do checkpoint liberado desativa o raciocínio por padrão. Passe `enable_thinking=True` para `apply_chat_template` para ativá-lo explicitamente. O MiniCPM-OCR suporta os dois modos de subamostragem visual da família MiniCPM-V: - **4x** (padrão): menos redução de amostragem, mais tokens visuais, o que é necessário para a transcrição de documentos e capturas de tela. - **16x**: Downsampling mais agressivo, menos tokens visuais, inferência mais rápida em imagens naturais. O modo precisa ser passado para o processador e para `model.generate` juntos, pois o processador conta os placeholders visuais que a torre de visão deve produzir: ```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 ``` O `downsample_mode` por chamada se aplica apenas a essa chamada e não altera o processador, permitindo que o mesmo processador atenda ambos os modos simultaneamente. Ao chamar o processador diretamente, em vez de usar `apply_chat_template`, passe-o como um argumento de palavra-chave simples: ```python inputs = processor(images=[image], text=[text], return_tensors="pt", downsample_mode="4x") ``` Para definir um modo como padrão, configure-o ao carregar o processador: ```python processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-1.0", downsample_mode="4x") ``` Imagens pequenas demais para serem fatiadas são ampliadas para `scale_resolution` por padrão, que é a configuração com a qual o checkpoint publicado foi treinado. Capturas de tela e recortes geralmente ficam melhores mantidas em sua resolução nativa, onde a ampliação apenas embaça os glifos, portanto `small_image_upsize` seleciona entre as duas opções: - `"always"` (padrão): aumenta a resolução para `scale_resolution`. - `"never"`: mantenha-os na resolução nativa, alinhados apenas à grade de patches. - `"adaptive"`: decide por imagem e por fatia, com base no tamanho e na densidade do 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 a escala de textos densos pequenos para `scale_resolution`, imagens com menos de 6272 pixels para 84 e mantém as demais no tamanho nativo; em uma fatia, ele nunca gasta mais tokens do que o tile de referência. A altura e a densidade dos glifos são medidas com um limiar de Otsu seguido de análise de componentes conectados, portanto é necessário [OpenCV](https://pypi.org/project/opencv-python/) e, na ausência dele, uma exceção é lançada, em vez de recorrer silenciosamente a uma regra diferente. ```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 ``` Assim como `downsample_mode`, ele também pode ser sobrescrito a cada chamada, o que mantém o recibo de 224x224 em sua resolução nativa sem recarregar o processador: ```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 # ... ``` As duas páginas são redimensionadas de forma independente, portanto seus prompts têm comprimentos diferentes. `padding` precisa ser solicitado por meio de `processor_kwargs` para que `apply_chat_template` o encaminhe ao processador, e o processador aplica `padding` à esquerda para que `generate` continue produzindo a partir do 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) ``` [Origem](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*) : O objeto de configuração ou dicionário do backbone de texto. vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. insert_layer_id (`int`, *opcional*, padrão 6) : Índice da camada do codificador de visão após a qual o mesclador de atenção em janela é aplicado. image_token_id (`int`, *opcional*) : O índice do token de imagem usado como marcador de posição para as imagens de entrada. video_token_id (`int`, *opcional*) : O índice do token de vídeo usado como marcador de posição para os vídeos de entrada. tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. downsample_mode (`str`, *opcional*, padrão `"4x"`) : Razão de downsampling de tokens visuais. `"4x"` mantém 4× mais tokens do que `"16x"`, que é o valor usado para ler imagens de documentos com muita densidade de texto. merge_kernel_size (`tuple[int, int]`, *opcional*, padrão `(2, 2)`) : Tamanho do kernel `(h, w)` para mesclar patches visuais adjacentes no Merger. merger_times (`int`, *opcional*, padrão 1) : Número de rodadas iterativas de mesclagem no Merger. Esta é a classe de configuração para armazenar a configuração de um MiniCPMOcrModel. Ela é usada para instanciar um modelo Minicpm Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [openbmb/MiniCPM-OCR-1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ## 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)) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/configuration_minicpm_ocr.py#L31) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `224`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. insert_layer_id (`int`, *opcional*, padrão 6) : Índice da camada do codificador de visão após a qual o mesclador de atenção em janela é aplicado. window_kernel_size (`tuple[int, int]`, *opcional*, padrão `(2, 2)`) : Tamanho da janela `(h, w)` para o merger de atenção em janela intermediário. Esta é a classe de configuração para armazenar a configuração de um MiniCPMOcrModel. Ela é usada para instanciar um modelo Minicpm Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [openbmb/MiniCPM-OCR-1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ## MiniCPMOcrVisionPreTrainedModel[[transformers.MiniCPMOcrVisionPreTrainedModel]] #### transformers.MiniCPMOcrVisionPreTrainedModel[[transformers.MiniCPMOcrVisionPreTrainedModel]] ```python transformers.MiniCPMOcrVisionPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Origem](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) ``` Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock. ## MiniCPMOcrVisionModel[[transformers.MiniCPMOcrVisionModel]] #### transformers.MiniCPMOcrVisionModel[[transformers.MiniCPMOcrVisionModel]] ```python transformers.MiniCPMOcrVisionModel(config: MiniCPMOcrVisionConfig) ``` [Origem](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: *) ``` [Origem](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)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor). Consulte [MiniCPMOcrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para mais detalhes ([MiniCPMOcrProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) usa [MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor) para processar imagens). target_sizes (`torch.IntTensor` de forma `(batch_size, 2)`, *opcional*) : Tamanhos da grade de patches `(h, w)` para o cálculo dos embeddings de posição. use_vit_merger (`bool`, *opcional*, padrão `True`) : Se deve aplicar o mesclador de atenção em janela do ViT após o codificador. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. O método forward do [MiniCPMOcrVisionModel](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrVisionModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## MiniCPMOcrModel[[transformers.MiniCPMOcrModel]] #### transformers.MiniCPMOcrModel[[transformers.MiniCPMOcrModel]] ```python transformers.MiniCPMOcrModel(config: MiniCPMOcrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L593) **Parâmetros:** config ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo MiniCPMOcr, que consiste em um backbone de visão e um modelo de linguagem, sem uma cabeça de modelagem de linguagem. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) pixel_values (`torch.Tensor`, *opcional*) : Patches de valores de pixels para imagens, empacotados pelo NaViT. target_sizes (`torch.IntTensor`, *opcional*) : Altura e largura (em patches) para cada imagem. pixel_values_videos (`torch.Tensor`, *opcional*) : Patches de valores de pixels para quadros de vídeo, empacotados no formato NaViT. target_sizes_videos (`torch.IntTensor`, *opcional*) : Altura e largura (em patches) para cada quadro de vídeo. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`list[torch.Tensor]`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas instâncias de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) são permitidas como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). downsample_mode (`str`, *opcional*) : `"4x"` mantém 4x mais tokens visuais; o padrão `"16x"` aplica a mesclagem completa. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto. **Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. O método forward do [MiniCPMOcrModel](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. #### get_image_features[[transformers.MiniCPMOcrModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, target_sizes: IntTensor, downsample_mode: str | None = None, **kwargs: *) ``` [Origem](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)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor). Veja [MiniCPMOcrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([MiniCPMOcrProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) usa [MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor) para processar imagens). target_sizes (`torch.IntTensor` de forma `(num_images, 2)`) : Altura e largura (em patches) de cada imagem. downsample_mode (`str`, *opcional*) : Quando definido como `"4x"`, o `vit_merger` intermediário é ignorado, de modo que cada imagem mantém `4×` mais tokens visuais. O modo padrão `"16x"` aplica o pipeline completo de mesclagem. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. Extração de características de imagem: codificador de visão, inserção do merger, em seguida, o merger MLP. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. #### 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: *) ``` [Origem](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)`) : patches de pixels empacotados pelo NaViT para todos os quadros do vídeo. O processador de vídeo concatena os patches de cada quadro ao longo da última dimensão em uma única sequência com dim-0 = 1, idêntico ao formato de empacotamento de imagem. target_sizes_videos (`torch.IntTensor` de forma `(num_patches, 2)`) : Altura e largura (em patches) de cada unidade visual. downsample_mode (`str`, *opcional*) : Quando definido como `"4x"`, o `vit_merger` intermediário é ignorado, de modo que cada quadro mantém `4×` mais tokens visuais. O modo padrão `"16x"` aplica o pipeline completo de mesclagem. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. Extraia recursos de vídeo: reorganize os quadros no formato NaViT e, em seguida, aplique o codificador de visão + mesclador. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## MiniCPMOcrForConditionalGeneration[[transformers.MiniCPMOcrForConditionalGeneration]] #### transformers.MiniCPMOcrForConditionalGeneration[[transformers.MiniCPMOcrForConditionalGeneration]] ```python transformers.MiniCPMOcrForConditionalGeneration(config: MiniCPMOcrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L779) **Parâmetros:** config ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Minicpm Ocr para geração de tokens condicionada a outras modalidades (por exemplo, geração de texto a partir de imagem e texto). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) pixel_values (`torch.Tensor`, *opcional*) : Patches de valores de pixels para imagens, empacotados pelo NaViT. target_sizes (`torch.IntTensor`, *opcional*) : Altura e largura (em patches) para cada imagem. pixel_values_videos (`torch.Tensor`, *opcional*) : Patches de valores de pixels para quadros de vídeo, empacotados no formato NaViT. target_sizes_videos (`torch.IntTensor`, *opcional*) : Altura e largura (em patches) para cada quadro de vídeo. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`list[torch.Tensor]`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas instâncias de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) são permitidas como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). downsample_mode (`str`, *opcional*) : `"4x"` mantém 4x mais tokens visuais; o padrão `"16x"` aplica a mesclagem completa. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto. **Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. O método forward de [MiniCPMOcrForConditionalGeneration](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrForConditionalGeneration) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L854) **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. Extração de características de imagem: codificador de visão, inserção do merger, em seguida, o merger MLP. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/modeling_minicpm_ocr.py#L858) **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([MiniCPMOcrConfig](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrConfig)) e das entradas. Extraia recursos de vídeo: reorganize os quadros no formato NaViT e, em seguida, aplique o codificador de visão + mesclador. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/processing_minicpm_ocr.py#L47) **Parâmetros:** image_processor (`MiniCPMOcrImageProcessor`) : O processador de imagem é uma entrada obrigatória. video_processor (`MiniCPMOcrVideoProcessor`) : O processador de vídeo é uma entrada obrigatória. tokenizer (`TokenizersBackend`) : O tokenizer é uma entrada obrigatória. chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. Constrói um MiniCPMOcrProcessor que encapsula um processador de imagem, um processador de vídeo e um tokenizer em um único processador. [MiniCPMOcrProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrProcessor) oferece todas as funcionalidades de [MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor), [MiniCPMOcrVideoProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrVideoProcessor) e [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~MiniCPMOcrImageProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrImageProcessor), [~MiniCPMOcrVideoProcessor](/docs/transformers/main/pt/model_doc/minicpm_ocr#transformers.MiniCPMOcrVideoProcessor) e [~TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) para mais informações. #### __call__[[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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/minicpm_ocr/processing_minicpm_ocr.py#L70) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. ## MiniCPMOcrImageProcessor[[transformers.MiniCPMOcrImageProcessor]] #### transformers.MiniCPMOcrImageProcessor[[transformers.MiniCPMOcrImageProcessor]] ```python transformers.MiniCPMOcrImageProcessor(**kwargs: *) ``` [Origem](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*, padrão *True*) : Se deve converter a imagem para RGB. do_resize (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve redimensionar a imagem. size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Descreve as dimensões de entrada máximas para o modelo. default_to_square (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Tamanho da imagem de saída após aplicar *center_crop*. resample (*Annotated[Union[int, PILImageRedimensionamento, NoneType], None]*, *kwargs*, padrão *3*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração *PILImageResampling*. Tem efeito apenas se *do_resize* estiver definido como *True*. do_rescale (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve reescalar a imagem. rescale_factor (*float*, *kwargs*, *opcional*, padrão *0.00392156862745098*) : Fator de reescala para reescalar a imagem, caso *do_rescale* esteja definido como *True*. do_normalize (*bool*, *kwargs*, *opcional*, padrão *True*) : Se a imagem deve ser normalizada. image_mean (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*, padrão *[0.5, 0.5, 0.5]*) : Média da imagem a ser usada para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. image_std (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*, padrão *[0.5, 0.5, 0.5]*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. do_pad (*bool*, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : O tamanho em *{"height": int, "width" int}* para preencher as imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se *pad_size* não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando *do_pad=True.* do_center_crop (*bool*, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : Apenas *ChannelDimension.FIRST* é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - *"channels_first"* ou *ChannelDimension.FIRST*: imagem no formato (num_channels, height, width). - *"channels_last"* ou *ChannelDimension.LAST*: imagem no formato (height, width, num_channels). - *"none"* ou *ChannelDimension.NONE*: imagem no formato (height, width). device (*Annotated[Union[str, torch.device, NoneType], None]*, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (*Annotated[str | ~utils.generic.TensorType | None, None]*, *kwargs*) : Retorna tensores empilhados se definido como *'pt'*, caso contrário, retorna uma lista de tensores. disable_grouping (*bool*, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (*int*, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. max_slice_nums (*int*, *kwargs*, *opcional*, padrão 9) : Número máximo de fatias ao dividir uma imagem de alta resolução. scale_resolution (*int*, *kwargs*, *opcional*, padrão 448) : Resolução alvo para fatias individuais. patch_size (*int*, *kwargs*, *opcional*, padrão 14) : Tamanho do patch espacial do codificador de visão. slice_mode (*bool*, *kwargs*, *opcional*, padrão *True*) : Se as imagens devem ser divididas em múltiplas fatias para maior resolução. downsample_mode (*str*, *kwargs*, *opcional*, padrão *"4x"*) : Modo de redução de amostragem de tokens visuais. *"4x"* mantém 4x mais tokens do que *"16x"*, que aplica a mesclagem completa. A sobrescrita por chamada é suportada. use_image_id (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve anteceder uma tag de ID de imagem (`N`) antes de cada marcador de posição de imagem. Consumido pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens. small_image_upsize (*str*, *kwargs*, *opcional*, padrão *"always"*) : Como imagens e fatias com tamanho não superior a *scale_resolution* ao quadrado são redimensionadas. *"always"* aumenta a resolução para *scale_resolution*, *"never"* mantém a resolução nativa alinhada à grade de patches e *"adaptive"* seleciona por imagem e por fatia com base no tamanho e na densidade dos glifos (requer OpenCV, veja [*adaptive_upsize_resolution*]). Constrói um processador de imagem 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: *) ``` [Origem](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]]*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina *do_rescale=False*. do_convert_rgb (*bool*, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (*bool*, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Descreve as dimensões de entrada máximas para o modelo. default_to_square (*bool*, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Tamanho da imagem de saída após aplicar *center_crop*. resample (*Annotated[Union[int, PILImageRedimensionamento, NoneType], None]*, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração *PILImageResampling*. Tem efeito apenas se *do_resize* estiver definido como *True*. do_rescale (*bool*, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (*float*, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso *do_rescale* esteja definido como *True*. do_normalize (*bool*, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. image_std (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. do_pad (*bool*, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : O tamanho em *{"height": int, "width" int}* para preencher as imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se *pad_size* não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando *do_pad=True.* do_center_crop (*bool*, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : Apenas *ChannelDimension.FIRST* é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - *"channels_first"* ou *ChannelDimension.FIRST*: imagem no formato (num_channels, height, width). - *"channels_last"* ou *ChannelDimension.LAST*: imagem no formato (height, width, num_channels). - *"none"* ou *ChannelDimension.NONE*: imagem no formato (height, width). device (*Annotated[Union[str, torch.device, NoneType], None]*, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (*Annotated[str | ~utils.generic.TensorType | None, None]*, *kwargs*) : Retorna tensores empilhados se definido como *'pt'*, caso contrário, retorna uma lista de tensores. disable_grouping (*bool*, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (*int*, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. max_slice_nums (*int*, *kwargs*, *opcional*, padrão 9) : Número máximo de fatias ao dividir uma imagem de alta resolução. scale_resolution (*int*, *kwargs*, *opcional*, padrão 448) : Resolução alvo para fatias individuais. patch_size (*int*, *kwargs*, *opcional*, padrão 14) : Tamanho do patch espacial do codificador de visão. slice_mode (*bool*, *kwargs*, *opcional*, padrão *True*) : Se as imagens devem ser divididas em múltiplas fatias para maior resolução. downsample_mode (*str*, *kwargs*, *opcional*, padrão *"4x"*) : Modo de redução de amostragem de tokens visuais. *"4x"* mantém 4x mais tokens do que *"16x"*, que aplica a mesclagem completa. A sobrescrita por chamada é suportada. use_image_id (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve anteceder uma tag de ID de imagem (`N`) antes de cada marcador de posição de imagem. Consumido pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens. small_image_upsize (*str*, *kwargs*, *opcional*, padrão *"always"*) : Como imagens e fatias com tamanho não superior a *scale_resolution* ao quadrado são redimensionadas. *"always"* aumenta a resolução para *scale_resolution*, *"never"* mantém a resolução nativa alinhada à grade de patches e *"adaptive"* seleciona por imagem e por fatia com base no tamanho e na densidade dos glifos (requer OpenCV, veja [*adaptive_upsize_resolution*]). **Retorna:** `*~feature_extraction_utils.BatchFeature*` - **data** (*dict*, *opcional*) -- Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', etc.). - **tensor_type** (*Union[None, str, TensorType]*, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. - **skip_tensor_conversion** (*list[str]* ou *set[str]*, *opcional*) -- Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quando *tensor_type* é especificado. ## MiniCPMOcrVideoProcessor[[transformers.MiniCPMOcrVideoProcessor]] #### transformers.MiniCPMOcrVideoProcessor[[transformers.MiniCPMOcrVideoProcessor]] ```python transformers.MiniCPMOcrVideoProcessor(**kwargs: *) ``` [Origem](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*, padrão *True*) : Se deve converter a imagem para RGB. do_resize (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve redimensionar a imagem. size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Descreve as dimensões de entrada máximas para o modelo. default_to_square (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. resample (*Annotated[Union[int, PILImageRedimensionamento, NoneType], None]*, *kwargs*, padrão *3*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração *PILImageResampling*. Tem efeito apenas se *do_resize* estiver definido como *True*. do_rescale (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve reescalar a imagem. rescale_factor (*float*, *kwargs*, *opcional*, padrão *0.00392156862745098*) : Fator de reescala para reescalar a imagem, caso *do_rescale* esteja definido como *True*. do_normalize (*bool*, *kwargs*, *opcional*, padrão *True*) : Se a imagem deve ser normalizada. image_mean (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*, padrão *[0.5, 0.5, 0.5]*) : Média da imagem a ser usada para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. image_std (*Union[float, list[float], tuple[float, ...]]*, *kwargs*, *opcional*, padrão *[0.5, 0.5, 0.5]*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se *do_normalize* estiver definido como *True*. do_center_crop (*bool*, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. do_pad (*bool*, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. crop_size (*Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]*, *kwargs*) : Tamanho da imagem de saída após aplicar *center_crop*. data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : Apenas *ChannelDimension.FIRST* é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (*Union[str, ~image_utils.ChannelDimension]*, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - *"channels_first"* ou *ChannelDimension.FIRST*: imagem no formato (num_channels, height, width). - *"channels_last"* ou *ChannelDimension.LAST*: imagem no formato (height, width, num_channels). - *"none"* ou *ChannelDimension.NONE*: imagem no formato (height, width). device (*Annotated[Union[str, torch.device, NoneType], None]*, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não definido, o dispositivo é inferido a partir dos vídeos de entrada. do_sample_frames (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro. video_metadata (*Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]*, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento fps (*Annotated[int | float | None, None]*, *kwargs*) : Quadros-alvo a amostrar por segundo quando *do_sample_frames=True*. num_frames (*Annotated[int | None, None]*, *kwargs*) : Número máximo de quadros a amostrar quando *do_sample_frames=True*. return_metadata (*bool*, *kwargs*, *opcional*, padrão *False*) : Se deve ou não retornar metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc. return_tensors (*Annotated[str | ~utils.generic.TensorType | None, None]*, *kwargs*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - *'pt'*: Retorna objetos *torch.Tensor* do PyTorch. - *'np'*: Retorna objetos *np.ndarray* do NumPy. max_num_frames (*int*, *kwargs*, *opcional*, padrão 128) : Número máximo de quadros principais a serem amostrados por vídeo. stack_frames (*int*, *kwargs*, *opcional*, padrão 1) : Sub-frames por segundo para empilhar. `1` desativa o empilhamento. max_slice_nums (*int*, *kwargs*, *opcional*, padrão 9) : Número máximo de fatias ao dividir uma imagem de alta resolução. scale_resolution (*int*, *kwargs*, *opcional*, padrão 448) : Resolução alvo para fatias individuais. patch_size (*int*, *kwargs*, *opcional*, padrão 14) : Tamanho do patch espacial do codificador de visão. slice_mode (*bool*, *kwargs*, *opcional*, padrão *True*) : Se as imagens devem ser divididas em múltiplas fatias para maior resolução. downsample_mode (*str*, *kwargs*, *opcional*, padrão *"4x"*) : Modo de redução de amostragem de tokens visuais. *"4x"* mantém 4x mais tokens do que *"16x"*, que aplica a mesclagem completa. use_image_id (*bool*, *kwargs*, *opcional*, padrão *True*) : Se deve anteceder uma tag de ID de imagem (`N`) antes de cada marcador de posição de imagem. Consumido pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens. - ****kwargs** ([*ProcessingKwargs*], *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. Constrói um processador de vídeo 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: *) ``` [Origem](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]]]`) : Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. do_sample_frames (`bool`, *kwargs*, *opcional*) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento fps (`Annotated[int | float | None, None]`, *kwargs*) : Quadros-alvo a amostrar por segundo quando `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*) : Número máximo de quadros a amostrar quando `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *opcional*) : Se deve ou não retornar os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. **Retorna:** `~feature_extraction_utils.BatchFeature` - **data** (`dict`, *opcional*) -- Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. - **skip_tensor_conversion** (`list[str]` ou `set[str]`, *opcional*) -- Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.