Transformers documentation

Longformer

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

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

Longformer

Longformer es un modelo transformer diseñado para procesar documentos largos. La operación de autoatención suele escalar de forma cuadrática con la longitud de la secuencia, lo que impide que los transformers procesen secuencias más largas. El mecanismo de atención de Longformer supera esta limitación escalando de forma lineal con la longitud de la secuencia. Combina la atención local con ventanas con la atención global específica de la tarea, lo que permite procesar de manera eficiente documentos con miles de tokens.

Puedes encontrar todos los puntos de control originales de Longformer bajo la organización Ai2.

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

El siguiente ejemplo demuestra cómo rellenar el token <mask> con Pipeline, AutoModel y desde la línea de comandos.

Pipeline

AutoModel

Notas

Longformer se basa en RoBERTa y no tiene token_type_ids. No es necesario indicar a qué segmento pertenece cada token. Solo hay que separar los segmentos con el token de separación </s> o tokenizer.sep_token.
Puede definir qué tokens pueden atender localmente y qué tokens atienden globalmente mediante global_attention_mask durante la inferencia (consulte este ejemplo para más detalles). Un valor de 0 significa que un token atiende localmente y un valor de 1 significa que un token atiende globalmente.

LongformerForMaskedLM se entrena como RobertaForMaskedLM y debe usarse como se muestra a continuación.

  input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt").to(model.device)
  mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
  loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0]

LongformerConfig

clase transformers.LongformerConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneattention_window: list[int] | int = 512sep_token_id: int | None = 2pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2vocab_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-12onnx_export: bool = Falsetie_word_embeddings: bool = True )

Parámetros

attention_window (int o list[int], opcional, valor predeterminado 512) — Tamaño de una ventana de atención alrededor de cada token. Si es un int, se utiliza el mismo tamaño para todas las capas. Para especificar un tamaño de ventana diferente para cada capa, use una list[int] donde len(attention_window) == num_hidden_layers.
sep_token_id (int, opcional, valor predeterminado 2) — Id del token utilizado como separador en el vocabulario.
pad_token_id (int, opcional, valor predeterminado 1) — Id del token utilizado para el relleno en el vocabulario.
bos_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
eos_token_id (Union[int, list[int]], opcional, valor predeterminado 2) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
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.
onnx_export (bool, opcional, predeterminado en False) — Si se debe crear un modelo que sea exportable a ONNX o no.
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 LongformerModel. Se utiliza para instanciar un modelo Longformer 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 allenai/longformer-base-4096

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

Ejemplo:

>>> from transformers import LongformerConfig, LongformerModel

>>> # Initializing a Longformer configuration
>>> configuration = LongformerConfig()

>>> # Initializing a model from the configuration
>>> model = LongformerModel(configuration)

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

LongformerTokenizer

clase transformers.RobertaTokenizer

< source >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneerrors: str = 'replace'bos_token: str = '<s>'eos_token: str = '</s>'sep_token: str = '</s>'cls_token: str = '<s>'unk_token: str = '<unk>'pad_token: str = '<pad>'mask_token: str = '<mask>'add_prefix_space: bool = Falsetrim_offsets: bool = True**kwargs )

Parámetros

vocab (str, dict o list, opcional) — Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde vocab_file.
merges (str o list, opcional) — Lista de fusiones personalizada. Si no se proporciona, las fusiones se cargan desde merges_file.
errors (str, opcional, valor predeterminado "replace") — Paradigma a seguir al decodificar bytes a UTF-8. Consulte bytes.decode para obtener más información.
bos_token (str, opcional, por defecto "<s>") — El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el inicio de la secuencia. El token que se utiliza es cls_token.

Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el inicio de la secuencia. El token que se utiliza es cls_token.
eos_token (str, opcional, por defecto es "</s>") — El token de fin de secuencia. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de la secuencia. El token que se utiliza es sep_token.

Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el final de la secuencia. El token que se utiliza es sep_token.
sep_token (str, opcional, valor predeterminado "</s>") — 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.
cls_token (str, opcional, valor predeterminado "<s>") — 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.
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.
pad_token (str, opcional, valor predeterminado "<pad>") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.
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.
add_prefix_space (bool, opcional, valor predeterminado False) — Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial como cualquier otra palabra. (El tokenizador de RoBERTa detecta el inicio de las palabras mediante el espacio que las precede).
trim_offsets (bool, opcional, valor predeterminado True) — Si el paso de posprocesado debe recortar los desplazamientos para evitar incluir espacios en blanco.

Construye un tokenizador de RoBERTa (respaldado por la biblioteca tokenizers de HuggingFace). Basado en Byte-Pair-Encoding.

Este tokenizador se ha entrenado para tratar los espacios como partes de los tokens (un poco como sentencepiece), por lo que una palabra

