# LED

[Longformer-Encoder-Decoder (LED)](https://huggingface.co/papers/2004.05150) es un modelo transformer de codificador-decodificador para tareas de secuencia a secuencia, como la resumición. Extiende a [Longformer](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. Gracias al mecanismo de autoatención lineal de Longformer, LED es más eficiente que los modelos de codificador-decodificador estándar al procesar secuencias largas.

Puedes encontrar todos los puntos de control originales de [LED] bajo la organización [Ai2](https://huggingface.co/allenai/models?search=led).

> [!TIP]
> Este modelo fue aportado por [patrickvonplaten](https://huggingface.co/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](/docs/transformers/main/es/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/es/model_doc/auto#transformers.AutoModel) y desde la línea de comandos.

```python
import torch

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "allenai/led-base-16384"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "allenai/led-base-16384",
    device_map="auto"
)

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

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](../quantization/overview) para conocer más backends de cuantización disponibles.

El ejemplo siguiente utiliza [bitsandbytes](../quantization/bitsandbytes) para cuantizar únicamente los pesos a int4.

```python
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](/docs/transformers/main/es/model_doc/led#transformers.LEDForConditionalGeneration) es una extensión de [BartForConditionalGeneration](/docs/transformers/main/es/model_doc/bart#transformers.BartForConditionalGeneration) que sustituye la capa de autoatención tradicional por la capa de autoatención por bloques de Longformer. [LEDTokenizer](/docs/transformers/main/es/model_doc/led#transformers.RobertaTokenizer) es un alias de [BartTokenizer](/docs/transformers/main/es/model_doc/led#transformers.RobertaTokenizer).
- 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](/docs/transformers/main/es/model_doc/led#transformers.RobertaTokenizer) 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](/docs/transformers/main/es/model_doc/longformer#transformers.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](https://colab.research.google.com/drive/12INTTR6n64TzS4RrXZxMSXfrOd9Xzamo?usp=sharing) 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](https://colab.research.google.com/drive/12LjJazBl7Gam0XBPy_y0CTOJZeZ34c2v?usp=sharing) para aprender a hacer fine-tuning de LED en artículos de PubMed.

## LEDConfig[[transformers.LEDConfig]]

#### transformers.LEDConfig[[transformers.LEDConfig]]

```python
transformers.LEDConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 50265, max_encoder_position_embeddings: int = 16384, max_decoder_position_embeddings: int = 1024, encoder_layers: int = 12, encoder_ffn_dim: int = 4096, encoder_attention_heads: int = 16, decoder_layers: int = 12, decoder_ffn_dim: int = 4096, decoder_attention_heads: int = 16, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, decoder_start_token_id: int = 2, classifier_dropout: float | int = 0.0, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, attention_window: list[int] | int = 512, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/configuration_led.py#L24)

**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 utilizarse el decodificador.

encoder_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el codificador 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 Transformer. Usará el mismo valor que `num_layers` si no se establece.

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](see https://huggingface.co/papers/1909.11556) para obtener 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](see https://huggingface.co/papers/1909.11556) para obtener más detalles.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en 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 de truncated_normal_initializer para inicializar todas las matrices de pesos.

decoder_start_token_id (`int`, *opcional*, valor predeterminado `2`) : Si un modelo encoder-decoder comienza a decodificar 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 de token utilizado para el relleno en el vocabulario.

bos_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de 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 la 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`) : Indica si se deben vincular las incrustaciones de pesos 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](https://huggingface.co/allenai/led-base-16384)

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

Ejemplo:

```python
>>> from transformers import 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[[transformers.RobertaTokenizer]]

#### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]]

```python
transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: 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 = False, trim_offsets: bool = True, **kwargs)
```

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

**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](https://docs.python.org/3/library/stdtypes.html#bytes.decode) para obtener más información.

bos_token (`str`, *opcional*, valor predeterminado `"<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`.

eos_token (`str`, *opcional*, valor predeterminado `"</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 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 igual que 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`) : Indica si el paso de posprocesamiento 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:

```python
>>> 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 esta 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](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### get_special_tokens_mask[[transformers.RobertaTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1338)

**Parámetros:**

token_ids_0 : Lista de IDs de la secuencia (posiblemente ya formateada).

token_ids_1 : No se utiliza cuando `already_has_special_tokens=True`. En ese caso, debe ser None.

already_has_special_tokens : 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 esta función 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 a `all_special_ids`.

#### save_vocabulary[[transformers.RobertaTokenizer.save_vocabulary]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546)

## Salidas específicas de LED[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]]

#### transformers.models.led.modeling_led.LEDEncoderBaseModelOutput[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]]

```python
transformers.models.led.modeling_led.LEDEncoderBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1063)

**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 se pasa `output_hidden_states=True` 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 de embedding iniciales opcionales.

