Hugging Face's logo

Transformers documentation

LayoutLM

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 31-12-2019 y se contribuyó a Hugging Face Transformers el 16-11-2020.

LayoutLM

LayoutLM aprende conjuntamente el texto y el diseño del documento, en lugar de centrarse únicamente en el texto. Incorpora información posicional del diseño y características visuales de las palabras de las imágenes del documento.

Puedes encontrar todos los puntos de control originales de LayoutLM en la colección LayoutLM.

Haz clic en los modelos de LayoutLM en la barra lateral derecha para ver más ejemplos de cómo aplicar LayoutLM a diferentes tareas de visión y lenguaje.

El siguiente ejemplo demuestra la respuesta a preguntas con la clase AutoModel.

AutoModel
import torch
from datasets import load_dataset

from transformers import AutoTokenizer, LayoutLMForQuestionAnswering


tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", device_map="auto")

dataset = load_dataset("nielsr/funsd", split="train")
example = dataset[0]
question = "what's his name?"
words = example["words"]
boxes = example["bboxes"]

encoding = tokenizer(
    question.split(),
    words,
    is_split_into_words=True,
    return_token_type_ids=True,
    return_tensors="pt"
)
bbox = []
for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
    if s == 1:
        bbox.append(boxes[w])
    elif i == tokenizer.sep_token_id:
        bbox.append([1000] * 4)
    else:
        bbox.append([0] * 4)
encoding["bbox"] = torch.tensor([bbox])

word_ids = encoding.word_ids(0)
outputs = model(**encoding)
loss = outputs.loss
start_scores = outputs.start_logits
end_scores = outputs.end_logits
start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
print(" ".join(words[start : end + 1]))

Notas

  • El LayoutLM original no fue diseñado con un flujo de trabajo de procesamiento unificado. En su lugar, espera texto preprocesado (words) y cajas delimitadoras (boxes) de un motor OCR externo (como Pytesseract) y proporciona estos como entradas adicionales al tokenizador.

  • El método forward() espera la entrada bbox (cajas delimitadoras de los tokens de entrada). Cada caja delimitadora debe estar en el formato (x0, y0, x1, y1). (x0, y0) corresponde a la esquina superior izquierda de la caja delimitadora y (x1, y1) corresponde a la esquina inferior derecha. Las cajas delimitadoras deben normalizarse en una escala de 0 a 1000, como se muestra a continuación.

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)),
    ]
  • width y height corresponden al ancho y alto del documento original en el que aparece el token. Estos valores se pueden obtener como se muestra a continuación.
from PIL import Image


# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con LayoutLM. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. El recurso debería demostrar algo nuevo en lugar de duplicar un recurso existente.

LayoutLMConfig

clase transformers.LayoutLMConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0eos_token_id: int | list[int] | None = Nonebos_token_id: int | None = Noneuse_cache: bool = Truemax_2d_position_embeddings: int = 1024tie_word_embeddings: bool = True )

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 del 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 las incrustaciones, 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 del 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 capa.
  • pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario.
  • bos_token_id (int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante si config.is_decoder=True o cuando el modelo es un modelo generativo solo de decodificador.
  • max_2d_position_embeddings (int, opcional, valor predeterminado 1024) — El valor máximo que podría llegar a usarse en el embedding de posición 2D. Normalmente, se establece en un valor grande por si acaso (p. ej., 1024).
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un LayoutLMModel. Se utiliza para instanciar un modelo Layoutlm 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/layoutlm-base-uncased

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

Ejemplos:

>>> from transformers import LayoutLMConfig, LayoutLMModel

>>> # Initializing a LayoutLM configuration
>>> configuration = LayoutLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LayoutLMModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

LayoutLMTokenizer

clase transformers.BertTokenizer

< >

( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs )

Parámetros

  • vocab (str o dict[str, int], opcional) — Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde vocab_file.
  • do_lower_case (bool, opcional, valor predeterminado True) — Si se debe convertir la entrada a 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.
  • tokenize_chinese_chars (bool, opcional, valor predeterminado True) — Si se tokenizan o no los caracteres chinos.
  • 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 (como en BERT original).

Construye un tokenizador de BERT (respaldado por la biblioteca tokenizers de HuggingFace). Basado en WordPiece.

Este tokenizador hereda de 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.

__call__

< >

( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding

Parámetros

  • text (str, list[str], list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), debe establecer is_split_into_words=True (para eliminar la ambigüedad con un lote de secuencias).
  • text_pair (str, list[str], list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pre-tokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), debe establecer is_split_into_words=True (para eliminar la ambigüedad con un lote de secuencias).
  • text_target (str, list[str], list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pretokenizadas), debe establecer is_split_into_words=True (para eliminar la ambigüedad con un lote de secuencias).
  • text_pair_target (str, list[str], list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pretokenizadas), debe establecer is_split_into_words=True (para eliminar la ambigüedad con un lote de secuencias).
  • tokenizer_kwargs (dict[str, Any], opcional) — Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos.
  • 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 deseas añadir tokens bos o eos automáticamente.
  • padding (bool, str o PaddingStrategy, opcional, el valor predeterminado es 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 diferentes longitudes).
  • truncation (bool, str o TruncationStrategy, opcional, por defecto 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 a 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 a una longitud máxima especificada con el argumento max_length o a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).
    • 'only_second': Trunca a una longitud máxima especificada con el argumento max_length o a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).
    • False o 'do_not_truncate' (predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
  • max_length (int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.

    Si se deja sin definir o se establece en None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada 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 de desbordamiento 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 desbordamiento. El valor de este argumento define el número de tokens superpuestos.
  • is_split_into_words (bool, opcional, valor predeterminado False) — Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en True, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y las tokenizará. Esto es útil para NER o clasificación de tokens.
  • pad_to_multiple_of (int, opcional) — Si se establece, se 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).
  • padding_side (str, opcional) — El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre [‘right’, ‘left’]. El valor predeterminado se elige a partir del atributo de clase con el mismo nombre.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos Numpy np.ndarray.
  • return_token_type_ids (bool, opcional) — 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 return_outputs atributo.

    ¿Qué son los IDs de tipo de token?

  • return_attention_mask (bool, opcional) — 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 return_outputs atributo.

    ¿Qué son las máscaras de atención?

  • return_overflowing_tokens (bool, opcional, valor predeterminado False) — Indica si se deben devolver las secuencias de tokens que exceden el límite. 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 exceden el límite.
  • 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, por defecto False) — Si se devuelve o no (char_start, char_end) para cada token.

    Esto solo está disponible en los tokenizadores rápidos que heredan de PreTrainedTokenizerFast; 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) — Si se imprime más información y advertencias.
  • **kwargs — se pasan al método self.tokenize()

