# LayoutLMV2 ## Resumen El modelo LayoutLMV2 se propuso en [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://huggingface.co/papers/2012.14740) de Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang y Lidong Zhou. LayoutLMV2 mejora a [LayoutLM](layoutlm) para obtener resultados de última generación en varios benchmarks de comprensión de imágenes de documentos: - extracción de información de documentos escaneados: el conjunto de datos [FUNSD](https://guillaumejaume.github.io/FUNSD/) (una colección de 199 formularios anotados que comprende más de 30.000 palabras), el conjunto de datos [CORD](https://github.com/clovaai/cord) (una colección de 800 recibos para entrenamiento, 100 para validación y 100 para pruebas), el conjunto de datos [SROIE](https://rrc.cvc.uab.es/?ch=13) (una colección de 626 recibos para entrenamiento y 347 recibos para pruebas) y el conjunto de datos [Kleister-NDA](https://github.com/applicaai/kleister-nda) (una colección de acuerdos de confidencialidad de la base de datos EDGAR, que incluye 254 documentos para entrenamiento, 83 documentos para validación y 203 documentos para pruebas). - clasificación de imágenes de documentos: el conjunto de datos [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/) (una colección de 400.000 imágenes que pertenecen a una de 16 clases). - Preguntas visuales sobre documentos: el conjunto de datos [DocVQA](https://huggingface.co/papers/2007.00398) (una colección de 50.000 preguntas definidas sobre más de 12.000 imágenes de documentos). El resumen del artículo es el siguiente: *El preentrenamiento de texto y diseño ha demostrado ser eficaz en una variedad de tareas de comprensión de documentos visualmente ricos, gracias a su arquitectura de modelo eficaz y a la ventaja de contar con documentos digitalizados/digitales nativos a gran escala sin etiquetar. En este artículo, presentamos LayoutLMv2 mediante el preentrenamiento de texto, diseño e imagen en un marco multimodal, donde se aprovechan nuevas arquitecturas de modelo y tareas de preentrenamiento. Específicamente, LayoutLMv2 no solo utiliza la tarea existente de modelado visual-lingüístico enmascarado, sino también las nuevas tareas de alineación texto-imagen y coincidencia texto-imagen en la etapa de preentrenamiento, donde se aprende mejor la interacción entre modalidades. Al mismo tiempo, integra un mecanismo de autoatención consciente del espacio en la arquitectura Transformer, de modo que el modelo pueda comprender plenamente la relación posicional relativa entre diferentes bloques de texto. Los resultados experimentales muestran que LayoutLMv2 supera a las líneas base fuertes y logra nuevos resultados del estado del arte en una amplia variedad de tareas de comprensión de documentos visualmente ricos, incluyendo FUNSD (0.7895 -> 0.8420), CORD (0.9493 -> 0.9601), SROIE (0.9524 -> 0.9781), Kleister-NDA (0.834 -> 0.852), RVL-CDIP (0.9443 -> 0.9564) y DocVQA (0.7295 -> 0.8672). El modelo LayoutLMv2 preentrenado está disponible públicamente en esta URL.* LayoutLMv2 depende de `detectron2`, `torchvision` y `tesseract`. Ejecute lo siguiente para instalarlos: ```bash python -m pip install 'git+https://github.com/facebookresearch/detectron2.git' python -m pip install torchvision tesseract ``` (Si estás desarrollando para LayoutLMv2, ten en cuenta que pasar los doctests también requiere la instalación de estos paquetes.) ## Consejos de uso - La principal diferencia entre LayoutLMv1 y LayoutLMv2 es que este último incorpora embeddings visuales durante el preentrenamiento (mientras que LayoutLMv1 solo añade embeddings visuales durante el ajuste fino). - LayoutLMv2 añade tanto un sesgo de atención relativo 1D como un sesgo de atención espacial 2D a las puntuaciones de atención en las capas de autoatención. Los detalles se pueden encontrar en la página 5 del [artículo](https://huggingface.co/papers/2012.14740). - Los cuadernos de demostración sobre cómo usar el modelo LayoutLMv2 en RVL-CDIP, FUNSD, DocVQA y CORD se pueden encontrar [aquí](https://github.com/NielsRogge/Transformers-Tutorials). - LayoutLMv2 utiliza el paquete [Detectron2](https://github.com/facebookresearch/detectron2/) de Facebook AI para su columna vertebral visual. Consulte [este enlace](https://detectron2.readthedocs.io/en/latest/tutorials/install.html) para obtener instrucciones de instalación. - Además de `input_ids`, [forward()](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Model.forward) espera 2 entradas adicionales, a saber, `image` y `bbox`. La entrada `image` corresponde a la imagen original del documento en la que aparecen los tokens de texto. El modelo espera que cada imagen de documento tenga un tamaño de 224x224. Esto significa que si se tiene un lote de imágenes de documentos, `image` debe ser un tensor de forma (batch_size, 3, 224, 224). Esto puede ser un `torch.Tensor` o un `Detectron2.structures.ImageList`. No es necesario normalizar los canales, ya que el modelo lo hace. Es importante tener en cuenta que el backbone visual espera canales BGR en lugar de RGB, ya que todos los modelos de Detectron2 se preentrenan utilizando el formato BGR. La entrada `bbox` son las cajas delimitadoras (es decir, posiciones 2D) de los tokens de texto de entrada. Esto es idéntico a [LayoutLMModel](/docs/transformers/main/es/model_doc/layoutlm#transformers.LayoutLMModel). Estas se pueden obtener utilizando un motor de OCR externo, como [Tesseract](https://github.com/tesseract-ocr/tesseract) de Google (hay un [envoltorio de Python](https://pypi.org/project/pytesseract/) disponible). Cada caja delimitadora debe estar en el formato (x0, y0, x1, y1), donde (x0, y0) corresponde a la posición de la esquina superior izquierda de la caja delimitadora, y (x1, y1) representa la posición de la esquina inferior derecha. Tenga en cuenta que primero se deben normalizar las cajas delimitadoras para que estén en una escala de 0 a 1000. Para normalizar, puede usar la siguiente función: ```python def normalize_bbox(bbox, width, height): return [ int(1000 * (bbox[0] / width)), int(1000 * (bbox[1] / height)), int(1000 * (bbox[2] / width)), int(1000 * (bbox[3] / height)), ] ``` Aquí, `width` y `height` corresponden al ancho y alto del documento original en el que aparece el token (antes de redimensionar la imagen). Esos valores se pueden obtener, por ejemplo, utilizando la biblioteca Python Image Library (PIL), de la siguiente manera: ```python from PIL import Image image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ) width, height = image.size ``` Sin embargo, este modelo incluye un [LayoutLMv2Processor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) completamente nuevo que se puede usar para preparar directamente los datos para el modelo (incluyendo la aplicación de OCR internamente). Más información se puede encontrar en la sección "Usage" a continuación. - Internamente, [LayoutLMv2Model](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Model) enviará la entrada `image` a través de su columna vertebral visual para obtener un mapa de características de menor resolución, cuya forma es igual al atributo `image_feature_pool_shape` de [LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config). A continuación, este mapa de características se aplana para obtener una secuencia de tokens de imagen. Dado que el tamaño del mapa de características es de 7x7 por defecto, se obtienen 49 tokens de imagen. Estos se concatenan con los tokens de texto y se envían al codificador Transformer. Esto significa que los últimos estados ocultos del modelo tendrán una longitud de 512 + 49 = 561, si se rellenan los tokens de texto hasta la longitud máxima. De manera más general, los últimos estados ocultos tendrán una forma de `seq_length` + `image_feature_pool_shape[0]` * `config.image_feature_pool_shape[1]`. - Al llamar a [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained), se imprimirá una advertencia con una lista larga de nombres de parámetros que no están inicializados. Esto no es un problema, ya que estos parámetros son estadísticas de normalización por lote, que tendrán valores al realizar el ajuste fino en un conjunto de datos personalizado. - Si desea entrenar el modelo en un entorno distribuido, asegúrese de llamar a `synchronize_batch_norm` en el modelo para sincronizar correctamente las capas de normalización por lote del esqueleto visual. Además, existe LayoutXLM, que es una versión multilingüe de LayoutLMv2. Más información se puede encontrar en [la página de documentación de LayoutXLM](layoutxlm). ## Recursos Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con LayoutLMv2. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente. - Un cuaderno sobre cómo [ajustar finamente LayoutLMv2 para la clasificación de texto en el conjunto de datos RVL-CDIP](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/RVL-CDIP/Fine_tuning_LayoutLMv2ForSequenceClassification_on_RVL_CDIP.ipynb). - Véase también: [Guía de la tarea de clasificación de texto](../tasks/sequence_classification) - Un cuaderno sobre cómo [ajustar finamente LayoutLMv2 para responder preguntas en el conjunto de datos DocVQA](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/DocVQA/Fine_tuning_LayoutLMv2ForQuestionAnswering_on_DocVQA.ipynb). - Véase también: [Guía de la tarea de respuesta a preguntas](../tasks/question_answering) - Véase también: [Guía de la tarea de respuesta a preguntas de documentos](../tasks/document_question_answering) - Un cuaderno sobre cómo [ajustar finamente LayoutLMv2 para la clasificación de tokens en el conjunto de datos CORD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/CORD/Fine_tuning_LayoutLMv2ForTokenClassification_on_CORD.ipynb). - Un cuaderno sobre cómo [ajustar finamente LayoutLMv2 para la clasificación de tokens en el conjunto de datos FUNSD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Fine_tuning_LayoutLMv2ForTokenClassification_on_FUNSD_using_HuggingFace_Trainer.ipynb). - Véase también: [Guía de la tarea de clasificación de tokens](../tasks/token_classification) ## Uso: LayoutLMv2Processor La forma más sencilla de preparar los datos para el modelo es utilizar [LayoutLMv2Processor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), que internamente combina un procesador de imágenes ([LayoutLMv2ImageProcessor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor)) y un tokenizador ([LayoutLMv2Tokenizer](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) o [LayoutLMv2TokenizerFast](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer)). El procesador de imágenes gestiona la modalidad de imagen, mientras que el tokenizador gestiona la modalidad de texto. Un procesador combina ambas, lo cual es ideal para un modelo multimodal como LayoutLMv2. Tenga en cuenta que aún puede utilizar ambos por separado si solo desea manejar una modalidad. ```python from transformers import LayoutLMv2ImageProcessor, LayoutLMv2Processor, LayoutLMv2TokenizerFast image_processor = LayoutLMv2ImageProcessor() # apply_ocr is set to True by default tokenizer = LayoutLMv2TokenizerFast.from_pretrained("microsoft/layoutlmv2-base-uncased") processor = LayoutLMv2Processor(image_processor, tokenizer) ``` En resumen, se puede proporcionar una imagen de un documento (y posiblemente datos adicionales) a [LayoutLMv2Processor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), y este creará las entradas que el modelo espera. Internamente, el procesador primero utiliza [LayoutLMv2ImageProcessor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) para aplicar OCR a la imagen y obtener una lista de palabras y cajas delimitadoras normalizadas, así como para redimensionar la imagen a un tamaño dado con el fin de obtener la entrada `image`. A continuación, las palabras y las cajas delimitadoras normalizadas se proporcionan a [LayoutLMv2Tokenizer](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) o [LayoutLMv2TokenizerFast](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer), que las convierte en `input_ids`, `attention_mask`, `token_type_ids` y `bbox` a nivel de token. Opcionalmente, se pueden proporcionar etiquetas de palabras al procesador, las cuales se convierten en `labels` a nivel de token. [LayoutLMv2Processor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) utiliza [PyTesseract](https://pypi.org/project/pytesseract/), un envoltorio de Python para el motor de OCR Tesseract de Google, en su interior. Tenga en cuenta que puede seguir utilizando su propio motor de OCR preferido y proporcionar las palabras y las cajas normalizadas usted mismo. Esto requiere inicializar [LayoutLMv2ImageProcessor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) con `apply_ocr` establecido en `False`. En total, hay 5 casos de uso que son compatibles con el procesador. A continuación, los enumeramos todos. Tenga en cuenta que cada uno de estos casos de uso funciona tanto para entradas por lotes como para entradas no por lotes (los ilustramos para entradas no por lotes). **Caso de uso 1: clasificación de imágenes de documentos (entrenamiento, inferencia) + clasificación de tokens (inferencia), apply_ocr = True** Este es el caso más simple, en el que el procesador (en realidad, el procesador de imágenes) realizará OCR en la imagen para obtener las palabras y las cajas delimitadoras normalizadas. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") encoding = processor( image, return_tensors="pt" ) # you can also add all tokenizer parameters here such as padding, truncation print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 2: clasificación de imágenes de documentos (entrenamiento, inferencia) + clasificación de tokens (inferencia), apply_ocr=False** En caso de que se desee realizar OCR por cuenta propia, se puede inicializar el procesador de imágenes con `apply_ocr` establecido en `False`. En ese caso, se deben proporcionar las palabras y las cajas delimitadoras (normalizadas) correspondientes al procesador. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 3: clasificación de tokens (entrenamiento), apply_ocr=False** Para tareas de clasificación de tokens (como FUNSD, CORD, SROIE, Kleister-NDA), también se pueden proporcionar las etiquetas de palabras correspondientes para entrenar un modelo. El procesador convertirá estas etiquetas en `labels` a nivel de token. De forma predeterminada, solo etiquetará la primera subpalabra de una palabra y etiquetará las subpalabras restantes con -100, que es el `ignore_index` de CrossEntropyLoss de PyTorch. Si se desea que todas las subpalabras de una palabra estén etiquetadas, se puede inicializar el tokenizador con `only_label_first_subword` establecido en `False`. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes word_labels = [1, 2] encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'labels', 'image']) ``` **Caso de uso 4: respuesta a preguntas visuales (inferencia), apply_ocr=True** Para tareas de respuesta a preguntas visuales (como DocVQA), puedes proporcionar una pregunta al procesador. De forma predeterminada, el procesador aplicará OCR a la imagen y creará [CLS] tokens de la pregunta [SEP] tokens de palabras [SEP]. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" encoding = processor(image, question, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 5: respuesta a preguntas visuales (inferencia), apply_ocr=False** Para tareas de respuesta a preguntas visuales (como DocVQA), puedes proporcionar una pregunta al procesador. Si deseas realizar el OCR por tu cuenta, puedes proporcionar tus propias palabras y cajas delimitadoras (normalizadas) al procesador. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, question, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` ## LayoutLMv2Config[[transformers.LayoutLMv2Config]] #### transformers.LayoutLMv2Config[[transformers.LayoutLMv2Config]] ```python transformers.LayoutLMv2Config(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, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, max_2d_position_embeddings: int = 1024, max_rel_pos: int = 128, rel_pos_bins: int = 32, fast_qkv: bool = True, max_rel_2d_pos: int = 256, rel_2d_pos_bins: int = 64, convert_sync_batchnorm: bool = True, image_feature_pool_shape: list[int] | tuple[int, ...] = (7, 7, 256), coordinate_size: int = 128, shape_size: int = 128, has_relative_attention_bias: bool = True, has_spatial_attention_bias: bool = True, has_visual_segment_embedding: bool = False, detectron2_config_args: dict | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/configuration_layoutlmv2.py#L29) **Parámetros:** vocab_size (`int`, *opcional*, valor predeterminado `30522`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. 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. intermediate_size (`int`, *opcional*, valor predeterminado `3072`) : Dimensión de las representaciones MLP. hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención. max_position_embeddings (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de secuencia con la que se podría utilizar este modelo. type_vocab_size (`int`, *opcional*, valor predeterminado `2`) : El tamaño del vocabulario de `token_type_ids`. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-12`) : El epsilon utilizado por las capas de normalización de capas. pad_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el relleno en el vocabulario. max_2d_position_embeddings (`int`, *opcional*, valor predeterminado 1024) : El valor máximo con el que podría utilizarse la incrustación de posición 2D. Por lo general, se establece en un valor grande por si acaso (p. ej., 1024). max_rel_pos (`int`, *opcional*, valor predeterminado 128) : El número máximo de posiciones relativas que se utilizarán en el mecanismo de autoatención. rel_pos_bins (`int`, *opcional*, valor predeterminado: 32) : El número de bins de posición relativa que se utilizarán en el mecanismo de autoatención. fast_qkv (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar una única matriz para las consultas, claves y valores en las capas de autoatención. max_rel_2d_pos (`int`, *opcional*, valor predeterminado 256) : El número máximo de posiciones 2D relativas en el mecanismo de autoatención. rel_2d_pos_bins (`int`, *opcional*, valor predeterminado: 64) : El número de bins de posición relativa 2D en el mecanismo de autoatención. convert_sync_batchnorm (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben convertir las capas de normalización por lotes en capas de normalización por lotes sincronizadas. image_feature_pool_shape (`list[int]`, *opcional*, valor predeterminado `[7, 7, 256]`) : La forma del mapa de características con pooling promedio. coordinate_size (`int`, *opcional*, valor predeterminado 128) : Dimensión de las incrustaciones de coordenadas. shape_size (`int`, *opcional*, valor predeterminado 128) : Dimensión de los embeddings de ancho y alto. has_relative_attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe utilizar un sesgo de atención relativo en el mecanismo de autoatención. has_spatial_attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe utilizar un sesgo de atención espacial en el mecanismo de autoatención. has_visual_segment_embedding (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no añadir embeddings de segmentos visuales. detectron2_config_args (`dict`, *opcional*) : Diccionario que contiene los argumentos de configuración del backbone visual de Detectron2. Consulte [este archivo](https://github.com/microsoft/unilm/blob/master/layoutlmft/layoutlmft/models/layoutlmv2/detectron2_config.py) para obtener detalles sobre los valores predeterminados. Esta es la clase de configuración para almacenar la configuración de un LayoutLMv2Model. Se utiliza para instanciar un modelo Layoutlmv2 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 [microsoft/layoutlmv2-base-uncased](https://huggingface.co/microsoft/layoutlmv2-base-uncased) 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 LayoutLMv2Config, LayoutLMv2Model >>> # Initializing a LayoutLMv2 microsoft/layoutlmv2-base-uncased style configuration >>> configuration = LayoutLMv2Config() >>> # Initializing a model (with random weights) from the microsoft/layoutlmv2-base-uncased style configuration >>> model = LayoutLMv2Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] #### transformers.LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] ```python transformers.LayoutLMv2ImageProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_layoutlmv2.py#L118) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 224, 'width': 224}`): Describe las dimensiones máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `None`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. apply_ocr (`bool`, *kwargs*, *opcional*, valor predeterminado `self.apply_ocr`) : Indica si se debe aplicar el motor de OCR de Tesseract para obtener palabras y cajas delimitadoras normalizadas. Puede sobrescribirse mediante el parámetro `apply_ocr` en el método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : El idioma, especificado por su código ISO, que se utilizará en el motor de OCR Tesseract. Por defecto, se utiliza el inglés. Puede sobrescribirse mediante el parámetro `ocr_lang` en el método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Cualquier bandera de configuración personalizada adicional que se reenvía al parámetro `config` al llamar a Tesseract. Por ejemplo: '--psm 6'. Puede ser sobrescrito por el parámetro `tesseract_config` en el método `preprocess`. Construye un procesador de imágenes LayoutLMv2ImageProcessor. #### preprocess[[transformers.LayoutLMv2ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_layoutlmv2.py#L131) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. apply_ocr (`bool`, *kwargs*, *opcional*, valor predeterminado `self.apply_ocr`) : Indica si se debe aplicar el motor de OCR de Tesseract para obtener palabras y cajas delimitadoras normalizadas. Puede sobrescribirse mediante el parámetro `apply_ocr` en el método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : El idioma, especificado por su código ISO, que se utilizará en el motor de OCR Tesseract. Por defecto, se utiliza el inglés. Puede sobrescribirse mediante el parámetro `ocr_lang` en el método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Cualquier bandera de configuración personalizada adicional que se reenvía al parámetro `config` al llamar a Tesseract. Por ejemplo: '--psm 6'. Puede ser sobrescrito por el parámetro `tesseract_config` en el método `preprocess`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. ## LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] #### transformers.LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] ```python transformers.LayoutLMv2ImageProcessorPil(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_pil_layoutlmv2.py#L121) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 224, 'width': 224}`): Describe las dimensiones máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `None`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. apply_ocr (`bool`, *kwargs*, *opcional*, valor predeterminado `self.apply_ocr`) : Indica si se debe aplicar el motor de OCR de Tesseract para obtener palabras y cajas delimitadoras normalizadas. Puede sobrescribirse mediante el parámetro `apply_ocr` en el método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : El idioma, especificado por su código ISO, que se utilizará en el motor de OCR Tesseract. Por defecto, se utiliza el inglés. Puede sobrescribirse mediante el parámetro `ocr_lang` en el método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Cualquier bandera de configuración personalizada adicional que se reenvía al parámetro `config` al llamar a Tesseract. Por ejemplo: '--psm 6'. Puede ser sobrescrito por el parámetro `tesseract_config` en el método `preprocess`. Construye un procesador de imágenes LayoutLMv2ImageProcessor. #### preprocess[[transformers.LayoutLMv2ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_pil_layoutlmv2.py#L134) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. apply_ocr (`bool`, *kwargs*, *opcional*, valor predeterminado `self.apply_ocr`) : Indica si se debe aplicar el motor de OCR de Tesseract para obtener palabras y cajas delimitadoras normalizadas. Puede sobrescribirse mediante el parámetro `apply_ocr` en el método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : El idioma, especificado por su código ISO, que se utilizará en el motor de OCR Tesseract. Por defecto, se utiliza el inglés. Puede sobrescribirse mediante el parámetro `ocr_lang` en el método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Cualquier bandera de configuración personalizada adicional que se reenvía al parámetro `config` al llamar a Tesseract. Por ejemplo: '--psm 6'. Puede ser sobrescrito por el parámetro `tesseract_config` en el método `preprocess`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. ## LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] #### transformers.LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] ```python transformers.LayoutLMv2Tokenizer(vocab: str | dict[str, int] | None = None, do_lower_case = True, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', cls_token_box = [0, 0, 0, 0], sep_token_box = [1000, 1000, 1000, 1000], pad_token_box = [0, 0, 0, 0], pad_token_label = -100, only_label_first_subword = True, tokenize_chinese_chars = True, strip_accents = None, model_max_length = 512, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L112) **Parámetros:** vocab_file (`str`) : Archivo que contiene el vocabulario. do_lower_case (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe convertir la entrada en minúsculas al tokenizar. unk_token (`str`, *opcional*, valor predeterminado `"[UNK]"`) : 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. sep_token (`str`, *opcional*, valor predeterminado `"[SEP]"`) : El token separador, que se utiliza al construir una secuencia a partir de varias secuencias, por ejemplo, dos secuencias para la clasificación de secuencias o un texto y una pregunta para la respuesta a preguntas. También se utiliza como el último token de una secuencia construida con tokens especiales. pad_token (`str`, *opcional*, valor predeterminado `"[PAD]"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes. cls_token (`str`, *opcional*, valor predeterminado `"[CLS]"`) : El token clasificador que se utiliza al realizar clasificación de secuencias (clasificación de la secuencia completa en lugar de clasificación por token). Es el primer token de la secuencia cuando se construye con tokens especiales. mask_token (`str`, *opcional*, valor predeterminado `"[MASK]"`) : El token utilizado para enmascarar valores. Este es el token que se emplea al entrenar este modelo con modelado de lenguaje enmascarado. Es el token que el modelo intentará predecir. cls_token_box (`List[int]`, *opcional*, valor predeterminado `[0, 0, 0, 0]`) : El recuadro delimitador que se usará para el token especial [CLS]. sep_token_box (`List[int]`, *opcional*, valor predeterminado `[1000, 1000, 1000, 1000]`) : El recuadro delimitador que se usará para el token especial [SEP]. pad_token_box (`List[int]`, *opcional*, valor predeterminado `[0, 0, 0, 0]`) : El recuadro delimitador que se usará para el token especial [PAD]. pad_token_label (`int`, *opcional*, valor predeterminado -100) : La etiqueta que se usará para los tokens de relleno. El valor predeterminado es -100, que corresponde a `ignore_index` de CrossEntropyLoss de PyTorch. only_label_first_subword (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe etiquetar únicamente el primer subtoken, en caso de que se proporcionen etiquetas de palabras. tokenize_chinese_chars (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben tokenizar los caracteres chinos. Probablemente debería desactivarse para el japonés (ver [este problema](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *opcional*) : Indica si se deben eliminar todas las tildes. Si no se especifica esta opción, se determinará en función del valor de `lowercase` (tal como en el LayoutLMv2 original). Construye un tokenizador "rápido" de LayoutLMv2 (respaldado por la biblioteca *tokenizers* de HuggingFace). Basado en WordPiece. Este tokenizador hereda de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend), 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. #### __llamada__[[transformers.LayoutLMv2Tokenizer.__call__]] ```python __call__(text: str | list[str] | list[list[str]], text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L243) **Parámetros:** text (`str`, `List[str]`, `List[List[str]]`) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres, una lista de cadenas (palabras de un solo ejemplo o preguntas de un lote de ejemplos) o una lista de listas de cadenas (lote de palabras). text_pair (`List[str]`, `List[List[str]]`) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia debe ser una lista de cadenas de caracteres (cadenas pretokenizadas). boxes (`List[List[int]]`, `List[List[List[int]]]`) : Cuadros delimitadores a nivel de palabra. Cada cuadro delimitador debe estar normalizado en una escala de 0 a 1000. word_labels (`List[int]`, `List[List[int]]`, *opcional*) : Etiquetas enteras a nivel de palabra (para tareas de clasificación de tokens como FUNSD, CORD). add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben codificar las secuencias con los tokens especiales relativos a su modelo. padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores: - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes). truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores: - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo). max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos. pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta). return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son las máscaras de atención?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan. return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales. return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`. return_length (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las longitudes de las entradas codificadas. verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias. - ****kwargs** : se pasan al método `self.tokenize()` Método principal para tokenizar y preparar para el modelo una o varias secuencias o uno o varios pares de secuencias con cajas delimitadoras normalizadas a nivel de palabra y etiquetas opcionales. #### save_vocabulary[[transformers.LayoutLMv2Tokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L547) ## LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] #### transformers.LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] ```python transformers.LayoutLMv2Processor(image_processor = None, tokenizer = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L24) **Parámetros:** image_processor (`LayoutLMv2ImageProcessor`) : El procesador de imágenes es una entrada obligatoria. tokenizer (`LayoutLMv2Tokenizer`) : El tokenizador es una entrada obligatoria. Construye un LayoutLMv2Processor que envuelve un procesador de imágenes y un tokenizador en un único procesador. [LayoutLMv2Processor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) ofrece todas las funcionalidades de [LayoutLMv2ImageProcessor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) y [LayoutLMv2Tokenizer](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer). Consulte [~LayoutLMv2ImageProcessor](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) y [~LayoutLMv2Tokenizer](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) para obtener más información. #### __llamada__[[transformers.LayoutLMv2Processor.__call__]] ```python __call__(images, text: str | list[str] | list[list[str]] = None, text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L28) **Parámetros:** 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`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote. text_pair (`str, list[str] or list[int]`, *opcional*) : Secuencia secundaria opcional que se debe codificar. Puede ser una cadena, una lista de cadenas (cadena tokenizada mediante el método `tokenize`) o una lista de enteros (ids de tokens de una cadena tokenizada mediante el método `convert_tokens_to_ids`). boxes (`list[list[int]] or list[list[list[int]]]`, *opcional*) : Cuadros delimitadores a nivel de palabra. Cada cuadro delimitador debe estar normalizado en una escala de 0 a 1000. word_labels (`list[int] or list[list[int]]`, *opcional*) : Etiquetas enteras a nivel de palabra (para tareas de clasificación de tokens como FUNSD, CORD). add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`. padding (bool, str o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores: - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes). truncation (bool, str o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores: - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño de entrada máximo admisible del modelo). max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. stride (`int`, *opcional*, valor predeterminado `0`) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos. pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta). return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son las máscaras de atención?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan. return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales. return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`. return_length (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las longitudes de las entradas codificadas. verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias. return_tensors (`Union[str, ~utils.generic.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. **Devuelve:** `~tokenization_utils_base.BatchEncoding` - **data** (`dict`, *opcional*) -- Diccionario de listas/arrays/tensores devueltos por los métodos `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). - **encoding** (`tokenizers.Encoding` o `Sequence[tokenizers.Encoding]`, *opcional*) -- Si el tokenizador es un tokenizador rápido que genera información adicional, como el mapeo del espacio de palabras/caracteres al espacio de tokens, la instancia de `tokenizers.Encoding` o la lista de instancias (para lotes) contiene esta información. - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. - **prepend_batch_axis** (`bool`, *opcional*, valor predeterminado `False`) -- Indica si se debe añadir un eje de lote al convertir a tensores (consulte `tensor_type` arriba). Tenga en cuenta que este parámetro tiene efecto si el parámetro `tensor_type` está establecido, *en caso contrario no tiene efecto*. - **n_sequences** (`int`, *opcional*) -- El número de secuencias de entrada representadas por cada codificación (`None` para desconocido, `1` para una secuencia única y `2` para un par de secuencias). ## LayoutLMv2Model[[transformers.LayoutLMv2Model]] #### transformers.LayoutLMv2Model[[transformers.LayoutLMv2Model]] ```python transformers.LayoutLMv2Model(config: LayoutLMv2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L551) **Parámetros:** config ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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 Layoutlmv2 básico que emite 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.LayoutLMv2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L663) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) bbox (`torch.LongTensor` de forma `((batch_size, sequence_length), 4)`, *opcional*) : Cajas delimitadoras de los tokens de cada secuencia de entrada. Se seleccionan en el rango `[0, config.max_2d_position_embeddings-1]`. Cada caja delimitadora debe ser una versión normalizada en formato (x0, y0, x1, y1), donde (x0, y0) corresponde a la posición de la esquina superior izquierda de la caja delimitadora, y (x1, y1) representa la posición de la esquina inferior derecha. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `detectron.structures.ImageList` cuyo `tensors` es de forma `(batch_size, num_channels, height, width)`) : Lote de imágenes de documentos. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) y las entradas. El método forward de [LayoutLMv2Model](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Model) reemplaza 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. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento. - **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. Ejemplos: ```python >>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> encoding = processor(image, return_tensors="pt") >>> outputs = model(**encoding) >>> last_hidden_states = outputs.last_hidden_state >>> last_hidden_states.shape torch.Size([1, 342, 768]) ``` ## LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] #### transformers.LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] ```python transformers.LayoutLMv2ForSequenceClassification(config: LayoutLMv2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L792) **Parámetros:** config ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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 LayoutLMv2 con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la concatenación del estado oculto final del token [CLS], los embeddings visuales iniciales promediados y los embeddings visuales finales promediados, por ejemplo, para tareas de clasificación de imágenes de documentos como el conjunto de datos [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/)). 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.LayoutLMv2ForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L806) **Parámetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 4)`, *opcional*) : Cajas delimitadoras de los tokens de cada secuencia de entrada. Seleccionadas en el rango `[0, config.max_2d_position_embeddings-1]`. Cada caja delimitadora debe ser una versión normalizada en formato (x0, y0, x1, y1), donde (x0, y0) corresponde a la posición de la esquina superior izquierda de la caja delimitadora, y (x1, y1) representa la posición de la esquina inferior derecha. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `detectron.structures.ImageList` cuyo `tensors` es de forma `(batch_size, num_channels, height, width)`) : Lote de imágenes de documentos. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada). **Devuelve:** [SequenceClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) o `tuple(torch.Tensor)` Un [SequenceClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) y las entradas. El método forward de [LayoutLMv2ForSequenceClassification](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ForSequenceClassification) reemplaza 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de clasificación (o de regresión si config.num_labels==1). - **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax). - **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. Ejemplo: ```python >>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> dataset = load_dataset("aharley/rvl_cdip", split="train", streaming=True) >>> data = next(iter(dataset)) >>> image = data["image"].convert("RGB") >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForSequenceClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=dataset.info.features["label"].num_classes ... ) >>> encoding = processor(image, return_tensors="pt") >>> sequence_label = torch.tensor([data["label"]]) >>> outputs = model(**encoding, labels=sequence_label) >>> loss, logits = outputs.loss, outputs.logits >>> predicted_idx = logits.argmax(dim=-1).item() >>> predicted_answer = dataset.info.features["label"].names[4] >>> predicted_idx, predicted_answer # results are not good without further fine-tuning (7, 'advertisement') ``` ## LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] #### transformers.LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] ```python transformers.LayoutLMv2ForTokenClassification(config: LayoutLMv2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L986) **Parámetros:** config ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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 LayoutLMv2 con una cabeza de clasificación de tokens en la parte superior (una capa lineal sobre la parte de texto de los estados ocultos), por ejemplo, para tareas de etiquetado de secuencias (extracción de información) como [FUNSD](https://guillaumejaume.github.io/FUNSD/), [SROIE](https://rrc.cvc.uab.es/?ch=13), [CORD](https://github.com/clovaai/cord) y [Kleister-NDA](https://github.com/applicaai/kleister-nda). 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.LayoutLMv2ForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1000) **Parámetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 4)`, *opcional*) : Cajas delimitadoras de los tokens de cada secuencia de entrada. Seleccionadas en el rango `[0, config.max_2d_position_embeddings-1]`. Cada caja delimitadora debe ser una versión normalizada en formato (x0, y0, x1, y1), donde (x0, y0) corresponde a la posición de la esquina superior izquierda de la caja delimitadora, y (x1, y1) representa la posición de la esquina inferior derecha. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `detectron.structures.ImageList` cuyo `tensors` es de forma `(batch_size, num_channels, height, width)`) : Lote de imágenes de documentos. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación de tokens. Los índices deben estar en `[0, ..., config.num_labels - 1]`. **Devuelve:** [TokenClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) o `tuple(torch.Tensor)` Un [TokenClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) y las entradas. El método forward de [LayoutLMv2ForTokenClassification](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de clasificación. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Puntuaciones de clasificación (antes de SoftMax). - **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. Ejemplo: ```python >>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> datasets = load_dataset("nielsr/funsd", split="test") >>> labels = datasets.features["ner_tags"].feature.names >>> id2label = {v: k for v, k in enumerate(labels)} >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") >>> model = LayoutLMv2ForTokenClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=len(labels) ... ) >>> data = datasets[0] >>> image = Image.open(data["image_path"]).convert("RGB") >>> words = data["words"] >>> boxes = data["bboxes"] # make sure to normalize your bounding boxes >>> word_labels = data["ner_tags"] >>> encoding = processor( ... image, ... words, ... boxes=boxes, ... word_labels=word_labels, ... padding="max_length", ... truncation=True, ... return_tensors="pt", ... ) >>> outputs = model(**encoding) >>> logits, loss = outputs.logits, outputs.loss >>> predicted_token_class_ids = logits.argmax(-1) >>> predicted_tokens_classes = [id2label[t.item()] for t in predicted_token_class_ids[0]] >>> predicted_tokens_classes[:5] # results are not good without further fine-tuning ['I-HEADER', 'I-HEADER', 'I-QUESTION', 'I-HEADER', 'I-QUESTION'] ``` ## LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] #### transformers.LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] ```python transformers.LayoutLMv2ForQuestionAnswering(config: LayoutLMv2Config, has_visual_segment_embedding = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1121) **Parámetros:** config ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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. has_visual_segment_embedding (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben añadir o no embeddings de segmentos visuales. El transformador Layoutlmv2 con una cabeza de clasificación de tramos en la parte superior para tareas de respuesta a preguntas extractivas como SQuAD (una capa lineal sobre la salida de los estados ocultos para calcular `span start logits` y `span end logits`). 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.LayoutLMv2ForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1139) **Parámetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 4)`, *opcional*) : Cajas delimitadoras de los tokens de cada secuencia de entrada. Seleccionadas en el rango `[0, config.max_2d_position_embeddings-1]`. Cada caja delimitadora debe ser una versión normalizada en formato (x0, y0, x1, y1), donde (x0, y0) corresponde a la posición de la esquina superior izquierda de la caja delimitadora, y (x1, y1) representa la posición de la esquina inferior derecha. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `detectron.structures.ImageList` cuyo `tensors` es de forma `(batch_size, num_channels, height, width)`) : Lote de imágenes de documentos. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. start_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para la posición (índice) del inicio del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (`sequence_length`). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. end_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para la posición (índice) del final del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (`sequence_length`). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. **Devuelve:** [QuestionAnsweringModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) o `tuple(torch.Tensor)` Un [QuestionAnsweringModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) y las entradas. El método forward de [LayoutLMv2ForQuestionAnswering](/docs/transformers/main/es/model_doc/layoutlmv2#transformers.LayoutLMv2ForQuestionAnswering) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin. - **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Puntuaciones de inicio de tramo (antes de SoftMax). - **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Puntuaciones de fin de tramo (antes de SoftMax). - **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. Ejemplo: En el siguiente ejemplo, le pasamos al modelo LayoutLMv2 una imagen (de textos) y le hacemos una pregunta. Nos dará una predicción de lo que cree que es la respuesta (el fragmento de la respuesta dentro de los textos extraídos de la imagen). ```python >>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed >>> import torch >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> question = "When is coffee break?" >>> encoding = processor(image, question, return_tensors="pt") >>> outputs = model(**encoding) >>> predicted_start_idx = outputs.start_logits.argmax(-1).item() >>> predicted_end_idx = outputs.end_logits.argmax(-1).item() >>> predicted_start_idx, predicted_end_idx (30, 191) >>> predicted_answer_tokens = encoding.input_ids.squeeze()[predicted_start_idx : predicted_end_idx + 1] >>> predicted_answer = processor.tokenizer.decode(predicted_answer_tokens) >>> predicted_answer # results are not good without further fine-tuning '44 a. m. to 12 : 25 p. m. 12 : 25 to 12 : 58 p. m. 12 : 58 to 4 : 00 p. m. 2 : 00 to 5 : 00 p. m. coffee break coffee will be served for men and women in the lobby adjacent to exhibit area. please move into exhibit area. ( exhibits open ) trrf general session ( part | ) presiding : lee a. waller trrf vice president " introductory remarks " lee a. waller, trrf vice presi - dent individual interviews with trrf public board members and sci - entific advisory council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public refrigerated warehousing industry is looking for. plus questions from' ``` ```python >>> target_start_index = torch.tensor([7]) >>> target_end_index = torch.tensor([14]) >>> outputs = model(**encoding, start_positions=target_start_index, end_positions=target_end_index) >>> predicted_answer_span_start = outputs.start_logits.argmax(-1).item() >>> predicted_answer_span_end = outputs.end_logits.argmax(-1).item() >>> predicted_answer_span_start, predicted_answer_span_end (30, 191) ```