Transformers documentation

LED

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 2021-01-05.

LED

Longformer-Encoder-Decoder (LED) es un modelo transformer de codificador-decodificador para tareas de secuencia a secuencia, como la resumición. Extiende a Longformer, un modelo solo de codificador diseñado para manejar entradas largas, añadiendo una capa de decodificador. El decodificador utiliza autoatención completa sobre los tokens codificados y las posiciones previamente decodificadas. Debido al mecanismo de autoatención lineal de Longformer, LED es más eficiente que los modelos estándar de codificador-decodificador al procesar secuencias largas.

Puedes encontrar todos los puntos de control originales de [LED] bajo la organización Ai2.

Este modelo fue aportado por patrickvonplaten.

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

El siguiente ejemplo demuestra cómo resumir texto con Pipeline, AutoModel y desde la línea de comandos.

AutoModel

La cuantización reduce la carga de memoria de los modelos grandes al representar los pesos con una precisión inferior. Consulte el resumen de Cuantización para conocer más backends de cuantización disponibles.

El ejemplo siguiente utiliza bitsandbytes para cuantizar únicamente los pesos a int4.

import torch

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig


quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "allenai/led-large-16384",
    device_map="auto",
    quantization_config=quantization_config
)

tokenizer = AutoTokenizer.from_pretrained(
    "allenai/led-large-16384"
)

input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)

# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1

output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))

Notas

LEDForConditionalGeneration es una extensión de BartForConditionalGeneration que sustituye la capa de autoatención tradicional por la capa de autoatención por bloques de Longformer. LEDTokenizer es un alias de BartTokenizer.
LED rellena input_ids hasta ser un múltiplo de config.attention_window si es necesario. Se obtiene una pequeña mejora de velocidad cuando LEDTokenizer se utiliza con el argumento pad_to_multiple_of.
LED funciona mejor en tareas de secuencia a secuencia de largo alcance donde los input_ids son significativamente más largos que 1024 tokens.
LED utiliza atención global mediante global_attention_mask (consulte LongformerModel). Para la resumición, se recomienda aplicar la atención global únicamente al primer token <s>. Para la respuesta a preguntas, se recomienda aplicar la atención global a todos los tokens de la pregunta.
Para ajustar LED en todos los 16384 parámetros, se puede habilitar el checkpointing de gradientes en caso de que el entrenamiento provoque errores de memoria insuficiente (OOM). Habilite el checkpointing de gradientes añadiendo model.gradient_checkpointing_enable() y estableciendo use_cache=False para desactivar el mecanismo de caché y ahorrar memoria.
Las entradas deben rellenarse a la derecha porque LED utiliza incrustaciones de posición absoluta.

Recursos

Lea el cuaderno de LED en Arxiv para ver cómo LED puede lograr un rendimiento de vanguardia en la resumición de artículos de Arxiv.
Lee el cuaderno Fine-tune LED para aprender a hacer fine-tuning de LED en artículos de PubMed.

LEDConfig

clase transformers.LEDConfig

< 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 50265max_encoder_position_embeddings: int = 16384max_decoder_position_embeddings: int = 1024encoder_layers: int = 12encoder_ffn_dim: int = 4096encoder_attention_heads: int = 16decoder_layers: int = 12decoder_ffn_dim: int = 4096decoder_attention_heads: int = 16encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0use_cache: bool = Trueactivation_function: str = 'gelu'd_model: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02decoder_start_token_id: int = 2classifier_dropout: float | int = 0.0pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2attention_window: list[int] | int = 512tie_word_embeddings: bool = True )

Parámetros

