# MGP-STR

## Visão geral

O modelo MGP-STR foi proposto em [Multi-Granularity Prediction for Scene Text Recognition](https://huggingface.co/papers/2209.03592) por Peng Wang, Cheng Da e Cong Yao. O MGP-STR é um modelo de Reconhecimento de Texto em Cena (STR) visual, conceitualmente **simples**, porém **potente**, construído sobre o [Vision Transformer (ViT)](vit). Para integrar o conhecimento linguístico, a estratégia de Previsão Multi-Granularidade (MGP) é proposta para injetar informações da modalidade de linguagem no modelo de forma implícita.

O resumo do artigo é o seguinte:

*O reconhecimento de texto em cenas (STR) tem sido um tópico de pesquisa ativo em visão computacional há anos. Para enfrentar esse problema desafiador, inúmeros métodos inovadores foram sucessivamente propostos e a incorporação de conhecimento linguístico em modelos de STR tornou-se recentemente uma tendência proeminente. Neste trabalho, primeiro nos inspiramos nos recentes avanços no Vision Transformer (ViT) para construir um modelo de STR visual conceitualmente simples, porém poderoso, que é baseado no ViT e supera os modelos state-of-the-art anteriores para reconhecimento de texto em cenas, incluindo tanto modelos puramente visuais quanto métodos aumentados por linguagem. Para integrar o conhecimento linguístico, propomos ainda uma estratégia de Previsão Multi-Granularidade para injetar informações da modalidade linguística no modelo de forma implícita, ou seja, as representações de subpalavras (BPE e WordPiece) amplamente utilizadas em PLN são introduzidas no espaço de saída, além da representação convencional em nível de caractere, sem que nenhum modelo de linguagem (LM) independente seja adotado. O algoritro resultante (denominado MGP-STR) é capaz de elevar o limite de desempenho do STR a um nível ainda mais alto. Especificamente, ele atinge uma precisão média de reconhecimento de 93,35% em benchmarks padrão.*

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/mgp_str_architecture.png"
alt="drawing" width="600"/>

 Arquitetura MGP-STR. Retirada do artigo original.

O MGP-STR é treinado em dois conjuntos de dados sintéticos [MJSynth](http://www.robots.ox.ac.uk/~vgg/data/text/) (MJ) e [SynthText](http://www.robots.ox.ac.uk/~vgg/data/scenetext/) (ST), sem ajuste fino em outros conjuntos de dados. Ele alcança resultados de estado da arte em seis benchmarks padrão de texto em cena em latim, incluindo 3 conjuntos de dados de texto regular (IC13, SVT, IIIT) e 3 irregulares (IC15, SVTP, CUTE). Este modelo foi contribuído por [yuekun](https://huggingface.co/yuekun). O código original pode ser encontrado [aqui](https://github.com/AlibabaResearch/AdvancedLiterateMachinery/tree/main/OCR/MGP-STR).

## Exemplo de inferência

[MgpstrModel](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrModel) aceita imagens como entrada e gera três tipos de previsões, que representam informações textuais em diferentes granularidades. Os três tipos de previsões são fundidos para fornecer o resultado final da previsão.

A classe [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) é responsável pelo pré-processamento da imagem de entrada e o [MgpstrTokenizer](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrTokenizer) decodifica os tokens de caracteres gerados para a string de destino. O [MgpstrProcessor](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrProcessor) agrupa o [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) e o [MgpstrTokenizer](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrTokenizer) em uma única instância para extrair os recursos de entrada e decodificar os ids de tokens previstos.

- Reconhecimento Óptico de Caracteres (OCR) passo a passo

```python
import requests
from PIL import Image

from transformers import MgpstrForSceneTextRecognition, MgpstrProcessor

processor = MgpstrProcessor.from_pretrained('alibaba-damo/mgp-str-base')
model = MgpstrForSceneTextRecognition.from_pretrained('alibaba-damo/mgp-str-base', device_map="auto")

# load a synthetic scene-text image
url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/mgp_str_ticket.png"
image = Image.open(requests.get(url, stream=True).raw).convert("RGB")

pixel_values = processor(images=image, return_tensors="pt").to(model.device).pixel_values
outputs = model(pixel_values)

generated_text = processor.batch_decode(outputs.logits)['generated_text']
```

## MgpstrConfig[[transformers.MgpstrConfig]]

#### transformers.MgpstrConfig[[transformers.MgpstrConfig]]

```python
transformers.MgpstrConfig(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, image_size: list[int] | tuple[int, ...] = (32, 128), patch_size: int | list[int] | tuple[int, int] = 4, num_channels: int = 3, max_token_length: int = 27, num_character_labels: int = 38, num_bpe_labels: int = 50257, num_wordpiece_labels: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: float | int = 4.0, qkv_bias: bool = True, distilled: bool = False, layer_norm_eps: float = 1e-05, drop_rate: float | int = 0.0, attn_drop_rate: float | int = 0.0, drop_path_rate: float | int = 0.0, output_a3_attentions: bool = False, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/configuration_mgp_str.py#L24)

**Parâmetros:**

image_size (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(32, 128)`) : O tamanho (resolução) de cada imagem.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `4`) : O tamanho (resolução) de cada patch.

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

