# Longformer

[Longformer](https://huggingface.co/papers/2004.05150)は、長文書の処理用に設計されたtransformerモデルです。自己注意（self-attention）操作は通常、シーケンス長に対して二次的にスケールするため、transformerがより長いシーケンスを処理することを妨げていました。Longformerの注意機構は、シーケンス長に対して線形的にスケールすることでこの問題を克服します。ローカルなウィンドウ付き注意とタスク固有のグローバル注意を組み合わせることで、数千トークンに及ぶ文書の効率的な処理を可能にしています。

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

> [!TIP]
> Longformer をさまざまな言語タスクに適用する方法の例については、右側のサイドバーにある Longformer モデルをクリックしてください。

以下の例では、[Pipeline](/docs/transformers/main/ja/main_classes/pipelines#transformers.Pipeline)、[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)、およびコマンドラインから`<mask>`トークンを埋める方法を示しています。

```python
from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="allenai/longformer-base-4096",
    device=0
)
pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the <mask> with a torn ligament in his left knee.
Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit.
Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""")
```

```python
from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
model = AutoModelForMaskedLM.from_pretrained("allenai/longformer-base-4096", device_map="auto")

text = (
"""
San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the <mask> with a torn ligament in his left knee.
Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit.
Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.
"""
)

input_ids = tokenizer([text], return_tensors="pt").to(model.device)["input_ids"]
logits = model(input_ids).logits

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

## 注記

- Longformer は [RoBERTa](./roberta) をベースにしており、`token_type_ids` はありません。どのトークンがどのセグメントに属するかを指定する必要はありません。セグメントを区切りトークン `</s>` または `tokenizer.sep_token` で区切るだけで構いません。
- 推論時において、`global_attention_mask` を設定することで、どのトークンがローカルにアテンションを行い、どのトークンがグローバルにアテンションを行うかを指定できます（詳細はこの[例](/docs/transformers/main/ja/model_doc/longformer#transformers.LongformerModel.forward.example)を参照してください）。値が`0`の場合はトークンがローカルにアテンションを行い、値が`1`の場合はトークンがグローバルにアテンションを行います。
- [LongformerForMaskedLM](/docs/transformers/main/ja/model_doc/longformer#transformers.LongformerForMaskedLM) は [RobertaForMaskedLM](/docs/transformers/main/ja/model_doc/roberta#transformers.RobertaForMaskedLM) と同様に学習され、以下に示すように使用します。

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

## LongformerConfig[[transformers.LongformerConfig]]

#### transformers.LongformerConfig[[transformers.LongformerConfig]]

```python
transformers.LongformerConfig(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, is_encoder_decoder: bool = False, 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, attention_window: list[int] | int = 512, sep_token_id: int | None = 2, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, onnx_export: bool = False, tie_word_embeddings: bool = True)
```

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

**パラメータ:**

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

sep_token_id (`int`、*optional*、デフォルトは `2`) : 語彙内で区切り文字として使用されるトークン ID。

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

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

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

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

hidden_size (`int`、*任意*、デフォルトは`768`) : 隠れ表現の次元数。

num_hidden_layers (`int`, *任意*, デフォルトは `12`) : Transformer デコーダーの隠れ層の数。

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

intermediate_size (`int`、*任意*、デフォルトは `3072`) : MLP 表現の次元数。

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

hidden_dropout_prob (`Union[float, int]`、*任意*、デフォルト値は`0.1`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。

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

max_position_embeddings (`int`、*任意*、デフォルトは`512`) : このモデルが使用される可能性のある最大シーケンス長。

type_vocab_size (`int`、*任意*、デフォルトは`2`) : `token_type_ids`の語彙サイズ。

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

layer_norm_eps (`float`、*任意*、デフォルトは `1e-12`) : layer normalization レイヤーで使用する epsilon。

onnx_export (`bool`、*任意*、デフォルトは False) : モデルを ONNX エクスポート可能にするかどうかを指定します。

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

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

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

例:

```python
>>> from transformers import LongformerConfig, LongformerModel

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

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

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

## LongformerTokenizer[[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) を継承しており、主要なメソッドの大部分がそこに含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

## Longformer固有の出力[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]]

#### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L41)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

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

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

Longformer の出力の基底クラスです。潜在的な隠れ状態、ローカルアテンション、グローバルアテンションを含みます。

#### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling]]

```python
transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling(last_hidden_state: Tensor, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L79)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

pooler_output (`torch.Tensor`、形状 `(batch_size, hidden_size)`) : シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態を、Linear層とTanh活性化関数でさらに処理したものです。Linear層の重みは、事前学習中の次の文予測（分類）目的から学習されます。

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

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

Longformer の出力の基底クラスであり、最後の隠れ状態のプーリングも含まれます。

#### transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput[[transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L122)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : マスクド言語モデリング (MLM) の損失。

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

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

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

マスク付き言語モデルの出力の基底クラス。

#### transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput[[transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L165)

**パラメータ:**

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

start_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : スパン開始スコア（SoftMax 適用前）。

end_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : Span-end スコア (SoftMax 適用前)。

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

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

Longformerモデルの質問応答の出力の基底クラス。

#### transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L207)

**パラメータ:**

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

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

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

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

文分類モデルの出力の基底クラス。

#### transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput[[transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L250)

**パラメータ:**

loss (`torch.Tensor`、形状 *(1,)*、*任意*、`labels` が指定された場合に返されます) : 分類損失。

logits (`torch.Tensor`、shape `(batch_size, num_choices)`) : *num_choices*は入力テンソルの2番目の次元です（上記の*input_ids*を参照）。SoftMax適用前の分類スコア。

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

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

複数選択 Longformer モデルの出力の基底クラス。

#### transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput]]

```python
transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L295)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 分類損失。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.num_labels)`) : SoftMax 適用前の分類スコア。

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

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

トークン分類モデルの出力の基底クラス。

## LongformerModel[[transformers.LongformerModel]]

#### transformers.LongformerModel[[transformers.LongformerModel]]

```python
transformers.LongformerModel(config: LongformerConfig, add_pooling_layer = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1276)

