Hugging Face's logo

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

Este modelo se publicó en HF papers el 2022-09-08 y se contribuyó a Hugging Face Transformers el 2023-03-13.

MGP-STR

Resumen

El modelo MGP-STR fue propuesto en Multi-Granularity Prediction for Scene Text Recognition por Peng Wang, Cheng Da y Cong Yao. MGP-STR es un modelo de reconocimiento de texto en escenas (STR) conceptualmente sencillo pero potente, construido sobre el Vision Transformer (ViT). Para integrar el conocimiento lingüístico, se propone la estrategia de Predicción Multi-Granularidad (MGP) para inyectar información de la modalidad lingüística en el modelo de manera implícita.

El resumen del artículo es el siguiente:

El reconocimiento de texto en escenas (STR) ha sido un tema de investigación activo en visión por computadora durante años. Para abordar este problema desafiante, se han propuesto sucesivamente numerosos métodos innovadores, y la incorporación de conocimiento lingüístico en los modelos de STR se ha convertido recientemente en una tendencia destacada. En este trabajo, primero nos inspiramos en los avances recientes en Vision Transformer (ViT) para construir un modelo de STR visual conceptualmente simple pero potente, que se basa en ViT y supera a los modelos de estado del arte anteriores para el reconocimiento de texto en escenas, incluidos tanto los modelos puramente visuales como los métodos aumentados con lenguaje. Para integrar el conocimiento lingüístico, proponemos además una estrategia de Predicción de Multi-Granularidad para inyectar información de la modalidad del lenguaje en el modelo de manera implícita, es decir, se introducen representaciones de subpalabras (BPE y WordPiece) ampliamente utilizadas en PLN en el espacio de salida, además de la representación convencional a nivel de caracteres, sin adoptar un modelo de lenguaje (LM) independiente. El algoritmo resultante (denominado MGP-STR) es capaz de llevar el límite de rendimiento del STR a un nivel aún más alto. Específicamente, logra una precisión de reconocimiento promedio del 93,35 % en los benchmarks estándar.

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

MGP-STR se entrena en dos conjuntos de datos sintéticos MJSynth (MJ) y SynthText (ST) sin realizar un ajuste fino en otros conjuntos de datos. Alcanza resultados de última generación en seis benchmarks estándar de texto escenas en latín, que incluyen 3 conjuntos de datos de texto regular (IC13, SVT, IIIT) y 3 irregulares (IC15, SVTP, CUTE). Este modelo fue aportado por yuekun. El código original se puede encontrar aquí.

Ejemplo de inferencia

MgpstrModel acepta imágenes como entrada y genera tres tipos de predicciones, que representan información textual en diferentes granularidades. Los tres tipos de predicciones se fusionan para dar el resultado final de la predicción.

La clase ViTImageProcessor se encarga de preprocesar la imagen de entrada y MgpstrTokenizer decodifica los tokens de caracteres generados a la cadena objetivo. MgpstrProcessor agrupa ViTImageProcessor y MgpstrTokenizer en una única instancia para extraer las características de entrada y decodificar los ids de tokens predichos.

  • Reconocimiento Óptico de Caracteres (OCR) paso a paso
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

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