max_token_length (`int`, *opcional*, padrão 27) : O número máximo de tokens de saída.

num_character_labels (`int`, *opcional*, padrão 38) : O número de classes para a cabeça de caracteres.

num_bpe_labels (`int`, *opcional*, padrão 50257) : O número de classes para a cabeça bpe.

num_wordpiece_labels (`int`, *opcional*, padrão 30522) : O número de classes para a cabeça wordpiece.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

mlp_ratio (`Union[float, int]`, *opcional*, padrão `4.0`) : Razão entre a dimensão oculta do MLP e a dimensão de incorporação.

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

distilled (`bool`, *opcional*, padrão `False`) : O modelo inclui um token e uma cabeça de destilação, como nos modelos DeiT.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

drop_rate (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder.

attn_drop_rate (`float`, *opcional*, padrão 0.0) : A taxa de dropout para as probabilidades de atenção.

drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.

output_a3_attentions (`bool`, *opcional*, padrão `False`) : Se o modelo deve ou não retornar as atenções dos módulos A^3.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Mgp StrModel. Ela é usada para instanciar um modelo Mgp Str 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 [alibaba-damo/mgp-str-base](https://huggingface.co/alibaba-damo/mgp-str-base)

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
>>> from transformers import MgpstrConfig, MgpstrForSceneTextRecognition

>>> # Initializing a Mgpstr mgp-str-base style configuration
>>> configuration = MgpstrConfig()

>>> # Initializing a model (with random weights) from the mgp-str-base style configuration
>>> model = MgpstrForSceneTextRecognition(configuration)

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

## MgpstrTokenizer[[transformers.MgpstrTokenizer]]

#### transformers.MgpstrTokenizer[[transformers.MgpstrTokenizer]]

```python
transformers.MgpstrTokenizer(vocab_file, unk_token = '[GO]', bos_token = '[GO]', eos_token = '[s]', pad_token = '[GO]', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/tokenization_mgp_str.py#L28)

**Parâmetros:**

vocab_file (`str`) : Caminho para o arquivo de vocabulário.

unk_token (`str`, *opcional*, padrão `"[GO]"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

bos_token (`str`, *opcional*, padrão `"[GO]"`) : O token de início de sequência.

eos_token (`str`, *opcional*, padrão `"[s]"`) : O token de fim de sequência.

pad_token (`str` ou `tokenizers.AddedToken`, *opcional*, padrão `"[GO]"`) : Um token especial usado para tornar os arrays de tokens do mesmo tamanho para fins de loteamento. Em seguida, será ignorado pelos mecanismos de atenção ou pelo cálculo da perda.

Construa um tokenizador de caracteres MGP-STR.

Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

#### save_vocabulary[[transformers.MgpstrTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/tokenization_mgp_str.py#L89)

## MgpstrProcessor[[transformers.MgpstrProcessor]]

#### transformers.MgpstrProcessor[[transformers.MgpstrProcessor]]

```python
transformers.MgpstrProcessor(image_processor = None, tokenizer = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/processing_mgp_str.py#L40)

**Parâmetros:**

image_processor (`ViTImageProcessor`) : O processador de imagem é uma entrada obrigatória.

tokenizer (`MgpstrTokenizer`) : O tokenizer é uma entrada obrigatória.

Constrói um MgpstrProcessor que encapsula um processador de imagem e um tokenizer em um único processador.

[MgpstrProcessor](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrProcessor) oferece todas as funcionalidades de [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) e [MgpstrTokenizer](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrTokenizer). Consulte [~ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) e [~MgpstrTokenizer](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrTokenizer) para mais informações.

#### __call__[[transformers.MgpstrProcessor.__call__]]

```python
__call__(text = None, images = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/processing_mgp_str.py#L48)

**Parâmetros:**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

images (``) : Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

#### batch_decode[[transformers.MgpstrProcessor.batch_decode]]

```python
batch_decode(sequences)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/processing_mgp_str.py#L56)

**Parâmetros:**

sequences (`torch.Tensor`) : Lista de ids de entrada tokenizados.

**Retorna:** `dict[str, any]`

Dicionário de todas as saídas dos resultados decodificados. generated_text (`list[str]`): Os resultados finais após a fusão de char, bpe e wp. scores (`list[float]`): As pontuações finais após a fusão de char, bpe e wp. char_preds (`list[str]`): A lista de frases decodificadas por caractere. bpe_preds (`list[str]`): A lista de frases decodificadas por bpe. wp_preds (`list[str]`): A lista de frases decodificadas por wp.

Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.

Este método encaminha todos os seus argumentos para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

## MgpstrModel[[transformers.MgpstrModel]]

#### transformers.MgpstrModel[[transformers.MgpstrModel]]

```python
transformers.MgpstrModel(config: MgpstrConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/modeling_mgp_str.py#L292)

**Parâmetros:**

config ([MgpstrConfig](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrConfig)) : 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 Mgp Str 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.MgpstrModel.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/modeling_mgp_str.py#L305)

**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 [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor). Veja [ViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([MgpstrProcessor](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrProcessor) usa [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) para processar imagens).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 ([MgpstrConfig](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrConfig)) e das entradas.

O método forward do [MgpstrModel](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrModel) 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.
- **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.

## MgpstrForSceneTextRecognition[[transformers.MgpstrForSceneTextRecognition]]

#### transformers.MgpstrForSceneTextRecognition[[transformers.MgpstrForSceneTextRecognition]]

```python
transformers.MgpstrForSceneTextRecognition(config: MgpstrConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/modeling_mgp_str.py#L347)

**Parâmetros:**

config ([MgpstrConfig](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrConfig)) : 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 transformer MGP-STR com três cabeças de classificação no topo (três módulos A^3 e três camadas lineares no topo da saída do codificador transformer) para reconhecimento de texto em cena (STR).

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.MgpstrForSceneTextRecognition.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_a3_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mgp_str/modeling_mgp_str.py#L368)

**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 [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor). Veja [ViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([MgpstrProcessor](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrProcessor) usa [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) para processar imagens).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_a3_attentions (`bool`, *opcional*) : Se deve ou não retornar os tensores de atenção dos módulos a3. Consulte `a3_attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `MgpstrModelOutput` ou `tuple(torch.Tensor)`

Um `MgpstrModelOutput` 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 ([MgpstrConfig](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrConfig)) e das entradas.

O método forward de [MgpstrForSceneTextRecognition](/docs/transformers/main/pt/model_doc/mgp-str#transformers.MgpstrForSceneTextRecognition) 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.

- **logits** (`tuple(torch.Tensor)` de forma `(batch_size, config.num_character_labels)`) -- Tupla de `torch.Tensor` (um para a saída de character de forma `(batch_size, config.max_token_length, config.num_character_labels)`, + um para a saída de bpe de forma `(batch_size, config.max_token_length, config.num_bpe_labels)`, + um para a saída de wordpiece de forma `(batch_size, config.max_token_length, config.num_wordpiece_labels)`) .

  Pontuações de classificação (antes do SoftMax) de character, bpe e wordpiece.
- **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.
- **a3_attentions** (`tuple(torch.Tensor)`, *optional*, returned when `output_a3_attentions=True` is passed or when `config.output_a3_attentions=True`) -- Tuple of `torch.Tensor` (one for the attention of character, + one for the attention of bpe`, + one for the attention of wordpiece) of shape `(batch_size, config.max_token_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> from transformers import (
...     MgpstrProcessor,
...     MgpstrForSceneTextRecognition,
... )
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image

>>> # load a synthetic scene-text image
>>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/mgp_str_ticket.png"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")

>>> processor = MgpstrProcessor.from_pretrained("alibaba-damo/mgp-str-base")
>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> model = MgpstrForSceneTextRecognition.from_pretrained("alibaba-damo/mgp-str-base")

>>> # inference
>>> outputs = model(pixel_values)
>>> out_strs = processor.batch_decode(outputs.logits)
>>> out_strs["generated_text"]
'["ticket"]'
```