# QianfanOCR ## Visão geral **Qianfan-OCR** é um modelo de inteligência de documentos de ponta a ponta com 4 bilhões de parâmetros, desenvolvido pela equipe Baidu Qianfan. Ele foi proposto em [Qianfan-OCR: A Unified End-to-End Model for Document Intelligence](https://huggingface.co/papers/2603.13398), por Daxiang Dong et al. Diferentemente dos pipelines de OCR multiestágio tradicionais, o Qianfan-OCR realiza **conversão direta de imagem para texto** e suporta uma ampla variedade de tarefas orientadas por prompts — desde o parsing de documentos estruturados e a extração de tabelas até a compreensão de gráficos, a resposta a perguntas sobre documentos e a extração de informações-chave — tudo em um único modelo. O modelo adota uma arquitetura de ponte multimodal composta por três componentes: - **Encoder de visão**: Qianfan-ViT com design AnyResolution (até 4K), 256 tokens visuais por tile de 448×448, máximo de 4.096 tokens por imagem - **Modelo de linguagem**: Qwen3-4B com contexto de 32K (estendível para 131K) - **Adaptador Cross-Modal**: MLP de 2 camadas com ativação GELU Uma inovação fundamental é o **Layout-as-Thought**: uma fase opcional de raciocínio ativada pelos tokens ``, na qual o modelo gera representações estruturadas de layout (bounding boxes, tipos de elementos, ordem de leitura) antes de produzir as saídas finais. Isso é particularmente útil para páginas heterogêneas com tipos de elementos mistos (provas, relatórios técnicos, jornais). O modelo atinge resultados de estado da arte em vários benchmarks: - **#1 em modelo de ponta a ponta no OmniDocBench v1.5** com uma pontuação geral de 93.12 - **#1 no benchmark OlmOCR de ponta a ponta** com uma pontuação de 79,8 - **1º em Extração de Informações-Chave** com uma pontuação média de 87,9 em cinco benchmarks públicos de KIE Este modelo foi contribuído pela [Baidu Qianfan Team](https://github.com/baidubce/Qianfan-VL). ## Exemplo de uso ### Análise de documentos ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained("baidu/Qianfan-OCR", device_map="auto") processor = AutoProcessor.from_pretrained("baidu/Qianfan-OCR") image = "https://huggingface.co/datasets/hf-internal-testing/fixtures_got_ocr/resolve/main/image_ocr.jpg" messages = [{"role": "user", "content": [{"type": "image", "url": image}, {"type": "text", "text": "Parse this document to Markdown."}]}] inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_tensors="pt").to(model.device) generate_ids = model.generate(**inputs, max_new_tokens=64) processor.decode(generate_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) ``` ### Layout-as-Thought (modo de raciocínio) Para documentos com layouts complexos, elementos desorganizados ou ordens de leitura não padrão, ative o modo de raciocínio definindo `enable_thinking=True` em `apply_chat_template`. O modelo primeiro gerará uma análise estruturada do layout (bounding boxes, tipos de elementos, ordem de leitura) e, em seguida, produzirá a saída final. ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained("baidu/Qianfan-OCR", device_map="auto") processor = AutoProcessor.from_pretrained("baidu/Qianfan-OCR") image = "https://huggingface.co/datasets/hf-internal-testing/fixtures_got_ocr/resolve/main/image_ocr.jpg" messages = [{"role": "user", "content": [{"type": "image", "url": image}, {"type": "text", "text": "Parse this document to Markdown."}]}] inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", enable_thinking=True).to(model.device) generate_ids = model.generate(**inputs, max_new_tokens=128) processor.decode(generate_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) ``` ### Inferência em lote ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained("baidu/Qianfan-OCR", device_map="auto") processor = AutoProcessor.from_pretrained("baidu/Qianfan-OCR") image1 = "https://huggingface.co/datasets/hf-internal-testing/fixtures_got_ocr/resolve/main/image_ocr.jpg" image2 = "https://huggingface.co/datasets/hf-internal-testing/fixtures_got_ocr/resolve/main/multi_box.png" messages = [ [{"role": "user", "content": [{"type": "image", "url": image1}, {"type": "text", "text": "Parse this document to Markdown."}]}], [{"role": "user", "content": [{"type": "image", "url": image2}, {"type": "text", "text": "OCR the text in the image."}]}], ] inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", padding=True).to(model.device) generate_ids = model.generate(**inputs, max_new_tokens=64) processor.batch_decode(generate_ids[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True) ``` ## QianfanOCRConfig[[transformers.QianfanOCRConfig]] #### transformers.QianfanOCRConfig[[transformers.QianfanOCRConfig]] ```python transformers.QianfanOCRConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 151667, image_seq_length: int = 256, downsample_ratio: float = 0.5, projector_hidden_act: str = 'gelu', vision_feature_layer: int | list[int] = -1, vision_feature_select_strategy: str = 'default', tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/configuration_qianfan_ocr.py#L95) **Parâmetros:** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. image_token_id (`int`, *opcional*, padrão `151667`) : O índice do token de imagem usado como marcador para as imagens de entrada. image_seq_length (`int`, *opcional*, padrão `256`) : Comprimento da sequência de um embedding de imagem. downsample_ratio (`float`, *opcional*, padrão 0.5) : Fator pelo qual a imagem será reduzida. projector_hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação usada pelo projetor multimodal. vision_feature_layer (`Union[int, list[int]]`, *opcional*, padrão `-1`) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. vision_feature_select_strategy (`str`, *opcional*, padrão `default`) : A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. Esta é a classe de configuração para armazenar a configuração de um QianfanOCRModel. Ela é usada para instanciar um modelo Qianfan 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 [baidu/Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) 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. Exemplo: ```python >>> # Initializing a QianfanOCR style configuration >>> configuration = QianfanOCRConfig() >>> # Initializing a model from the configuration >>> model = QianfanOCRForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## QianfanOCRVisionConfig[[transformers.QianfanOCRVisionConfig]] #### transformers.QianfanOCRVisionConfig[[transformers.QianfanOCRVisionConfig]] ```python transformers.QianfanOCRVisionConfig(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 = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, attention_bias: bool = True, use_qk_norm: bool = False, intermediate_size: int = 4096, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_dropout: float | int = 0.0, projection_dropout: float | int = 0.0, initializer_range: float = 0.02, norm_type: str = 'layer_norm', layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, ...] = (448, 448), patch_size: int | list[int] | tuple[int, ...] = (14, 14), num_channels: int = 3, use_mask_token: bool = False, use_absolute_position_embeddings: bool = True, layer_scale_init_value: float = 0.1, use_mean_pooling: bool = True, drop_path_rate: float = 0.1) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/configuration_qianfan_ocr.py#L30) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `24`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. attention_bias (`bool`, *opcional*, padrão `True`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. use_qk_norm (`bool`, *opcional*, padrão `False`) : Se deve usar normalização de query-key na atenção. intermediate_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. projection_dropout (`float`, *opcional*, padrão 0.0) : Probabilidade de dropout para a camada de projeção. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. norm_type (`str`, *opcional*, padrão `"layer_norm"`) : O tipo de normalização a ser usado no codificador. Pode ser `"layer_norm"` ou `"rms_norm"`. layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. image_size (`Union[int, list[int], tuple[int, ...]]`, *opcional*, padrão `(448, 448)`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, ...]]`, *opcional*, padrão `(14, 14)`) : O tamanho (resolução) de cada patch. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. use_mask_token (`bool`, *opcional*, padrão `False`) : Se deve usar um token de máscara para modelagem de imagem mascarada. use_absolute_position_embeddings (`bool`, *opcional*, padrão `True`) : Se deve usar embeddings de posição absoluta. layer_scale_init_value (`float`, *opcional*, padrão `0.1`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para grande. Defina 0 para desativar a escala da camada. use_mean_pooling (`bool`, *opcional*, padrão `True`) : Se deve aplicar a média das camadas ocultas finais dos patches, em vez de usar a camada oculta final do token CLS, antes de aplicar a cabeça de classificação. drop_path_rate (`float`, *opcional*, padrão 0.1) : Taxa de dropout para profundidade estocástica. Esta é a classe de configuração para armazenar a configuração de um QianfanOCRModel. Ela é usada para instanciar um modelo Qianfan 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 [baidu/Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) 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. Exemplo: ```python >>> # Initializing a QianfanOCR vision style configuration >>> configuration = QianfanOCRVisionConfig() >>> # Initializing a model from the configuration >>> model = QianfanOCRVisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## QianfanOCRProcessor[[transformers.QianfanOCRProcessor]] #### transformers.QianfanOCRProcessor[[transformers.QianfanOCRProcessor]] ```python transformers.QianfanOCRProcessor(image_processor = None, tokenizer = None, image_seq_length: int = 256, chat_template = None, image_placeholder_token: str = '', **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/processing_qianfan_ocr.py#L46) **Parâmetros:** image_processor (*GotOcr2ImageProcessor*) : O processador de imagem é uma entrada obrigatória. tokenizer (*Qwen2Tokenizer*) : O tokenizer é uma entrada obrigatória. image_seq_length (*int*, *opcional*, padrão *256*) : 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. chat_template (*str*) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. image_placeholder_token (*str*, *opcional*, padrão *"<image>"*) : O token emitido pelo modelo de chat para marcar as posições de imagens. Ele é substituído pela sequência completa `<IMG_CONTEXT>...<IMG_CONTEXT></img>` durante o processamento. Constrói um QianfanOCRProcessor que encapsula um processador de imagem e um tokenizer em um único processador. [*QianfanOCRProcessor*] oferece todas as funcionalidades de [*GotOcr2ImageProcessor*] e [*Qwen2Tokenizer*]. Consulte [*~GotOcr2ImageProcessor*] e [*~Qwen2Tokenizer*] para mais informações. #### __call__[[transformers.QianfanOCRProcessor.__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, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/processing_qianfan_ocr.py#L81) **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. 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. **Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) Um [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) com os seguintes campos: - **input_ids** -- Lista de ids de tokens a serem fornecidos a um modelo. Retornado quando `text` não é `None`. - **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando `return_attention_mask=True` ou se *"attention_mask"* estiver em `self.model_input_names` e se `text` não for `None`). - **pixel_values** -- Valores de pixel a serem fornecidos a um modelo. Retornado quando `images` não é `None`. ## QianfanOCRVisionModel[[transformers.QianfanOCRVisionModel]] #### transformers.QianfanOCRVisionModel[[transformers.QianfanOCRVisionModel]] ```python transformers.QianfanOCRVisionModel(config: QianfanOCRVisionConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/modeling_qianfan_ocr.py#L423) **Parâmetros:** config ([QianfanOCRVisionConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRVisionConfig)) : 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 Qianfan Ocr puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. 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.QianfanOCRVisionModel.forward]] ```python forward(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/modeling_qianfan_ocr.py#L444) **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 [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor). Veja [GotOcr2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([QianfanOCRProcessor](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRProcessor) usa [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor) para processar imagens). bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, num_patches)`, *opcional*) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). **Retorna:** `QianfanOCRVisionModelOutputWithPooling` ou `tuple(torch.Tensor)` Um `QianfanOCRVisionModelOutputWithPooling` 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 ([QianfanOCRConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRConfig)) e das entradas. O método forward do [QianfanOCRVisionModel](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRVisionModel) 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. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Média dos estados ocultos da última camada dos tokens de patch (excluindo o token *[CLS]*) se *config.use_mean_pooling* estiver definido como True. Se definido como False, o estado oculto final do token *[CLS]* será retornado. ## QianfanOCRModel[[transformers.QianfanOCRModel]] #### transformers.QianfanOCRModel[[transformers.QianfanOCRModel]] ```python transformers.QianfanOCRModel(config: QianfanOCRConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/modeling_qianfan_ocr.py#L522) **Parâmetros:** config ([QianfanOCRConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 QianfanOCR, 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.QianfanOCRModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: 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/qianfan_ocr/modeling_qianfan_ocr.py#L606) **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` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor). Veja [GotOcr2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([QianfanOCRProcessor](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRProcessor) usa [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor) para processar imagens). 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 (`~cache_utils.Cache`, *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 uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](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 a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(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. vision_feature_layer (`Union[int, list[int]]`, *opcional*) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. vision_feature_select_strategy (`str`, *opcional*) : A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser `"default"` ou `"full"`. 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:** `QianfanOCRModelOutputWithPast` ou `tuple(torch.Tensor)` Um `QianfanOCRModelOutputWithPast` 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 ([QianfanOCRConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRConfig)) e das entradas. O método forward do [QianfanOCRModel](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRModel) substitui 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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto. ## QianfanOCRForConditionalGeneration[[transformers.QianfanOCRForConditionalGeneration]] #### transformers.QianfanOCRForConditionalGeneration[[transformers.QianfanOCRForConditionalGeneration]] ```python transformers.QianfanOCRForConditionalGeneration(config: QianfanOCRConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/modeling_qianfan_ocr.py#L734) **Parâmetros:** config ([QianfanOCRConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 QIANFAN_OCR, que consiste em um backbone de visão e um modelo 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.QianfanOCRForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qianfan_ocr/modeling_qianfan_ocr.py#L762) **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` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor). Veja [GotOcr2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([QianfanOCRProcessor](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRProcessor) usa [GotOcr2ImageProcessor](/docs/transformers/main/pt/model_doc/got_ocr2#transformers.GotOcr2ImageProcessor) para processar imagens). 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 (`~cache_utils.Cache`, *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 uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](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 a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(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. vision_feature_layer (`Union[int, list[int]]`, *opcional*) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. vision_feature_select_strategy (`str`, *opcional*) : A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser `"default"` ou `"full"`. 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]`. logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). image_sizes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. 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:** `QianfanOCRCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `QianfanOCRCausalLMOutputWithPast` 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 ([QianfanOCRConfig](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRConfig)) e das entradas. O método forward de [QianfanOCRForConditionalGeneration](/docs/transformers/main/pt/model_doc/qianfan_ocr#transformers.QianfanOCRForConditionalGeneration) substitui 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) de 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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto. Exemplo: ```python >>> import torch >>> from transformers import AutoProcessor, AutoModelForImageTextToText >>> torch_device = "cuda" >>> processor = AutoProcessor.from_pretrained("baidu/Qianfan-OCR") >>> model = AutoModelForImageTextToText.from_pretrained( ... "baidu/Qianfan-OCR", dtype=torch.bfloat16, device_map=torch_device ... ) >>> messages = [ ... { ... "role": "user", ... "content": [ ... {"type": "image", "url": "https://example.com/image.jpg"}, ... {"type": "text", "text": "Describe this image."}, ... ], ... }, ... ] >>> inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(torch_device) >>> generate_ids = model.generate(**inputs, max_new_tokens=200) >>> print(processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)) ```