**パラメータ:**

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

add_pooling_layer (`bool`、*任意*、デフォルトは`True`) : プーリング層を追加するかどうか

特定のヘッドを上に載せず、生のhidden-statesを出力する素のLongformerモデル。

このモデルは [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.LongformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1384)

**パラメータ:**

input_ids (`torch.Tensor`、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)

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

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

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

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) を返すかどうか。

**戻り値:** [LongformerBaseModelOutputWithPooling](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) または `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.Tensor`、形状 `(batch_size, hidden_size)`) -- シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態を、Linear層とTanh活性化関数でさらに処理したものです。Linear層の重みは、事前学習中の次の文予測（分類）目的から学習されます。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

例:

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

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

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

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

## LongformerForMaskedLM[[transformers.LongformerForMaskedLM]]

#### transformers.LongformerForMaskedLM[[transformers.LongformerForMaskedLM]]

```python
transformers.LongformerForMaskedLM(config: LongformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1522)

**パラメータ:**

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

`language modeling`ヘッドを備えたLongformerモデル。

このモデルは [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.LongformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1543)

**パラメータ:**

input_ids (`torch.Tensor`、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)

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

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

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

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

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) を返すかどうか。

**戻り値:** [LongformerMaskedLMOutput](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- マスクド言語モデリング (MLM) の損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

マスク埋めの例:

```python
>>> from transformers import AutoTokenizer, LongformerForMaskedLM

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

非常に長い入力を試してみましょう。

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

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

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

## LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]]

#### transformers.LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]]

```python
transformers.LongformerForSequenceClassification(config: LongformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1639)

**パラメータ:**

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

Longformer Model シーケンス分類/回帰ヘッドを上部に備えた transformer（プーリングされた出力の上に線形層を配置）であり、GLUE タスクなどに使用できます。

このモデルは [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.LongformerForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1651)

**パラメータ:**

input_ids (`torch.Tensor`、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)

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

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

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

labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（平均二乗誤差）が計算され、`config.num_labels > 1` の場合は分類損失（クロスエントロピー）が計算されます。

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) を返すかどうか。

**戻り値:** [LongformerSequenceClassifierOutput](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 分類損失（config.num_labels==1 の場合は回帰損失）。
- **logits** (`torch.Tensor`、形状 `(batch_size, config.num_labels)`) -- SoftMax 適用前の分類（または config.num_labels==1 の場合は回帰）スコア。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

単一ラベル分類の例:

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

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

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

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

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

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

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

マルチラベル分類の例:

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

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

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

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

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

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

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

## LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]]

#### transformers.LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]]

```python
transformers.LongformerForMultipleChoice(config: LongformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1966)