se codifica de manera diferente si se encuentra al principio de la oración (sin espacio) o no:

>>> from transformers import RobertaTokenizer

>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

Puede evitar ese comportamiento pasando add_prefix_space=True al instanciar este tokenizer o al llamarlo sobre algún texto, pero dado que el modelo no se preentrenó de esa manera, podría provocar una disminución en el rendimiento.

Cuando se usa con is_split_into_words=True, este tokenizador debe instanciarse con add_prefix_space=True.

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.

Salidas específicas de Longformer

clase transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput

< source >

( last_hidden_state: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneglobal_attentions: tuple[torch.Tensor, ...] | None = None )

Parámetros

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.
hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de Longformer, con posibles estados ocultos, atenciones locales y globales.

clase transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling

< source >

( last_hidden_state: Tensorpooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneglobal_attentions: tuple[torch.Tensor, ...] | None = None )

Parámetros

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), procesado adicionalmente por una capa Linear y una función de activación Tanh. Los pesos de la capa Linear 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 output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de Longformer que también contiene un agrupamiento de los últimos estados ocultos.

clase transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneglobal_attentions: tuple[torch.Tensor, ...] | None = None )

Parámetros

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, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de modelos de lenguaje enmascarados.

clase transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneglobal_attentions: tuple[torch.Tensor, ...] | None = None )

Parámetros

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), opcional) — Puntuaciones de inicio de tramo (antes de SoftMax).
end_logits (torch.Tensor de forma (batch_size, sequence_length), opcional) — Puntuaciones de fin de tramo (antes de SoftMax).
hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de los modelos Longformer de respuesta a preguntas.

clase transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput

< source >

Parámetros

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 output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de los modelos de clasificación de oraciones.

clase transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput

< source >

Parámetros

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, num_choices)) — num_choices es la segunda dimensión de los tensores de entrada. (ver input_ids anteriormente).
Puntuaciones de clasificación (antes de SoftMax).
hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de los modelos Longformer de selección múltiple.

clase transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput

< source >

Parámetros

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 output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.
Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor ((uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.
Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Clase base para las salidas de los modelos de clasificación de tokens.

LongformerModel

clase transformers.LongformerModel

< source >

( config: LongformerConfigadd_pooling_layer = True )

Parámetros

config (LongformerConfig) — 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.
add_pooling_layer (bool, opcional, valor predeterminado True) — Si se debe añadir una capa de pooling

El modelo Longformer 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

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerBaseModelOutputWithPooling or tuple(torch.Tensor)

Parámetros

input_ids (torch.Tensor 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
token_type_ids (torch.Tensor 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.Tensor 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.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerBaseModelOutputWithPooling o tuple(torch.Tensor)

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

El método forward de LongformerModel 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), procesado adicionalmente por 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 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 (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplos:

>>> import torch
>>> from transformers import LongformerModel, AutoTokenizer

>>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")

>>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000)  # long input document
>>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0)  # batch of size 1

>>> attention_mask = torch.ones(
...     input_ids.shape, dtype=torch.long, device=input_ids.device
... )  # initialize to local attention
>>> global_attention_mask = torch.zeros(
...     input_ids.shape, dtype=torch.long, device=input_ids.device
... )  # initialize to global attention to be deactivated for all tokens
>>> global_attention_mask[
...     :,
...     [
...         1,
...         4,
...         21,
...     ],
... ] = 1  # Set global attention to random tokens for the sake of this example
>>> # Usually, set global attention based on the task. For example,
>>> # classification: the <s> token
>>> # QA: question tokens
>>> # LM: potentially on the beginning of sentences and paragraphs
>>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask)
>>> sequence_output = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output

LongformerForMaskedLM

clase transformers.LongformerForMaskedLM

< source >

( config: LongformerConfig )

Parámetros

config (LongformerConfig) — 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 Longformer con una cabeza de language modeling en la parte superior.”

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerMaskedLMOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.Tensor 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
token_type_ids (torch.Tensor 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.Tensor 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].
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerMaskedLMOutput o tuple(torch.Tensor)

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

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

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo de relleno de máscara:

>>> from transformers import AutoTokenizer, LongformerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")

Probemos una entrada muy larga.

>>> TXT = (
...     "My friends are <mask> but they eat too many carbs."
...     + " That's why I decide not to eat with them." * 300
... )
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = model(input_ids).logits

>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)

>>> tokenizer.decode(predictions).split()
['healthy', 'skinny', 'thin', 'good', 'vegetarian']

LongformerForSequenceClassification

clase transformers.LongformerForSequenceClassification

< source >

( config: LongformerConfig )

Parámetros