Parámetros

  • image_size (Union[list[int], tuple[int, ...]], opcional, valor predeterminado (32, 128)) — El tamaño (resolución) de cada imagen.
  • patch_size (Union[int, list[int], tuple[int, int]], opcional, valor predeterminado 4) — El tamaño (resolución) de cada parche.
  • num_channels (int, opcional, valor predeterminado 3) — El número de canales de entrada.
  • max_token_length (int, opcional, valor predeterminado 27) — El número máximo de tokens de salida.
  • num_character_labels (int, opcional, valor predeterminado 38) — El número de clases para la cabeza de personaje.
  • num_bpe_labels (int, opcional, valor predeterminado 50257) — El número de clases para la cabeza bpe.
  • num_wordpiece_labels (int, opcional, valor predeterminado 30522) — El número de clases para la cabecera de wordpiece.
  • hidden_size (int, opcional, valor predeterminado 768) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • mlp_ratio (Union[float, int], opcional, valor predeterminado 4.0) — Relación entre la dimensión oculta del MLP y la dimensión de la incrustación.
  • qkv_bias (bool, opcional, valor predeterminado True) — Si se debe añadir un sesgo a las consultas, claves y valores.
  • distilled (bool, opcional, valor predeterminado False) — El modelo incluye un token y una cabeza de destilación, como en los modelos DeiT.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-05) — El epsilon utilizado por las capas de normalización de capa.
  • drop_rate (float, opcional, valor predeterminado 0.0) — La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings y el codificador.
  • attn_drop_rate (float, opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • drop_path_rate (Union[float, int], opcional, valor predeterminado 0.0) — Tasa de drop path para la fusión de parches.
  • output_a3_attentions (bool, opcional, valor predeterminado False) — Indica si el modelo debe devolver las atenciones del módulo A^3.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un Mgp StrModel. Se utiliza para instanciar un modelo Mgp Str según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de alibaba-damo/mgp-str-base

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.MgpstrTokenizer

< >

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

Parámetros

  • vocab_file (str) — Ruta al archivo de vocabulario.
  • unk_token (str, opcional, valor predeterminado "[GO]") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.
  • bos_token (str, opcional, valor predeterminado "[GO]") — El token de inicio de secuencia.
  • eos_token (str, opcional, valor predeterminado "[s]") — El token de fin de secuencia.
  • pad_token (str o tokenizers.AddedToken, opcional, valor predeterminado "[GO]") — Un token especial utilizado para que los arreglos de tokens tengan el mismo tamaño con fines de lote. Luego será ignorado por los mecanismos de atención o el cálculo de la pérdida.

Construye un tokenizador de caracteres MGP-STR.

Este tokenizador hereda de PreTrainedTokenizer, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

MgpstrProcessor

clase transformers.MgpstrProcessor

< >

( image_processor = Nonetokenizer = None**kwargs )

Parámetros

  • image_processor (ViTImageProcessor) — El procesador de imágenes es una entrada obligatoria.
  • tokenizer (MgpstrTokenizer) — El tokenizador es una entrada obligatoria.

Construye un MgpstrProcessor que envuelve un procesador de imágenes y un tokenizador en un único procesador.

MgpstrProcessor ofrece todas las funcionalidades de ViTImageProcessor y MgpstrTokenizer. Consulte ~ViTImageProcessor y ~MgpstrTokenizer para obtener más información.

__call__

< >

( text = Noneimages = None**kwargs )

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 o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.

batch_decode

< >

( sequences ) → dict[str, any]

Parámetros

  • sequences (torch.Tensor) — Lista de ids de entrada tokenizados.

Devuelve

dict[str, any]

Diccionario con todas las salidas de los resultados decodificados. generated_text (list[str]): Los resultados finales tras la fusión de char, bpe y wp. scores (list[float]): Las puntuaciones finales tras la fusión de char, bpe y wp. char_preds (list[str]): La lista de oraciones decodificadas por caracteres. bpe_preds (list[str]): La lista de oraciones decodificadas por bpe. wp_preds (list[str]): La lista de oraciones decodificadas por wp.

Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.

Este método reenvía todos sus argumentos a batch_decode() de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

MgpstrModel

clase transformers.MgpstrModel

< >

( config: MgpstrConfig )

Parámetros

  • config (MgpstrConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo Mgp Str básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

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

Parámetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando ViTImageProcessor. Consulte ViTImageProcessor.call() para más detalles (MgpstrProcessor utiliza ViTImageProcessor para procesar las imágenes).
  • output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
  • output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
  • return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

BaseModelOutput o tuple(torch.FloatTensor)

Un BaseModelOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MgpstrConfig) y las entradas.

El método forward de MgpstrModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

MgpstrForSceneTextRecognition

clase transformers.MgpstrForSceneTextRecognition

< >

( config: MgpstrConfig )

Parámetros

  • config (MgpstrConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

MGP-STR Modelo transformer con tres cabezas de clasificación en la parte superior (tres módulos A^3 y tres capas lineales sobre la salida del codificador transformer) para el reconocimiento de texto en escenas (STR).

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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)

Parámetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando ViTImageProcessor. Consulte ViTImageProcessor.call() para más detalles (MgpstrProcessor utiliza ViTImageProcessor para procesar las imágenes).
  • output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
  • output_a3_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de los módulos a3. Consulte a3_attentions en los tensores devueltos para obtener más detalles.
  • output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
  • return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

MgpstrModelOutput o tuple(torch.FloatTensor)

Un MgpstrModelOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MgpstrConfig) y las entradas.

El método forward de MgpstrForSceneTextRecognition sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • logits (tuple(torch.FloatTensor) de forma (batch_size, config.num_character_labels)) — Tupla de torch.FloatTensor (una para la salida de carácter de forma (batch_size, config.max_token_length, config.num_character_labels), + una para la salida de bpe de forma (batch_size, config.max_token_length, config.num_bpe_labels), + una para la salida de wordpiece de forma (batch_size, config.max_token_length, config.num_wordpiece_labels)) .

    Puntuaciones de clasificación (antes de SoftMax) de character, bpe y wordpiece.

  • hidden_states (tuple[torch.FloatTensor], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple[torch.FloatTensor], opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

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

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

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

←MetaCLIP 2 MiniCPM-OCR→