Hugging Face's logo

Transformers documentation

QianfanOCR

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em papers do HF em 2026-03-11 e contribuído para o Hugging Face Transformers em 2026-04-17.

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, 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 <think>, 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.

Exemplo de uso

Análise de documentos

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.

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

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

classe transformers.QianfanOCRConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 151667image_seq_length: int = 256downsample_ratio: float = 0.5projector_hidden_act: str = 'gelu'vision_feature_layer: int | list[int] = -1vision_feature_select_strategy: str = 'default'tie_word_embeddings: bool = False )

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 de posição 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) — Estratégia de seleção de recursos utilizada para selecionar o recurso visual a partir 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> # Initializing a QianfanOCR style configuration
>>> configuration = QianfanOCRConfig()

>>> # Initializing a model from the configuration
>>> model = QianfanOCRForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

QianfanOCRVisionConfig

classe transformers.QianfanOCRVisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16attention_bias: bool = Trueuse_qk_norm: bool = Falseintermediate_size: int = 4096hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_dropout: float | int = 0.0projection_dropout: float | int = 0.0initializer_range: float = 0.02norm_type: str = 'layer_norm'layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, ...] = (448, 448)patch_size: int | list[int] | tuple[int, ...] = (14, 14)num_channels: int = 3use_mask_token: bool = Falseuse_absolute_position_embeddings: bool = Truelayer_scale_init_value: float = 0.1use_mean_pooling: bool = Truedrop_path_rate: float = 0.1 )

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 média (mean pooling) aos estados ocultos finais dos patches, em vez de usar o estado oculto 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> # 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

classe transformers.QianfanOCRProcessor

< >

( image_processor = Nonetokenizer = Noneimage_seq_length: int = 256chat_template = Noneimage_placeholder_token: str = '<image>'**kwargs )

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 de um chat em uma string tokenizável.
  • image_placeholder_token (str, opcional, padrão ””) — O token emitido pelo modelo de chat para marcar as posições das imagens. Ele é substituído pela sequência completa <img><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 o [~GotOcr2ImageProcessor] e o [~Qwen2Tokenizer] para mais informações.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = None**kwargs: *<class 'transformers.models.qianfan_ocr.processing_qianfan_ocr.QianfanOCRProcessorKwargs'> ) → BatchFeature

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 passar 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 pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors 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, 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

Um 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 pixels a serem fornecidos a um modelo. Retornado quando images não é None.

QianfanOCRVisionModel

classe transformers.QianfanOCRVisionModel

< >

( config: QianfanOCRVisionConfig )

Parâmetros

  • config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensorbool_masked_pos: typing.Optional[torch.BoolTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QianfanOCRVisionModelOutputWithPooling or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensors correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando GotOcr2ImageProcessor. Consulte GotOcr2ImageProcessor.call() para mais detalhes (QianfanOCRProcessor usa 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)

Uma 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) e das entradas.

O método forward do 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

classe transformers.QianfanOCRModel

< >

( config: QianfanOCRConfig )

Parâmetros

  • config (QianfanOCRConfig) — 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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QianfanOCRModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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. Consulte GotOcr2ImageProcessor.call() para mais detalhes (QianfanOCRProcessor usa 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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) e das entradas.

O método forward do 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) 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 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 nos cabeçalhos 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

classe transformers.QianfanOCRForConditionalGeneration

< >

( config: QianfanOCRConfig )

Parâmetros

  • config (QianfanOCRConfig) — 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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QianfanOCRCausalLMOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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. Consulte GotOcr2ImageProcessor.call() para detalhes (QianfanOCRProcessor usa 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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 o cálculo da 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)

Uma 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) e das entradas.

O método forward de 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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 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 nos cabeçalhos 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:

>>> 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))
Update on GitHub

←PPLCNetV4 Qwen2.5-Omni→