Devuelve

BatchEncoding

Un BatchEncoding con los siguientes campos:

  • input_ids — Lista de ids de tokens que se enviarán a un modelo.

    ¿Qué son los IDs de entrada?

  • token_type_ids — Lista de ids de tipo de token que se enviarán a un modelo (cuando return_token_type_ids=True o si “token_type_ids” está en self.model_input_names).

    ¿Qué son los IDs de tipo de token?

  • attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando return_attention_mask=True o si “attention_mask” está en self.model_input_names).

    ¿Qué son las máscaras de atención?

  • overflowing_tokens — Lista de secuencias de tokens que exceden el límite (cuando se especifica un max_length y return_overflowing_tokens=True).

  • num_truncated_tokens — Número de tokens truncados (cuando se especifica un max_length y return_overflowing_tokens=True).

  • special_tokens_mask — Lista de 0 y 1, donde 1 especifica los tokens especiales añadidos y 0 especifica los tokens regulares de la secuencia (cuando add_special_tokens=True y return_special_tokens_mask=True).

  • length — La longitud de las entradas (cuando return_length=True)

Método principal para tokenizar y preparar para el modelo una o varias secuencias o uno o varios pares de secuencias.

LayoutLMModel

clase transformers.LayoutLMModel

< >

( config: LayoutLMConfig )

Parámetros

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

El modelo Layoutlm básico que emite estados ocultos sin ninguna cabeza específica en la parte superior.

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 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. Consulte Resumen para la normalización.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 o tuple(torch.Tensor)

Un 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 (LayoutLMConfig) y las entradas.

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

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

  • last_hidden_state (torch.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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

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

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

Ejemplos:

>>> from transformers import AutoTokenizer, LayoutLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

LayoutLMForMaskedLM

clase transformers.LayoutLMForMaskedLM

< >

( config: LayoutLMConfig )

Parámetros

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

El modelo Layoutlm con una cabeza de language modeling en la parte superior.”

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MaskedLMOutput or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 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. Consulte Resumen para la normalización.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 modelado de lenguaje enmascarado. Los índices deben estar en [-100, 0, ..., config.vocab_size] (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].

Devuelve

MaskedLMOutput o tuple(torch.Tensor)

Un MaskedLMOutput 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 (LayoutLMConfig) y las entradas.

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

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

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje enmascarado (MLM).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

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

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

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

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

Ejemplos:

>>> from transformers import AutoTokenizer, LayoutLMForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="pt")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

LayoutLMForSequenceClassification

clase transformers.LayoutLMForSequenceClassification

< >

( config: LayoutLMConfig )

Parámetros

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

Modelo LayoutLM con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas de clasificación de imágenes de documentos como el conjunto de datos RVL-CDIP.

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 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. Consulte Resumen para la normalización.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 o tuple(torch.Tensor)

Un 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 (LayoutLMConfig) y las entradas.

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

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

  • 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

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

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

Ejemplos:

>>> from transformers import AutoTokenizer, LayoutLMForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> sequence_label = torch.tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForTokenClassification

clase transformers.LayoutLMForTokenClassification

< >

( config: LayoutLMConfig )

Parámetros

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

Modelo LayoutLM con una cabeza de clasificación de tokens en la parte superior (una capa lineal sobre la salida de los estados ocultos), por ejemplo, para tareas de etiquetado de secuencias (extracción de información) como el conjunto de datos FUNSD y el conjunto de datos SROIE.

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 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. Consulte Resumen para la normalización.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 o tuple(torch.Tensor)

Un 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 (LayoutLMConfig) y las entradas.

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

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

  • 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

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

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

Ejemplos:

>>> from transformers import AutoTokenizer, LayoutLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> token_labels = torch.tensor([1, 1, 0, 0]).unsqueeze(0)  # batch size of 1

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForQuestionAnswering

clase transformers.LayoutLMForQuestionAnswering

< >

( config: LayoutLMConfighas_visual_segment_embedding = True )

Parámetros

  • config (LayoutLMConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
  • has_visual_segment_embedding (bool, opcional, valor predeterminado True) — Indica si se deben añadir embeddings de segmentos visuales.

El transformer Layoutlm 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 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. Consulte Resumen para la normalización.
  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 o tuple(torch.Tensor)

Un 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 (LayoutLMConfig) y las entradas.

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

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

  • 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

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

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

Ejemplo:

En el ejemplo siguiente, preparamos un par de pregunta + contexto para el modelo LayoutLM. Nos dará una predicción de lo que cree que es la respuesta (el tramo de la respuesta dentro de los textos extraídos de la imagen).

>>> from transformers import AutoTokenizer, LayoutLMForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="pt"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = torch.tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez
Update on GitHub

←KOSMOS-2.5 LayoutLMV2→