# PP-OCRv6_tiny_rec ## Visão geral PP-OCRv6_tiny_rec é o modelo de reconhecimento mais leve da série PP-OCRv6. Ele utiliza LCNetV4 como backbone, com uma projeção de reshape direta em vez de um encoder neck, e um decodificador multi-head CTC+NRTR. O modelo suporta 49 idiomas e contém 1,1M de parâmetros. ## Arquitetura do Modelo ## Uso ### Inferência com entrada única O exemplo abaixo demonstra como detectar texto com PP-OCRv6_tiny_rec usando o [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). ```python from io import BytesIO from huggingface_hub.utils import httpx from PIL import Image from transformers import AutoImageProcessor, AutoModelForTextRecognition from transformers.image_utils import load_image model_path = "PaddlePaddle/PP-OCRv6_tiny_rec_safetensors" model = AutoModelForTextRecognition.from_pretrained(model_path, device_map="auto") image_processor = AutoImageProcessor.from_pretrained(model_path) image_url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_general_ocr_rec_001.png" image = load_image(image_url) inputs = image_processor(images=image, return_tensors="pt").to(model.device) outputs = model(**inputs) results = image_processor.post_process_text_recognition(outputs) for result in results: print(result) ``` ### Inferência em lote Aqui está como você pode fazer isso com PP-OCRv6_tiny_rec usando o [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel): ```python from io import BytesIO from huggingface_hub.utils import httpx from PIL import Image from transformers import AutoImageProcessor, AutoModelForTextRecognition from transformers.image_utils import load_image model_path = "PaddlePaddle/PP-OCRv6_tiny_rec_safetensors" model = AutoModelForTextRecognition.from_pretrained(model_path, device_map="auto") image_processor = AutoImageProcessor.from_pretrained(model_path) image_url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_general_ocr_rec_001.png" image = load_image(image_url) inputs = image_processor(images=[image, image], return_tensors="pt").to(model.device) outputs = model(**inputs) results = image_processor.post_process_text_recognition(outputs) for result in results: print(result) ``` ## PPOCRV6TinyRecForTextRecognition[[transformers.PPOCRV6TinyRecForTextRecognition]] #### transformers.PPOCRV6TinyRecForTextRecognition[[transformers.PPOCRV6TinyRecForTextRecognition]] ```python transformers.PPOCRV6TinyRecForTextRecognition(config: PPOCRV6TinyRecConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_tiny_rec/modeling_pp_ocrv6_tiny_rec.py#L118) **Parâmetros:** config ([PPOCRV6TinyRecConfig](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecConfig)) : 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. Modelo PPOCR6TinyRec para tarefas de reconhecimento de 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.PPOCRV6TinyRecForTextRecognition.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_tiny_rec/modeling_pp_ocrv6_tiny_rec.py#L128) **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 [PPOCRV6SmallRecImageProcessor](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6SmallRecImageProcessor). Veja [PPOCRV6SmallRecImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [PPOCRV6SmallRecImageProcessor](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6SmallRecImageProcessor) para processar imagens). **Retorna:** `BaseModelOutputWithNoAttention` ou `tuple(torch.Tensor)` Um `BaseModelOutputWithNoAttention` 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 ([PPOCRV6TinyRecConfig](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecConfig)) e das entradas. O método forward de [PPOCRV6TinyRecForTextRecognition](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecForTextRecognition) 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, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **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, num_channels, height, width)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. ## PPOCRV6TinyRecConfig[[transformers.PPOCRV6TinyRecConfig]] #### transformers.PPOCRV6TinyRecConfig[[transformers.PPOCRV6TinyRecConfig]] ```python transformers.PPOCRV6TinyRecConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 120, head_out_channels: int = 6625) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_tiny_rec/configuration_pp_ocrv6_tiny_rec.py#L31) **Parâmetros:** backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone. hidden_size (`int`, *opcional*, padrão `120`) : Dimensão das representações ocultas. head_out_channels (`int`, *opcional*, padrão 18714) : O número de canais de saída do PPOCRV6TinyRecHead, responsável pela classificação final. Esta é a classe de configuração para armazenar a configuração de um PPOCRV6TinyRecModel. Ela é usada para instanciar um modelo Pp Ocrv6 Tiny Rec 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 [PaddlePaddle/PP-OCRv6_tiny_rec_safetensors](https://huggingface.co/PaddlePaddle/PP-OCRv6_tiny_rec_safetensors) 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. ## PPOCRV6TinyRecModel[[transformers.PPOCRV6TinyRecModel]] #### transformers.PPOCRV6TinyRecModel[[transformers.PPOCRV6TinyRecModel]] ```python transformers.PPOCRV6TinyRecModel(config: PPOCRV6TinyRecConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_tiny_rec/modeling_pp_ocrv6_tiny_rec.py#L92) **Parâmetros:** config ([PPOCRV6TinyRecConfig](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecConfig)) : 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. Modelo PPOCRV6TinyRec, composto pelas redes Backbone e Head. 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.PPOCRV6TinyRecModel.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_tiny_rec/modeling_pp_ocrv6_tiny_rec.py#L100) **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 [PPOCRV6SmallRecImageProcessor](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6SmallRecImageProcessor). Veja [PPOCRV6SmallRecImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [PPOCRV6SmallRecImageProcessor](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6SmallRecImageProcessor) para processar imagens). **Retorna:** `BaseModelOutputWithNoAttention` ou `tuple(torch.Tensor)` Um `BaseModelOutputWithNoAttention` 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 ([PPOCRV6TinyRecConfig](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecConfig)) e das entradas. O método forward do [PPOCRV6TinyRecModel](/docs/transformers/main/pt/model_doc/pp_ocrv6_tiny_rec#transformers.PPOCRV6TinyRecModel) 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, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **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, num_channels, height, width)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. ## PPOCRV6SmallRecImageProcessor[[transformers.PPOCRV6SmallRecImageProcessor]] #### transformers.PPOCRV6SmallRecImageProcessor[[transformers.PPOCRV6SmallRecImageProcessor]] ```python transformers.PPOCRV6SmallRecImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_small_rec/image_processing_pp_ocrv6_small_rec.py#L50) **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*, padrão `{'height' : 48, 'width': 320}`): 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, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem 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 redimensionamento para redimensionar 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*, padrão `True`) : Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 48, 'width': 320}`): O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que qualquer tamanho de imagem fornecido para 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 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. 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. 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. 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. 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. 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. 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. 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. Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. -- Constrói um processador de imagem PPOCRV6SmallRecImageProcessor. 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. #### get_target_size[[transformers.PPOCRV6SmallRecImageProcessor.get_target_size]] ```python get_target_size(shape_list: list) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_small_rec/image_processing_pp_ocrv6_small_rec.py#L122) Calcule a largura e a altura a partir da imagem mais larga do lote. #### post_process_text_recognition[[transformers.PPOCRV6SmallRecImageProcessor.post_process_text_recognition]] ```python post_process_text_recognition(predictions) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_ocrv6_small_rec/image_processing_pp_ocrv6_small_rec.py#L149) **Parâmetros:** predictions : Saídas do modelo com o atributo `logits` (mapas de probabilidade de forma `(batch_size, height, vocab_size)`). **Retorna:** Uma lista de dicionários, em que cada dicionário corresponde a uma imagem no lote. Cada dicionário contém: - "text" (str): A string de texto decodificada. - "score" (float): A pontuação média de confiança dos caracteres no texto decodificado. Processa os logits brutos do modelo para decodificar o texto reconhecido e sua pontuação de confiança.