config (LongformerConfig) — 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 transformer Longformer con una cabeza de clasificación/regresión de secuencias en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas GLUE.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerSequenceClassifierOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.Tensor 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
token_type_ids (torch.Tensor 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.Tensor 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).
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerSequenceClassifierOutput o tuple(torch.Tensor)

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

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

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo de clasificación de una sola etiqueta:

>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

Ejemplo de clasificación multietiqueta:

>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LongformerForSequenceClassification.from_pretrained(
...     "allenai/longformer-base-4096", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

LongformerForMultipleChoice

clase transformers.LongformerForMultipleChoice

< source >

( config: LongformerConfig )

Parámetros

config (LongformerConfig) — 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 Longformer con una cabeza de clasificación de opción múltiple en la parte superior (una capa lineal sobre la salida agrupada y un softmax), por ejemplo, para las tareas RocStories/SWAG.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerMultipleChoiceModelOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor de forma (batch_size, num_choices, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario.
Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?
token_type_ids (torch.LongTensor de forma (batch_size, num_choices, 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, num_choices, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación de opción múltiple. Los índices deben estar en [0, ..., num_choices-1], donde num_choices es el tamaño de la segunda dimensión de los tensores de entrada. (Véase input_ids arriba)
position_ids (torch.LongTensor de forma (batch_size, num_choices, 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.max_position_embeddings - 1].
¿Qué son los IDs de posición?
inputs_embeds (torch.Tensor de forma (batch_size, num_choices, 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.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerMultipleChoiceModelOutput o tuple(torch.Tensor)

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

El método forward de LongformerForMultipleChoice 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, devuelta cuando se proporciona labels) — Pérdida de clasificación.
logits (torch.Tensor de forma (batch_size, num_choices)) — num_choices es la segunda dimensión de los tensores de entrada. (ver input_ids arriba).

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 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 (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo:

>>> from transformers import AutoTokenizer, LongformerForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

LongformerForTokenClassification

clase transformers.LongformerForTokenClassification

< source >

( config: LongformerConfig )

Parámetros

config (LongformerConfig) — 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 transformer Longformer con una cabeza de clasificación de tokens en la parte superior (una capa lineal sobre la salida de los hidden-states), por ejemplo, para tareas de reconocimiento de entidades nombradas (NER).

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerTokenClassifierOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.Tensor 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
token_type_ids (torch.Tensor 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.Tensor 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].
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerTokenClassifierOutput o tuple(torch.Tensor)

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

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

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo:

>>> from transformers import AutoTokenizer, LongformerForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

LongformerForQuestionAnswering

clase transformers.LongformerForQuestionAnswering

< source >

( config: LongformerConfig )

Parámetros

config (LongformerConfig) — 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 transformer Longformer 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).

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LongformerQuestionAnsweringModelOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.Tensor 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?
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?
global_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para decidir la atención dada a cada token, atención local o atención global. Los tokens con atención global atienden a todos los demás tokens, y todos los demás tokens atienden a ellos. Esto es importante para el ajuste fino específico de tareas porque hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, el token debe recibir atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el artículo de Longformer para más detalles. Valores de la máscara seleccionados en [0, 1]:
- 0 para atención local (una atención de ventana deslizante),
- 1 para atención global (los tokens que atienden a todos los demás tokens, y todos los demás tokens atienden a ellos).
token_type_ids (torch.Tensor 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.Tensor 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.Tensor de forma (batch_size,), opcional) — Etiquetas para la posición (índice) del inicio del span 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.Tensor de forma (batch_size,), opcional) — Etiquetas para la posición (índice) del final del span 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.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

LongformerQuestionAnsweringModelOutput o tuple(torch.Tensor)

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

El método forward de LongformerForQuestionAnswering 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), opcional) — Puntuaciones de inicio de tramo (antes de SoftMax).
end_logits (torch.Tensor de forma (batch_size, sequence_length), opcional) — 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 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 (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x + attention_window + 1), donde x es el número de tokens con máscara de atención global.

Pesos de atención local después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token de la secuencia hacia cada token con atención global (los primeros x valores) y hacia cada token en la ventana de atención (los valores restantes `attention_window
- 1values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
global_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, num_heads, sequence_length, x), donde x es el número de tokens con máscara de atención global.

Pesos de atención global después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Son los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplos:

>>> from transformers import AutoTokenizer, LongformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> encoding = tokenizer(question, text, return_tensors="pt")
>>> input_ids = encoding["input_ids"]

>>> # default is local attention everywhere
>>> # the forward method will automatically set global attention on question tokens
>>> attention_mask = encoding["attention_mask"]

>>> outputs = model(input_ids, attention_mask=attention_mask)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist())

>>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1]
>>> answer = tokenizer.decode(
...     tokenizer.convert_tokens_to_ids(answer_tokens)
... )  # remove space prepending space token

Update on GitHub

←LongCatFlash LongT5→