# LED

[Longformer-Encoder-Decoder (LED)](https://huggingface.co/papers/2004.05150)は、要約などのシーケンス間タスク向けのエンコーダー・デコーダー型transformerモデルです。これは、長い入力を処理するために設計されたエンコーダーのみを持つモデルである[Longformer](longformer)に、デコーダー層を追加したものです。デコーダーは、エンコードされたトークンと以前にデコードされた位置に対してフルセルフアテンションを使用します。Longformerの線形セルフアテンション機構のおかげで、LEDは長いシーケンスを処理する際に、標準的なエンコーダー・デコーダーモデルよりも効率的です。

すべてのオリジナルの [LED] チェックポイントは、[Ai2](https://huggingface.co/allenai/models?search=led) 組織の下で確認できます。

> [!TIP]
> このモデルは [patrickvonplaten](https://huggingface.co/patrickvonplaten) によって提供されました。
>
> 右側のサイドバーにあるLEDモデルをクリックすると、LEDを異なる言語タスクに適用する方法のさらなる例を確認できます。

以下の例では、[Pipeline](/docs/transformers/main/ja/main_classes/pipelines#transformers.Pipeline)、[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)、およびコマンドラインからテキストを要約する方法を示します。

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

Quantization は、重みを低精度で表現することで、大規模モデルのメモリ負荷を軽減します。利用可能な Quantization バックエンドの詳細については、[Quantization](../quantization/overview) の概要を参照してください。

以下の例では、[bitsandbytes](../quantization/bitsandbytes)を使用して、重みを 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))
```

## 注記

- [LEDForConditionalGeneration](/docs/transformers/main/ja/model_doc/led#transformers.LEDForConditionalGeneration) は [BartForConditionalGeneration](/docs/transformers/main/ja/model_doc/bart#transformers.BartForConditionalGeneration) の拡張であり、従来の自己アテンション層を Longformer のチャンク化された自己アテンション層に置き換えています。 [LEDTokenizer](/docs/transformers/main/ja/model_doc/led#transformers.RobertaTokenizer) は [BartTokenizer](/docs/transformers/main/ja/model_doc/led#transformers.RobertaTokenizer) の別名です。
- 必要に応じて、LED は `input_ids` を `config.attention_window` の倍数にパディングします。[LEDTokenizer](/docs/transformers/main/ja/model_doc/led#transformers.RobertaTokenizer) を `pad_to_multiple_of` 引数と組み合わせて使用すると、わずかな高速化が得られます。
- LEDは、`input_ids`が1024トークンをはるかに超える長いシーケンスのシーケンスツーシーケンスタスクで最も効果を発揮します。
- LED は `global_attention_mask` を用いてグローバルアテンションを実装しています（[LongformerModel](/docs/transformers/main/ja/model_doc/longformer#transformers.LongformerModel)を参照）。要約タスクでは、グローバルアテンションを最初の `<s>` トークンのみに設定することをお勧めします。質問応答タスクでは、質問のすべてのトークンにグローバルアテンションを設定することをお勧めします。
- LED の全 16384 パラメータをファインチューニングする場合、トレーニング中にメモリ不足 (OOM) エラーが発生する可能性があるため、`model.gradient_checkpointing_enable()` を追加して `use_cache=False` を設定し、メモリを節約するためにキャッシュ機構を無効化することで、勾配チェックポイントを有効にできます。
- LEDは絶対位置埋め込みを使用するため、入力には右パディングを適用する必要があります。

## リソース

- LEDがArxiv論文の要約において最先端の性能をどのように達成できるかを確認するには、[ArxivのLEDノートブック](https://colab.research.google.com/drive/12INTTR6n64TzS4RrXZxMSXfrOd9Xzamo?usp=sharing)をお読みください。
- LEDのファインチューニング方法とPubMed記事でのファインチューニングの手順を学ぶには、[Fine-tune LED notebook](https://colab.research.google.com/drive/12LjJazBl7Gam0XBPy_y0CTOJZeZ34c2v?usp=sharing)をお読みください。

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

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

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

vocab_size (`int`、*任意*、デフォルトは`50265`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

max_encoder_position_embeddings (`int`、*optional*、デフォルトは 16384) : エンコーダーが使用される可能性のある最大シーケンス長です。

max_decoder_position_embeddings (`int`、*optional*、デフォルトは 16384) : デコーダーが使用される可能性のある最大シーケンス長です。

encoder_layers (`int`、*任意*、デフォルトは`12`) : Transformerエンコーダーの隠れ層の数。設定されていない場合は、`num_layers`と同じ値が使用されます。

encoder_ffn_dim (`int`、*任意*、デフォルトは `4096`) : エンコーダー内の「intermediate」（feed-forward と呼ばれることが多い）層の次元数。

encoder_attention_heads (`int`、*任意*、デフォルトは`16`) : Transformerエンコーダーの各アテンション層におけるアテンションヘッドの数。

decoder_layers (`int`、*任意*、デフォルトは`12`) : Transformer デコーダーの隠れ層の数。設定されていない場合は、`num_layers` と同じ値が使用されます。

decoder_ffn_dim (`int`、*任意*、デフォルトは `4096`) : デコーダー内の「intermediate」（feed-forward と呼ばれることが多い）層の次元数。

decoder_attention_heads (`int`、*任意*、デフォルトは`16`) : Transformerデコーダーの各アテンション層におけるアテンションヘッドの数。

encoder_layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.0`) : エンコーダーのLayerDrop確率です。詳細については、[LayerDrop論文](see https://huggingface.co/papers/1909.11556)を参照してください。

decoder_layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.0`) : デコーダーの LayerDrop 確率です。詳細については、[LayerDrop の論文](see https://huggingface.co/papers/1909.11556)を参照してください。

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

activation_function (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。

d_model (`int`、*任意*、デフォルトは`1024`) : エンコーダ層とプーラー層のサイズ。

dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

activation_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 全結合層内の活性化に対する dropout 率。

init_std (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

decoder_start_token_id (`int`、*optional*、デフォルトは`2`) : エンコーダーデコーダーモデルが`bos`以外のトークンでデコーディングを開始する場合、そのトークンのID。

classifier_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : クラシファイア用の dropout 率。

pad_token_id (`int`, *任意*, デフォルトは `1`) : 語彙内でパディングに使用されるトークン ID。

bos_token_id (`int`, *optional*, デフォルトは `0`) : 語彙内でストリームの開始に使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`2`) : 語彙内でストリーム終了に使用されるトークン ID。

attention_window (`int` または `list[int]`、*任意*、デフォルト値は 512) : 各トークンの周囲の attention window のサイズです。`int` の場合、すべての層で同じサイズを使用します。層ごとに異なるウィンドウサイズを指定するには、`len(attention_window) == num_hidden_layers` を満たす `list[int]` を使用します。

tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。

これは LEDModel の設定を保存するための設定クラスです。指定された引数に基づいて Led モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[allenai/led-base-16384](https://huggingface.co/allenai/led-base-16384) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

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

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

**パラメータ:**

vocab (`str`、`dict`または`list`、*省略可*) : カスタムの語彙辞書。指定しない場合、vocab_fileから語彙が読み込まれます。

merges (`str` または `list`、*省略可*) : カスタムなマージリスト。指定しない場合、マージは merges_file から読み込まれます。

errors (`str`、*任意*、デフォルトは`"replace"`) : バイトを UTF-8 にデコードする際に従うパラダイム。詳細は[bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)を参照してください。

bos_token (`str`、*任意*、デフォルトは `"<s>"`) : 事前学習で使用されたシーケンスの開始トークンです。シーケンス分類器のトークンとして使用できます。    特殊トークンを使用してシーケンスを構築する場合は、シーケンスの開始にこのトークンは使用されません。使用されるのは `cls_token` です。

eos_token (`str`、*任意*、デフォルトは`"</s>"`) : シーケンスの終了トークン。特殊トークンを使用してシーケンスを構築する場合は、シーケンスの終了に使用されるトークンではありません。使用されるトークンは`sep_token`です。

sep_token (`str`、*任意*、デフォルトは `"</s>"`) : 区切りトークンです。複数のシーケンスからシーケンスを構築する際に使用されます。例えば、シーケンス分類では2つのシーケンス、質問応答ではテキストと質問です。また、特殊トークンを用いて構築されたシーケンスの最後のトークンとしても使用されます。

cls_token (`str`、*任意*、デフォルトは `"<s>"`) : シーケンス分類（トークンごとの分類ではなく、シーケンス全体に対する分類）を行う際に使用される分類トークンです。特殊トークンを用いて構築された場合、シーケンスの最初のトークンになります。

unk_token (`str`、*任意*、デフォルトは `"<unk>"`) : 不明トークン。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。

pad_token (`str`、*任意*、デフォルトは `"<pad>"`) : パディングに使用されるトークンです。長さの異なるシーケンスをバッチ処理する場合などに使用します。

mask_token (`str`、*任意*、デフォルトは `"<mask>"`) : 値をマスクするために使用されるトークンです。これは、マスク言語モデリングでこのモデルを訓練する際に使用されるトークンです。モデルが予測しようとするトークンです。

add_prefix_space (`bool`、*任意*、デフォルトは`False`) : 入力に先頭スペースを追加するかどうか。これにより、先頭の単語を他の単語と同様に扱うことができます。(RoBERTa トークナイザーは、先行するスペースによって単語の先頭を検出します)。

trim_offsets (`bool`、*任意*、デフォルトは `True`) : 後処理ステップでオフセットをトリムし、空白文字が含まれないようにするかどうかを指定します。

HuggingFaceのtokenizersライブラリをバックエンドに持つRoBERTaのトークナイザーを構築します。Byte-Pair-Encodingに基づいています。

このトークナイザーは、スペースをトークンの一部として扱うように学習されています（sentencepieceに少し似ています）。そのため、単語は

文の先頭（スペースなし）にある場合と、そうでない場合とで、エンコードの仕方が異なります。

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

この動作を回避するには、このトークナイザーをインスタンス化する際、またはテキストに対して呼び出す際に`add_prefix_space=True`を渡すことができます。ただし、モデルはこの方式で事前学習されていないため、パフォーマンスが低下する可能性があります。

`is_split_into_words=True` と併用する場合、このトークナイザーは `add_prefix_space=True` を指定してインスタンス化する必要があります。

このトークナイザーは、[TokenizersBackend](/docs/transformers/main/ja/main_classes/tokenizer#transformers.TokenizersBackend) を継承しており、主要なメソッドの大部分がそこに含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

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

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

**パラメータ:**

token_ids_0 : (すでにフォーマット済みの可能性がある) シーケンスの ID のリスト。

token_ids_1 `already_has_special_tokens=True` の場合は使用されません。その場合は None でなければなりません。

already_has_special_tokens : シーケンスがすでに特殊トークンでフォーマットされているかどうか。

**戻り値:** 範囲 [0, 1] 内の整数のリスト

特殊トークンには1、シーケンストークンには0を指定します。

特殊トークンが追加されていないトークンリストからシーケンスIDを取得します。

高速なトークナイザーでは、データコラテーターは`already_has_special_tokens=True`を指定してこの関数を呼び出し、すでに整形済みのシーケンスに対してマスクを構築します。その場合、`all_special_ids`への所属を確認することによってマスクを計算します。

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

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

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

## 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: FloatTensor, hidden_states: tuple[torch.FloatTensor, ...] | None = None, attentions: tuple[torch.FloatTensor, ...] | None = None, global_attentions: tuple[torch.FloatTensor, ...] | None = None)
```

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

**パラメータ:**

last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における hidden-states のシーケンス。

hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ、各層の出力用 1 つずつ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` です。ここで `x` は、グローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のローカルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内のすべてのトークンから、グローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window + 1` 個の値）へのアテンション重みです。最初の `x` 個の値はテキスト内の固定位置のトークンを指しますが、残りの `attention_window + 1` 個の値は相対位置のトークンを指します。あるトークンが自分自身へのアテンション重みはインデックス `x + attention_window / 2` に位置し、その前後の `attention_window / 2` 個の値は、それぞれ前後の `attention_window / 2` 個のトークンへのアテンション重みです。アテンションウィンドウ内にグローバルアテンションを持つトークンがある場合、対応するインデックスのアテンション重みは 0 に設定されます。その値は、最初の `x` 個のアテンション重みからアクセスする必要があります。あるトークンがグローバルアテンションを持つ場合、`attentions` 内の他のすべてのトークンへのアテンション重みは 0 に設定され、値は `global_attentions` からアクセスする必要があります。

global_attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のグローバルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、グローバルアテンションを持つすべてのトークンからシーケンス内のすべてのトークンへのアテンション重みです。

LEDEncoderの出力の基底クラスです。潜在的な隠れ状態、ローカルアテンション、グローバルアテンションを含む可能性があります。

#### 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.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None, decoder_attentions: tuple[torch.FloatTensor, ...] | None = None, cross_attentions: tuple[torch.FloatTensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None, encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None, encoder_attentions: tuple[torch.FloatTensor, ...] | None = None, encoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None)
```

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

**パラメータ:**

last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルのデコーダーの最終層の出力における hidden-states のシーケンスです。 `past_key_values` を使用する場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持しており、シーケンシャルデコーディングを高速化するために使用できます（`past_key_values` 入力参照）。

decoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 適用後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンション層のアテンション重みです。

encoder_last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダーの最終層の出力における、hidden-states のシーケンス。

encoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル(モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ)で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.FloatTensor, ...]`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のものであり、セルフアテンションヘッドにおける加重平均の計算に使用されます。

encoder_global_attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のグローバルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、グローバルアテンションを持つすべてのトークンからシーケンス内のすべてのトークンへのアテンション重みです。

モデルエンコーダーの出力の基底クラスであり、シーケンシャルデコーディングを高速化できる事前計算済みヒドゥンステートも含まれます。

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

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

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

**パラメータ:**

loss (`torch.FloatTensor`、shape `(1,)`、*任意*、`labels` が指定された場合のみ返されます) : 言語モデリングの損失。

logits (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持しており、シーケンシャルデコーディングを高速化するために使用できます（`past_key_values` 入力参照）。

decoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル(モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ)で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 適用後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンション層のアテンション重みです。

encoder_last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダーの最終層の出力における、hidden-states のシーケンス。

encoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のものであり、セルフアテンションヘッドにおける加重平均の計算に使用されます。

encoder_global_attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のグローバルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、グローバルアテンションを持つすべてのトークンからシーケンス内のすべてのトークンへのアテンション重みです。

シーケンスツーシーケンス言語モデルの出力の基底クラス。

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

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

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

**パラメータ:**

loss (`torch.FloatTensor`、shape `(1,)`、*optional*、`label` が指定された場合に返されます) : 分類（config.num_labels==1 の場合は回帰）の損失。

logits (`torch.FloatTensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持しており、シーケンシャルデコーディングを高速化するために使用できます（`past_key_values` 入力参照）。

decoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 適用後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンション層のアテンション重みです。

encoder_last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダーの最終層の出力における、hidden-states のシーケンス。

encoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル(モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ)で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.FloatTensor, ...]`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のものであり、セルフアテンションヘッドにおける加重平均の計算に使用されます。

encoder_global_attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のグローバルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、グローバルアテンションを持つすべてのトークンからシーケンス内のすべてのトークンへのアテンション重みです。

シーケンスツーシーケンス文分類モデルの出力の基底クラス。

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

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

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

**パラメータ:**

loss (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) : 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。

start_logits (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : Span開始スコア（SoftMax適用前）。

end_logits (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : Span-end スコア（SoftMax 適用前）。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持しており、シーケンシャルデコーディングを高速化するために使用できます（`past_key_values` 入力参照）。

decoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 適用後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンション層のアテンション重みです。

encoder_last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダーの最終層の出力における、hidden-states のシーケンス。

encoder_hidden_states (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル(モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ)で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.FloatTensor, ...]`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のものであり、セルフアテンションヘッドにおける加重平均の計算に使用されます。

encoder_global_attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。アテンションの softmax 後のグローバルアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。これらは、グローバルアテンションを持つすべてのトークンからシーケンス内のすべてのトークンへのアテンション重みです。

シーケンスツーシーケンスの質問応答モデルの出力の基底クラス。

## LEDModel[[transformers.LEDModel]]

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

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

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

**パラメータ:**

config ([LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを使用してください。

特定のヘッドを付加せず、生のhidden-statesを出力する素のLed Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### 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.FloatTensor]] | None = None, global_attention_mask: typing.Optional[torch.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックスです。インデックスは `LedTokenizer` を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力IDとは何ですか？](../glossary#input-ids) LED は、`decoder_input_ids` の生成の開始トークンとして `eos_token_id` を使用します。`past_key_values` を使用する場合は、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。

decoder_attention_mask (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内の pad トークンを無視するテンソルを生成します。デフォルトでは、causal mask も使用されます。パディングの動作を変更する場合は、`modeling_led._prepare_decoder_inputs` を読み、必要に応じて修正してください。デフォルトの戦略に関する詳細は、[論文](https://huggingface.co/papers/1910.13461)の図 1 を参照してください。

encoder_outputs (`tuple[tuple[torch.FloatTensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*) デコーダーのクロスアテンションで使用されます。

global_attention_mask (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : エンコーダーにおける各トークンへのアテンションの決定、すなわちローカルアテンションまたはグローバルアテンションを指定するためのマスクです。グローバルアテンションを持つトークンは他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けます。これはタスク固有のファインチューニングにおいて重要であり、モデルがタスクを表現する際に柔軟性を持たせるためです。例えば、分類タスクでは  トークンにグローバルアテンションを与えるべきです。QAタスクでは、すべての質問トークンにもグローバルアテンションを与える必要があります。詳細については、[Longformer論文](https://huggingface.co/papers/2004.05150)を参照してください。`[0, 1]`から選択されるマスクの値:  - 0: ローカルアテンション（スライディングウィンドウアテンション） - 1: グローバルアテンション（他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けるトークン）

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

decoder_inputs_embeds (`torch.FloatTensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すれば十分です（`past_key_values` を参照）。モデル内部の埋め込みルックアップ行列よりも、`decoder_input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を採ります。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [LEDSeq2SeqModelOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput) または `tuple(torch.FloatTensor)`

[LEDSeq2SeqModelOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)）や入力に応じて、さまざまな要素で構成されます。

[LEDModel](/docs/transformers/main/ja/model_doc/led#transformers.LEDModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルのデコーダーの最終層の出力における、隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **decoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- モデルのエンコーダーの最終層の出力における、隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合は埋め込みの出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_global_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, x)` です。ここで `x` は、グローバルアテンションマスクを持つトークンの数です。

  アテンションのsoftmax適用後のグローバルアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。これは、グローバルアテンションを持つ各トークンからシーケンス内の全トークンへのアテンション重みです。

## LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]]

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

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

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

**パラメータ:**

config ([LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを使用してください。

言語モデリングヘッドを備えたLEDモデル。要約に使用できます。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### 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.FloatTensor]] | None = None, global_attention_mask: typing.Optional[torch.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = 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)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックスです。インデックスは `LedTokenizer` を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力IDとは何ですか？](../glossary#input-ids) LED は、`decoder_input_ids` の生成の開始トークンとして `eos_token_id` を使用します。`past_key_values` を使用する場合は、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。

decoder_attention_mask (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内の pad トークンを無視するテンソルを生成します。デフォルトでは、causal mask も使用されます。パディングの動作を変更する場合は、`modeling_led._prepare_decoder_inputs` を読み、必要に応じて修正してください。デフォルトの戦略に関する詳細は、[論文](https://huggingface.co/papers/1910.13461)の図 1 を参照してください。

encoder_outputs (`tuple[tuple[torch.FloatTensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*) デコーダーのクロスアテンションで使用されます。

global_attention_mask (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : エンコーダーにおける各トークンへのアテンションの決定、すなわちローカルアテンションまたはグローバルアテンションを指定するためのマスクです。グローバルアテンションを持つトークンは他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けます。これはタスク固有のファインチューニングにおいて重要であり、モデルがタスクを表現する際に柔軟性を持たせるためです。例えば、分類タスクでは、CLS トークンにグローバルアテンションを与えるべきです。QAタスクでは、すべての質問トークンにもグローバルアテンションを与えるべきです。詳細については、[Longformer の論文](https://huggingface.co/papers/2004.05150)を参照してください。`[0, 1]` から選択されるマスクの値: - 0: ローカルアテンション（スライディングウィンドウアテンション） - 1: グローバルアテンション（他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けるトークン）

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

decoder_inputs_embeds (`torch.FloatTensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すれば十分です（`past_key_values` を参照）。モデル内部の埋め込みルックアップ行列よりも、`decoder_input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を採ります。

labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [LEDSeq2SeqLMOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput) または `tuple(torch.FloatTensor)`

[LEDSeq2SeqLMOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)）や入力に応じて、さまざまな要素で構成されます。

[LEDForConditionalGeneration](/docs/transformers/main/ja/model_doc/led#transformers.LEDForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **decoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- モデルのエンコーダーの最終層の出力における、隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合は埋め込みの出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_global_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンションのsoftmax適用後のグローバルアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。これは、グローバルアテンションを持つ各トークンからシーケンス内の全トークンへのアテンション重みです。

要約の例:

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

例: 条件付き生成:

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

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

**パラメータ:**

config ([LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを使用してください。

SQuADのような抽出型質問応答タスク用に、隠れ状態の出力の上に線形層を配置して`span start logits`と`span end logits`を計算するスパン分類ヘッドを備えたLed Transformer。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### 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.FloatTensor]] | None = None, global_attention_mask: typing.Optional[torch.FloatTensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックスです。インデックスは `LedTokenizer` を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力IDとは何ですか？](../glossary#input-ids) LED は、`decoder_input_ids` の生成の開始トークンとして `eos_token_id` を使用します。`past_key_values` を使用する場合は、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。

decoder_attention_mask (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内の pad トークンを無視するテンソルを生成します。デフォルトでは、causal mask も使用されます。パディングの動作を変更する場合は、`modeling_led._prepare_decoder_inputs` を読み、必要に応じて修正してください。デフォルトの戦略に関する詳細は、[論文](https://huggingface.co/papers/1910.13461)の図 1 を参照してください。

encoder_outputs (`tuple[tuple[torch.FloatTensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*) デコーダーのクロスアテンションで使用されます。

global_attention_mask (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : エンコーダーにおける各トークンへのアテンションの決定、すなわちローカルアテンションまたはグローバルアテンションを指定するためのマスクです。グローバルアテンションを持つトークンは他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けます。これはタスク固有のファインチューニングにおいて重要であり、モデルがタスクを表現する際に柔軟性を持たせるためです。例えば、分類タスクでは  トークンにグローバルアテンションを与えるべきです。QAタスクでは、すべての質問トークンにもグローバルアテンションを与える必要があります。詳細については、[Longformer論文](https://huggingface.co/papers/2004.05150)を参照してください。`[0, 1]`から選択されるマスクの値:  - 0: ローカルアテンション（スライディングウィンドウアテンション） - 1: グローバルアテンション（他のすべてのトークンにアテンションを向け、他のすべてのトークンもそのトークンにアテンションを向けるトークン）

start_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの開始位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。

end_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの終了位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

decoder_inputs_embeds (`torch.FloatTensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すれば十分です（`past_key_values` を参照）。モデル内部の埋め込みルックアップ行列よりも、`decoder_input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を採ります。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput) または `tuple(torch.FloatTensor)`

[LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/ja/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[LEDConfig](/docs/transformers/main/ja/model_doc/led#transformers.LEDConfig)）や入力に応じて、さまざまな要素で構成されます。

[LEDForQuestionAnswering](/docs/transformers/main/ja/model_doc/led#transformers.LEDForQuestionAnswering)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。
- **start_logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) -- SoftMax 適用前のスパン開始スコア。
- **end_logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) -- スパンの終了スコア（SoftMax 適用前）。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  デコーダーの事前計算済み hidden-states（attention ブロックの key と value）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **decoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- モデルのエンコーダーの最終層の出力における、隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合は埋め込みの出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple[torch.FloatTensor, ...]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_global_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, x)` です。ここで `x` は、グローバルアテンションマスクを持つトークンの数です。

  アテンションのsoftmax適用後のグローバルアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。これは、グローバルアテンションを持つ各トークンからシーケンス内の全トークンへのアテンション重みです。

例:

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