Transformers documentation

MGP-STR

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

Ce modèle a été publié dans HF papers le 2022-09-08 et ajouté à Hugging Face Transformers le 2023-03-13.

MGP-STR

Aperçu

Le modèle MGP-STR a été proposé dans Multi-Granularity Prediction for Scene Text Recognition 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). 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.

drawing MGP-STR architecture. Taken from the original paper.

MGP-STR est entraîné sur deux jeux de données synthétiques MJSynth (MJ) et SynthText (ST), sans fine-tuning sur d'autres jeux de données. Il obtient des résultats de l'état de l'art sur six benchmarks standard de texte en scène latin, 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. Le code d'origine est disponible ici.

Exemple d'inférence

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 est chargée de la prétraitement de l'image d'entrée et MgpstrTokenizer décode les jetons de caractères générés vers la chaîne cible. MgpstrProcessor encapsule ViTImageProcessor et 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
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

classe transformers.MgpstrConfig

< >

( 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 = Noneimage_size: list[int] | tuple[int, ...] = (32, 128)patch_size: int | list[int] | tuple[int, int] = 4num_channels: int = 3max_token_length: int = 27num_character_labels: int = 38num_bpe_labels: int = 50257num_wordpiece_labels: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12mlp_ratio: float | int = 4.0qkv_bias: bool = Truedistilled: bool = Falselayer_norm_eps: float = 1e-05drop_rate: float | int = 0.0attn_drop_rate: float | int = 0.0drop_path_rate: float | int = 0.0output_a3_attentions: bool = Falseinitializer_range: float = 0.02 )

Paramètres

  • image_size (Union[list[int], tuple[int, ...]], facultatif, par défaut (32, 128)) — La taille (résolution) de chaque image.
  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, 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) — Le 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 personnage.
  • 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, 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, 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) — 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, par défaut 0.0) — Taux de drop path pour la fusion des patches.
  • output_a3_attentions (bool, facultatif, par défaut False) — Indique si le modèle doit retourner les attentions du module A^3.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Mgp StrModel. Elle est utilisée pour instancier un modèle Mgp Str en fonction des arguments spécifiés, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.MgpstrTokenizer

< >

( vocab_fileunk_token = '[GO]'bos_token = '[GO]'eos_token = '[s]'pad_token = '[GO]'**kwargs )

Paramètres

  • vocab_file (str) — Chemin vers le fichier de vocabulaire.
  • unk_token (str, facultatif, 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, par défaut "[GO]") — Le jeton de début de séquence.
  • eos_token (str, facultatif, par défaut "[s]") — Le jeton de fin de séquence.
  • pad_token (str ou tokenizers.AddedToken, facultatif, 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, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

MgpstrProcessor

classe transformers.MgpstrProcessor

< >

( image_processor = Nonetokenizer = None**kwargs )

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 offre toutes les fonctionnalités de ViTImageProcessor et de MgpstrTokenizer. Consultez ~ViTImageProcessor et ~MgpstrTokenizer pour plus d’informations.

__call__

< >

( text = Noneimages = None**kwargs )

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, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

batch_decode

< >

( sequences ) → dict[str, any]

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 des scores char, bpe et wp. scores (list[float]) : Les scores finaux après fusion des 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() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

MgpstrModel

classe transformers.MgpstrModel

< >

( config: MgpstrConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( pixel_values: FloatTensoroutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.FloatTensor)

Paramètres

  • pixel_values (torch.FloatTensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de ViTImageProcessor. Voir ViTImageProcessor.call() pour plus de détails (MgpstrProcessor utilise 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. Consultez 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 sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

BaseModelOutput ou tuple(torch.FloatTensor)

Un BaseModelOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MgpstrConfig) et des entrées.

La méthode forward du modèle 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.FloatTensor 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

MgpstrForSceneTextRecognition

classe transformers.MgpstrForSceneTextRecognition

< >

( config: MgpstrConfig )

Paramètres

  • config (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() pour charger les poids du modèle.

Transformeur de modèle MGP-STR avec trois têtes de classification au sommet (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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( pixel_values: FloatTensoroutput_attentions: bool | None = Noneoutput_a3_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MgpstrModelOutput or tuple(torch.FloatTensor)

Paramètres

  • pixel_values (torch.FloatTensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de ViTImageProcessor. Voir ViTImageProcessor.call() pour plus de détails (MgpstrProcessor utilise 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. Consultez 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 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 sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

MgpstrModelOutput ou tuple(torch.FloatTensor)

Un MgpstrModelOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (MgpstrConfig) et des entrées.

La méthode forward de 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.FloatTensor) de forme (batch_size, config.num_character_labels)) — Tuple de torch.FloatTensor (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.FloatTensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

  • a3_attentions (tuple(torch.FloatTensor), optional, returned when output_a3_attentions=True is passed or when config.output_a3_attentions=True) — Tuple of torch.FloatTensor (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)`.

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

Exemple :

>>> 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"]'
Update on GitHub