**パラメータ:**

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

Longformer モデルは、プーリングされた出力の上に線形層と softmax を重ねた複数選択分類ヘッドを備えています。RocStories/SWAG タスクなどに使用できます。

このモデルは [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.LongformerForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1977)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, num_choices, 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)

token_type_ids (`torch.LongTensor`、shape `(batch_size, num_choices, sequence_length)`、*任意*) : 入力の第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは`[0, 1]`から選択されます:  - 0 は*文A*のトークンに対応します。 - 1 は*文B*のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

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

labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 多肢選択分類の損失を計算するためのラベル。インデックスは `[0, ..., num_choices-1]` の範囲である必要があります。ここで `num_choices` は入力テンソルの2次元目のサイズです（上記の `input_ids` を参照）。

position_ids (`torch.LongTensor`、shape `(batch_size, num_choices, sequence_length)`、*optional*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.max_position_embeddings - 1]` の範囲から選択されます。 [position ID とは?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`、shape `(batch_size, num_choices, sequence_length, hidden_size)`、*optional*) : `input_ids`を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、`input_ids`のインデックスを関連するベクトルに変換する方法をより細かく制御したい場合に便利です。

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) を返すかどうか。

**戻り値:** [LongformerMultipleChoiceModelOutput](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 *(1,)*、*オプション*、`labels` が指定された場合に返されます) -- 分類損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, num_choices)`) -- *num_choices* は入力テンソルの2番目の次元です（*input_ids* を参照）。

  分類スコア（SoftMax 適用前）。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

例:

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

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

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

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

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

## LongformerForTokenClassification[[transformers.LongformerForTokenClassification]]

#### transformers.LongformerForTokenClassification[[transformers.LongformerForTokenClassification]]

```python
transformers.LongformerForTokenClassification(config: LongformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1887)

**パラメータ:**

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

トークン分類ヘッド（隠れ状態の出力上に配置された線形層）を備えたLongformerトランスフォーマー。例として、固有表現抽出（NER）タスクに使用されます。

このモデルは [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.LongformerForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1899)

**パラメータ:**

input_ids (`torch.Tensor`、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)

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

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

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

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : トークン分類損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。

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) を返すかどうか。

**戻り値:** [LongformerTokenClassifierOutput](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 分類損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.num_labels)`) -- SoftMax 適用前の分類スコア。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

例:

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

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

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

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

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

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

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

## LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]]

#### transformers.LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]]

```python
transformers.LongformerForQuestionAnswering(config: LongformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1758)

**パラメータ:**

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

SQuAD などの抽出型質問応答タスク向けに、スパン分類ヘッドを備えた Longformer トランスフォーマー（隠れ状態の出力の上に線形層を置き、`span start logits` と `span end logits` を計算します）。

このモデルは [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.LongformerForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = 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/longformer/modeling_longformer.py#L1769)

**パラメータ:**

input_ids (`torch.Tensor`、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)

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

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

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

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

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

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) を返すかどうか。

**戻り値:** [LongformerQuestionAnsweringModelOutput](/docs/transformers/main/ja/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。
- **start_logits** (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) -- スパン開始スコア(SoftMax 適用前)。
- **end_logits** (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) -- スパンの終了スコア（SoftMax 適用前）。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル(レイヤーごとに1つ)。形状は `(batch_size, num_heads, sequence_length, x + attention_window + 1)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

  アテンション softmax 後のローカルアテンション重みです。自己アテンションヘッドにおける加重平均の計算に使用されます。これらは、シーケンス内の各トークンからグローバルアテンションを持つすべてのトークン（最初の `x` 個の値）およびアテンションウィンドウ内のすべてのトークン（残りの `attention_window
  + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`.
- **global_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）。形状は `(batch_size, num_heads, sequence_length, x)` で、`x` はグローバルアテンションマスクを持つトークンの数です。

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

例:

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

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

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

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

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

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