attentions (`tuple(torch.Tensor)`, *opcional*, devuelto 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. Estos 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 `attention_window + 1` valores restantes). Tenga en cuenta que los primeros `x` valores se refieren a tokens con posiciones fijas en el texto, pero los `attention_window + 1` valores restantes se refieren a tokens con posiciones relativas: el peso de atención de un token hacia sí mismo se encuentra en el índice `x + attention_window / 2` y los `attention_window / 2` valores precedentes (sucesivos) son los pesos de atención hacia los `attention_window / 2` tokens precedentes (sucesivos). Si la ventana de atención contiene un token con atención global, el peso de atención en el índice correspondiente se establece en 0; el valor debe accederse desde los primeros `x` pesos de atención. Si un token tiene atención global, los pesos de atención hacia todos los demás tokens en `attentions` se establecen en 0, los valores deben accederse desde `global_attentions`.

global_attentions (`tuple(torch.Tensor)`, *opcional*, devuelto 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. Estos 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.

#### transformers.models.led.modeling_led.LEDSeq2SeqModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqModelOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1102)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de hidden-states en la salida de la última capa del decodificador del modelo. Si se usa `past_key_values`, solo se devuelve el último hidden-state de las secuencias, de 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene los hidden-states precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (consulte 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` (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 los embeddings iniciales.

decoder_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, 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` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de cross-attention del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

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` (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 codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_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, 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*, devuelto 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. Estos 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.

#### transformers.models.led.modeling_led.LEDSeq2SeqLMOutput[[transformers.models.led.modeling_led.LEDSeq2SeqLMOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1140)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto 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 del 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene los hidden-states precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (consulte 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` (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 los embeddings iniciales.

decoder_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, 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` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de cross-attention del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

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` (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 codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_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, 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*, devuelto 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. Estos 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.

#### transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput[[transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1178)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto 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 se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene los hidden-states precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (consulte 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` (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 los embeddings iniciales.

decoder_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, 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` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de cross-attention del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

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` (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 codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_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, 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*, devuelto 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. Estos 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.

#### transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1216)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene los hidden-states precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (consulte 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` (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 los embeddings iniciales.

decoder_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, 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` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de cross-attention del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de cross-attention.

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` (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 codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_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, 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*, devuelto 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. Estos 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[[transformers.LEDModel]]

#### transformers.LEDModel[[transformers.LEDModel]]

```python
transformers.LEDModel(config: LEDConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1719)

**Parámetros:**

config ([LEDConfig](/docs/transformers/main/es/model_doc/led#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LEDModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1745)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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 mediante `LedTokenizer`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) 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`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `modeling_led._prepare_decoder_inputs` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) 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 estados ocultos 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 la tarea, ya que hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, al token  se le debe dar atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el [artículo de Longformer](https://huggingface.co/papers/2004.05150) para obtener 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 (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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en 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 valores clave `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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LEDSeq2SeqModelOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput) o `tuple(torch.Tensor)`

Un [LEDSeq2SeqModelOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.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](/docs/transformers/main/es/model_doc/led#transformers.LEDConfig)) y las entradas.

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

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (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` (una 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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Se trata de los pesos de atención de cada token con atención global hacia cada token de la secuencia.

## LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]]

#### transformers.LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]]

```python
transformers.LEDForConditionalGeneration(config: LEDConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1861)

**Parámetros:**

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

El modelo LED con una cabeza de modelado de lenguaje. Puede usarse para resumir.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LEDForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1893)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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 mediante `LedTokenizer`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) 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`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `modeling_led._prepare_decoder_inputs` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) 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 estados ocultos 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 la tarea, ya que hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, al token  se le debe dar atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el [artículo de Longformer](https://huggingface.co/papers/2004.05150) para obtener 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 (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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en 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 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); 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 valores clave `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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LEDSeq2SeqLMOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput) o `tuple(torch.Tensor)`

Un [LEDSeq2SeqLMOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.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](/docs/transformers/main/es/model_doc/led#transformers.LEDConfig)) y las entradas.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (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` (una 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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Se trata de los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo de resumen:

```python
>>> 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:

```python
>>> 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[[transformers.LEDForQuestionAnswering]]

#### transformers.LEDForQuestionAnswering[[transformers.LEDForQuestionAnswering]]

```python
transformers.LEDForQuestionAnswering(config: LEDConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L2047)

**Parámetros:**

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

El Led transformer con una cabeza de clasificación de tramos en la parte superior para tareas de respuesta a preguntas extractivas como SQuAD (una capa lineal sobre la salida de los estados ocultos para calcular `span start logits` y `span end logits`).

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.LEDForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L2060)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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 mediante `LedTokenizer`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) 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`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `modeling_led._prepare_decoder_inputs` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) 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 estados ocultos 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 la tarea, ya que hace que el modelo sea más flexible a la hora de representar la tarea. Por ejemplo, para la clasificación, al token  se le debe dar atención global. Para QA, todos los tokens de la pregunta también deben tener atención global. Consulte el [artículo de Longformer](https://huggingface.co/papers/2004.05150) para obtener 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 (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`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en 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 valores clave `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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput) o `tuple(torch.Tensor)`

Un [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/es/model_doc/led#transformers.models.led.modeling_led.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](/docs/transformers/main/es/model_doc/led#transformers.LEDConfig)) y las entradas.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.
- **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`, *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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) del decodificador que se pueden utilizar (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` (una 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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Se trata de los pesos de atención de cada token con atención global hacia cada token de la secuencia.

Ejemplo:

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