# MGP-STR

## Resumen

El modelo MGP-STR fue propuesto en [Multi-Granularity Prediction for Scene Text Recognition](https://huggingface.co/papers/2209.03592) 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)](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.*

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

 Arquitectura MGP-STR. Tomada del artículo original.

MGP-STR se entrena en dos conjuntos de datos sintéticos [MJSynth](http://www.robots.ox.ac.uk/~vgg/data/text/) (MJ) y [SynthText](http://www.robots.ox.ac.uk/~vgg/data/scenetext/) (ST) sin realizar un ajuste fino en otros conjuntos de datos. Alcanza resultados de última generación en seis benchmarks estándar de texto en escenas latinas, que incluyen 3 conjuntos de datos de texto regular (IC13, SVT, IIIT) y 3 irregulares (IC15, SVTP, CUTE). Este modelo fue aportado por [yuekun](https://huggingface.co/yuekun). El código original se puede encontrar [aquí](https://github.com/AlibabaResearch/AdvancedLiterateMachinery/tree/main/OCR/MGP-STR).

## Ejemplo de inferencia

[MgpstrModel](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrModel) acepta imágenes como entrada y genera tres tipos de predicciones, que representan información textual en diferentes niveles de granularidad. Los tres tipos de predicciones se fusionan para obtener el resultado final de la predicción.

La clase [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor) se encarga de preprocesar la imagen de entrada y [MgpstrTokenizer](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrTokenizer) decodifica los tokens de caracteres generados a la cadena objetivo. [MgpstrProcessor](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrProcessor) agrupa [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor) y [MgpstrTokenizer](/docs/transformers/main/es/model_doc/mgp-str#transformers.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

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

[Fuente](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*, 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 caracteres.

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`) : Proporción entre la dimensión oculta del MLP y la dimensión de incrustación.

qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica 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 capas.

drop_rate (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, 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 de los módulos A^3.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de 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](https://huggingface.co/alibaba-damo/mgp-str-base)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**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 a 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 lotes. 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](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend), 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[[transformers.MgpstrTokenizer.save_vocabulary]]

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

[Fuente](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)
```

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

**Parámetros:**

image_processor (`ViTImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio.

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](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrProcessor) ofrece todas las funcionalidades de [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor) y [MgpstrTokenizer](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrTokenizer). Consulte [~ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor) y [~MgpstrTokenizer](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrTokenizer) para obtener más información.

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

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

[Fuente](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` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.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[[transformers.MgpstrProcessor.batch_decode]]

```python
batch_decode(sequences)
```

[Fuente](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.

**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 a nivel de caracteres. bpe_preds (`list[str]`): La lista de oraciones decodificadas con bpe. wp_preds (`list[str]`): La lista de oraciones decodificadas con 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()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

## MgpstrModel[[transformers.MgpstrModel]]

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

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

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

**Parámetros:**

config ([MgpstrConfig](/docs/transformers/main/es/model_doc/mgp-str#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[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)
```

[Fuente](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)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor). Consulte [ViTImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MgpstrProcessor](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrProcessor) utiliza [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([MgpstrConfig](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrConfig)) y las entradas.

El método forward de [MgpstrModel](/docs/transformers/main/es/model_doc/mgp-str#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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[[transformers.MgpstrForSceneTextRecognition]]

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

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

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

**Parámetros:**

config ([MgpstrConfig](/docs/transformers/main/es/model_doc/mgp-str#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo transformer MGP-STR 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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[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)
```

[Fuente](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)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.ViTImageProcessor). Consulte [ViTImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([MgpstrProcessor](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrProcessor) utiliza [ViTImageProcessor](/docs/transformers/main/es/model_doc/vit#transformers.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 o no 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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** `MgpstrModelOutput` o `tuple(torch.Tensor)`

Un `MgpstrModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([MgpstrConfig](/docs/transformers/main/es/model_doc/mgp-str#transformers.MgpstrConfig)) y las entradas.

El método forward de [MgpstrForSceneTextRecognition](/docs/transformers/main/es/model_doc/mgp-str#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **logits** (`tuple(torch.Tensor)` de forma `(batch_size, config.num_character_labels)`) -- Tupla de `torch.Tensor` (uno para la salida de carácter de forma `(batch_size, config.max_token_length, config.num_character_labels)`, + uno para la salida de bpe de forma `(batch_size, config.max_token_length, config.num_bpe_labels)`, + uno 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.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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.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 atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

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