is_encoder_decoder (bool, opcional, valor predeterminado True) — Indica si el modelo se utiliza como codificador/decodificador o no.
vocab_size (int, opcional, valor predeterminado 50265) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
max_encoder_position_embeddings (int, opcional, valor predeterminado 16384) — La longitud máxima de secuencia con la que podría utilizarse el codificador.
max_decoder_position_embeddings (int, opcional, valor predeterminado 16384) — La longitud máxima de secuencia con la que podría usarse el decodificador.
encoder_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el codificador del Transformer. Usará el mismo valor que num_layers si no se establece.
encoder_ffn_dim (int, opcional, valor predeterminado 4096) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el codificador.
encoder_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el codificador Transformer.
decoder_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor que num_layers.
decoder_ffn_dim (int, opcional, valor predeterminado 4096) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el decodificador.
decoder_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.
encoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de LayerDrop para el codificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
decoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de LayerDrop para el decodificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
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.
activation_function (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.
d_model (int, opcional, valor predeterminado 1024) — Tamaño de las capas del codificador y de la capa pooler.
dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción para todas las capas de dropout.
attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
activation_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
init_std (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
decoder_start_token_id (int, opcional, valor predeterminado 2) — Si un modelo encoder-decoder inicia la decodificación con un token diferente de bos, el id de ese token.
classifier_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para el clasificador.
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.
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.
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 LEDModel. Se utiliza para instanciar un modelo Led 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/led-base-16384

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 LEDModel, LEDConfig

>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()

>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)

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

LEDTokenizer

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.

get_special_tokens_mask

< source >

( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

Parámetros

token_ids_0 — Lista de IDs de la secuencia (posiblemente ya formateada).
token_ids_1 — No se usa cuando already_has_special_tokens=True. Debe ser None en ese caso.
already_has_special_tokens — Indica si la secuencia ya está formateada con tokens especiales.

Devuelve

Una lista de enteros en el rango [0, 1]

1 para un token especial, 0 para un token de secuencia.

Obtener los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales.

Para los tokenizadores rápidos, los collators de datos llaman a esto con already_has_special_tokens=True para construir una máscara sobre una secuencia ya formateada. En ese caso, calculamos la máscara comprobando la pertenencia en all_special_ids.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

Salidas específicas de LED

clase transformers.models.led.modeling_led.LEDEncoderBaseModelOutput

< 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 LEDEncoder, con estados ocultos potenciales, atenciones locales y globales.

clase transformers.models.led.modeling_led.LEDSeq2SeqModelOutput

< source >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_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 decodificador del modelo.
Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).
past_key_values (Cache, opcional, se devuelve cuando use_cache=True se pasa o cuando config.use_cache=True) — Es una Cache instancia. Para más detalles, consulta nuestra guía de caché kv.
Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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, sequence_length).
Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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, sequence_length).
Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + uno para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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, sequence_length).
Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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 del codificador de un modelo que también contiene: estados ocultos precalculados que pueden acelerar la decodificación secuencial.

clase transformers.models.led.modeling_led.LEDSeq2SeqLMOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_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.
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).
past_key_values (Cache, opcional, se devuelve cuando use_cache=True se pasa o cuando config.use_cache=True) — Es una Cache instancia. Para más detalles, consulta nuestra guía de caché kv.
Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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, sequence_length).
Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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, sequence_length).
Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + uno para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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, sequence_length).
Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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 de secuencia a secuencia.

clase transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput

< source >

Parámetros

loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona label) — 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).
past_key_values (Cache, opcional, se devuelve cuando use_cache=True se pasa o cuando config.use_cache=True) — Es una Cache instancia. Para más detalles, consulta nuestra guía de caché kv.
Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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, sequence_length).
Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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, sequence_length).
Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + uno para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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, sequence_length).
Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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 clasificación de oraciones de secuencia a secuencia.

clase transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_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).
past_key_values (Cache, opcional, se devuelve cuando use_cache=True se pasa o cuando config.use_cache=True) — Es una Cache instancia. Para más detalles, consulta nuestra guía de caché kv.
Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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, sequence_length).
Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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, sequence_length).
Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + uno para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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, sequence_length).
Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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 respuesta a preguntas de secuencia a secuencia.

LEDModel

clase transformers.LEDModel

< source >

( config: LEDConfig )

Parámetros

config (LEDConfig) — 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 Led básico que emite estados ocultos sin ningún cabezal específico 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.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqModelOutput 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?
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?
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para obtener más detalles. ¿Qué son los IDs de entrada? LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).
Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?

LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (consulte past_key_values).
decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. La máscara causal también se usará de forma predeterminada. Si deseas cambiar el comportamiento de relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 del artículo para obtener más información sobre la estrategia predeterminada.
Si deseas cambiar el comportamiento del relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 de el artículo para obtener más información sobre la estrategia predeterminada.
encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
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 para el codificador. 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 tener 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).
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.
Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

El modelo generará el mismo formato de caché que se proporciona como entrada.

Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).
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.
decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo la última decoder_inputs_embeds debe ser introducida (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.
Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.
use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
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

LEDSeq2SeqModelOutput o tuple(torch.Tensor)

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

El método forward de LEDModel 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 decodificador del modelo.

Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).
past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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.

LEDForConditionalGeneration

clase transformers.LEDForConditionalGeneration

< source >

( config: LEDConfig )

Parámetros

config (LEDConfig) — 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 LED con una cabeza de modelado de lenguaje. Puede usarse para resumir.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqLMOutput 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?
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?
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para obtener más detalles. ¿Qué son los IDs de entrada? LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).
Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?

LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (consulte past_key_values).
decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. La máscara causal también se usará de forma predeterminada. Si deseas cambiar el comportamiento de relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 del artículo para obtener más información sobre la estrategia predeterminada.
Si deseas cambiar el comportamiento del relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 de el artículo para obtener más información sobre la estrategia predeterminada.
encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
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 para el codificador. 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 tener 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).
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.
Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

El modelo generará el mismo formato de caché que se proporciona como entrada.

Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).
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.
decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo la última decoder_inputs_embeds debe ser introducida (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.
Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.
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 [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
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

LEDSeq2SeqLMOutput o tuple(torch.Tensor)

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

El método forward de LEDForConditionalGeneration 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.
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).
past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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 resumen:

>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")

>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
...     results in a wide range of natural language tasks including generative language modeling
...     (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
...     This success is partly due to the self-attention component which enables the network to capture contextual
...     information from the entire sequence. While powerful, the memory and computational requirements of
...     self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
...     process long sequences. To address this limitation, we present Longformer, a modified Transformer
...     architecture with a self-attention operation that scales linearly with the sequence length, making it
...     versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
...     long document classification, question answering (QA), and coreference resolution, where existing approaches
...     partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
...     of BERT-style pretrained models. Such partitioning could potentially result in loss of important
...     cross-partition information, and to mitigate this problem, existing methods often rely on complex
...     architectures to address such interactions. On the other hand, our proposed Longformer is able to build
...     contextual representations of the entire context using multiple layers of attention, reducing the need for
...     task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")

>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1

>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))

Ejemplo de generación condicional:

>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]

>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))

LEDForQuestionAnswering

clase transformers.LEDForQuestionAnswering

< source >

( config: LEDConfig )

Parámetros

config (LEDConfig) — 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 transformador Led 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.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqQuestionAnsweringModelOutput 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?
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?
decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para obtener más detalles. ¿Qué son los IDs de entrada? LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).
Los índices se pueden obtener usando LedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?

LED utiliza eos_token_id como token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (consulte past_key_values).
decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. La máscara causal también se usará de forma predeterminada. Si deseas cambiar el comportamiento de relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 del artículo para obtener más información sobre la estrategia predeterminada.
Si deseas cambiar el comportamiento del relleno, debes leer modeling_led._prepare_decoder_inputs y modificarlo según tus necesidades. Consulta la figura 1 de el artículo para obtener más información sobre la estrategia predeterminada.
encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
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 para el codificador. 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 tener 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).
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.
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.
decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo la última decoder_inputs_embeds debe ser introducida (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.
Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.
use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
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

LEDSeq2SeqQuestionAnsweringModelOutput o tuple(torch.Tensor)

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

El método forward de LEDForQuestionAnswering 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).
past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
decoder_hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
encoder_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 codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
encoder_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, LEDForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...

Update on GitHub

←Laguna LFM2→