# MGP-STR

## Aperçu

Le modèle MGP-STR a été proposé dans [Multi-Granularity Prediction for Scene Text Recognition](https://huggingface.co/papers/2209.03592) par Peng Wang, Cheng Da et Cong Yao. MGP-STR est un modèle de reconnaissance de texte dans les scènes (STR) visuel, conceptuellement **simple** mais **puissant**, construit sur la base du [Vision Transformer (ViT)](vit). Pour intégrer les connaissances linguistiques, la stratégie de prédiction multi-granularité (MGP) est proposée afin d'injecter implicitement des informations de la modalité langage dans le modèle.

L'abstract de l'article est le suivant :

*La reconnaissance de texte dans les scènes (STR) est un sujet de recherche actif en vision par ordinateur depuis plusieurs années. Pour relever ce défi, de nombreuses méthodes innovantes ont été proposées successivement, et l’intégration de connaissances linguistiques dans les modèles de STR est devenue une tendance marquante récemment. Dans ce travail, nous nous inspirons d’abord des progrès récents du Vision Transformer (ViT) pour construire un modèle de STR visuel conceptuellement simple mais puissant, basé sur ViT et surpassant les modèles de l’état de l’art antérieurs pour la reconnaissance de texte dans les scènes, y compris les modèles purement visuels et les méthodes augmentées par le langage. Pour intégrer les connaissances linguistiques, nous proposons ensuite une stratégie de prédiction multi-granularité afin d’injecter implicitement des informations de la modalité langage dans le modèle, c’est-à-dire que des représentations de sous-mots (BPE et WordPiece) largement utilisées en NLP sont introduites dans l’espace de sortie, en plus de la représentation au niveau des caractères conventionnelle, sans qu’aucun modèle de langage (LM) indépendant ne soit adopté. L’algorithme résultant (dénommé MGP-STR) est capable de repousser l’enveloppe des performances de la STR à un niveau encore plus élevé. Plus précisément, il atteint une précision de reconnaissance moyenne de 93,35 % sur des benchmarks standard.*

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

 Architecture MGP-STR. Issue de l'article original.

MGP-STR est entraîné sur deux jeux de données synthétiques, [MJSynth](http://www.robots.ox.ac.uk/~vgg/data/text/) (MJ) et [SynthText](http://www.robots.ox.ac.uk/~vgg/data/scenetext/) (ST), sans fine-tuning sur d'autres jeux de données. Il obtient des résultats de pointe sur six benchmarks standard de texte en scène latine, dont 3 jeux de données de texte régulier (IC13, SVT, IIIT) et 3 irréguliers (IC15, SVTP, CUTE). Ce modèle a été contribué par [yuekun](https://huggingface.co/yuekun). Le code d'origine est disponible [ici](https://github.com/AlibabaResearch/AdvancedLiterateMachinery/tree/main/OCR/MGP-STR).

## Exemple d'inférence

[MgpstrModel](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrModel) accepte des images en entrée et génère trois types de prédictions, représentant des informations textuelles à différentes granularités. Les trois types de prédictions sont fusionnés pour donner le résultat de prédiction final.

La classe [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) est chargée de la prétraitement de l'image d'entrée et [MgpstrTokenizer](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrTokenizer) décode les jetons de caractères générés vers la chaîne cible. [MgpstrProcessor](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrProcessor) encapsule [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) et [MgpstrTokenizer](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrTokenizer) en une seule instance afin d'extraire les caractéristiques d'entrée et de décoder les identifiants de jetons prédits.

- Reconnaissance optique de caractères (OCR) pas à pas

```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)
```

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

**Paramètres :**

image_size (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(32, 128)`) : La taille (résolution) de chaque image.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `4`) : La taille (résolution) de chaque patch.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

max_token_length (`int`, *facultatif*, valeur par défaut 27) : Nombre maximal de jetons de sortie.

num_character_labels (`int`, *facultatif*, valeur par défaut 38) : Le nombre de classes pour la tête de caractères.

num_bpe_labels (`int`, *facultatif*, valeur par défaut 50257) : Le nombre de classes pour la tête bpe.

num_wordpiece_labels (`int`, *facultatif*, valeur par défaut 30522) : Le nombre de classes pour la tête wordpiece.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

mlp_ratio (`Union[float, int]`, *facultatif*, valeur par défaut `4.0`) : Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.

qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.

distilled (`bool`, *facultatif*, valeur par défaut `False`) : Le modèle inclut un jeton et une tête de distillation, comme dans les modèles DeiT.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

drop_rate (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings et de l'encodeur.

attn_drop_rate (`float`, *facultatif*, valeur par défaut 0.0) : Le taux de dropout appliqué aux probabilités d'attention.

drop_path_rate (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Taux de drop path pour la fusion des patches.

output_a3_attentions (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle doit retourner les attentions des modules A^3.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Ceci est la classe de configuration destinée à stocker la configuration d'un Mgp StrModel. Elle est utilisée pour instancier un modèle Mgp Str en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [alibaba-damo/mgp-str-base](https://huggingface.co/alibaba-damo/mgp-str-base)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```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)
```

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

**Paramètres :**

vocab_file (`str`) : Chemin vers le fichier de vocabulaire.

unk_token (`str`, *facultatif*, valeur par défaut `"[GO]"`) : le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

bos_token (`str`, *facultatif*, valeur par défaut `"[GO]"`) : Jeton de début de séquence.

eos_token (`str`, *facultatif*, par défaut `"[s]"`) : Jeton de fin de séquence.

pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*, valeur par défaut `"[GO]"`) : Un jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte.

Construire un tokenizer de caractères MGP-STR.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/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)
```

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

**Paramètres :**

image_processor (`ViTImageProcessor`) : le processeur d'images est une entrée obligatoire.

tokenizer (`MgpstrTokenizer`) : le tokenizer est une entrée obligatoire.

Construit un MgpstrProcessor qui encapsule un processeur d’images et un tokenizer en un seul processeur.

[MgpstrProcessor](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrProcessor) offre toutes les fonctionnalités de [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) et de [MgpstrTokenizer](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrTokenizer). Consultez [~ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) et [~MgpstrTokenizer](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrTokenizer) pour plus d’informations.

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

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

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

**Paramètres :**

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/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

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

```python
batch_decode(sequences)
```

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

**Paramètres :**

sequences (`torch.Tensor`) : Liste des identifiants d'entrée tokenisés.

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

Dictionnaire de toutes les sorties des résultats décodés. generated_text (`list[str]`) : Les résultats finaux après fusion de char, bpe et wp. scores (`list[float]`) : Les scores finaux après fusion de char, bpe et wp. char_preds (`list[str]`) : La liste des phrases décodées au niveau des caractères. bpe_preds (`list[str]`) : La liste des phrases décodées au niveau bpe. wp_preds (`list[str]`) : La liste des phrases décodées au niveau wp.

Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.

Cette méthode transmet tous ses arguments à [batch_decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

## MgpstrModel[[transformers.MgpstrModel]]

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

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

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

**Paramètres :**

config ([MgpstrConfig](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Mgp Str brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor). Voir [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MgpstrProcessor](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrProcessor) utilise [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) pour le traitement des images).

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MgpstrConfig](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrConfig)) et les entrées.

La méthode forward du modèle [MgpstrModel](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## MgpstrForSceneTextRecognition[[transformers.MgpstrForSceneTextRecognition]]

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

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

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

**Paramètres :**

config ([MgpstrConfig](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Transformeur MGP-STR doté de trois têtes de classification en partie supérieure (trois modules A^3 et trois couches linéaires au-dessus de la sortie du codeur du transformeur) pour la reconnaissance de texte dans les scènes (STR).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor). Voir [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MgpstrProcessor](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrProcessor) utilise [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) pour le traitement des images).

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_a3_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention des modules a3. Voir `a3_attentions` dans les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un `MgpstrModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MgpstrConfig](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrConfig)) et les entrées.

La méthode forward de [MgpstrForSceneTextRecognition](/docs/transformers/v5.23.0/fr/model_doc/mgp-str#transformers.MgpstrForSceneTextRecognition) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **logits** (`tuple(torch.Tensor)` de forme `(batch_size, config.num_character_labels)`) -- Tuple de `torch.Tensor` (un pour la sortie de caractère de forme `(batch_size, config.max_token_length, config.num_character_labels)`, + un pour la sortie de bpe de forme `(batch_size, config.max_token_length, config.num_bpe_labels)`, + un pour la sortie de wordpiece de forme `(batch_size, config.max_token_length, config.num_wordpiece_labels)`) .

  Scores de classification (avant SoftMax) des caractères, bpe et wordpiece.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **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)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```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"]'
```

