Transformers documentation
MGP-STR
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.
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
< source >( 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éfaut4) — La taille (résolution) de chaque patch. - num_channels (
int, facultatif, par défaut3) — 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éfaut768) — Dimension des représentations cachées. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - mlp_ratio (
Union[float, int], facultatif, par défaut4.0) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding. - qkv_bias (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - distilled (
bool, facultatif, par défautFalse) — 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éfaut1e-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éfaut0.0) — Taux de drop path pour la fusion des patches. - output_a3_attentions (
bool, facultatif, par défautFalse) — Indique si le modèle doit retourner les attentions du module A^3. - initializer_range (
float, facultatif, par défaut0.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.configMgpstrTokenizer
classe transformers.MgpstrTokenizer
< source >( 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 (
stroutokenizers.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.
MgpstrProcessor
classe transformers.MgpstrProcessor
< source >( image_processor = Nonetokenizer = None**kwargs )
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__
< source >( 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, setis_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, setdo_rescale=False`. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
batch_decode
< source >( sequences ) → dict[str, any]
Paramètres
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
< source >( 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
< source >( 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.FloatTensorde 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. Consultezattentionssous 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. Voirhidden_statessous 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
Moduleplutô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.FloatTensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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
< source >( 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
< source >( 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.FloatTensorde 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. Consultezattentionssous 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. Voira3_attentionssous 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. Voirhidden_statessous 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
Moduleplutô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 detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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 whenoutput_a3_attentions=Trueis passed or whenconfig.output_a3_attentions=True) — Tuple oftorch.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"]'