# Reformer

## 概要

Reformerモデルは、Nikita Kitaev、Łukasz Kaiser、Anselm Levskayaによる論文[Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451)で提案されました。

論文の抄録は以下の通りです。

*大規模なTransformerモデルは、多くのタスクで最先端の結果を達成しますが、これらのモデルの学習は、特に長いシーケンスに対しては、コストが非常に高くなる場合があります。本稿では、Transformerの効率を向上させる2つの手法を紹介します。1つ目は、ドット積アテンションを、局所性感受性ハッシュ（locality-sensitive hashing）を用いたアテンションに置き換えることで、その計算量をO(L^2)からO(Llog(L))に変更します（ここでLはシーケンスの長さです）。さらに、標準的な残差接続の代わりに、可逆な残差層を使用することで、学習プロセスにおいてアクティベーションをN回（Nは層数）保存する代わりに、1回だけ保存できるようにします。これにより得られるモデル、Reformerは、Transformerモデルと同等のパフォーマンスを発揮しながら、メモリ効率が高く、長いシーケンスに対してははるかに高速です。*

このモデルは[patrickvonplaten](https://huggingface.co/patrickvonplaten)によって提供されました。著者のコードは[こちら](https://github.com/google/trax/tree/master/trax/models/reformer)で確認できます。

## 使用のコツ

- PyTorch のバグにより、Reformer は *torch.nn.DataParallel* と **併用できません**。詳細は [issue #36035](https://github.com/pytorch/pytorch/issues/36035) を参照してください。
- Axial position encoding を使用します（詳細は下記を参照してください）。これは、シーケンス長が非常に大きい場合に巨大な位置エンコーディング行列を必要とすることを回避するための仕組みであり、小さな行列に因数分解することで実現されます。
- 従来のアテンションをLSH（local-sensitive hashing）アテンションに置き換えます（詳細は下記を参照）。これは、アテンション層内でクエリとキーの完全な積を計算することを回避するための技術です。
- 可逆トランスフォーマーレイヤーを使用し、バックワードパスの間に各レイヤーの中間結果を取得することで、それらを保存することを避けてください（次のレイヤーの入力から残差を引くことで復元できます）。また、特定のレイヤー内部の結果については、再計算を行うこともできます（保存するよりも効率は劣りますが、メモリを節約できます）。
- フィードフォワード操作をバッチ全体ではなく、チャンク単位で計算します。

### 軸方向位置エンコーディング

Axial Positional Encodings は、Google の [trax ライブラリ](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) で初めて実装され、このモデルの論文の著者によって開発されました。非常に長い入力シーケンスを扱うモデルでは、従来の position id エンコーディングは、各位置 $i, \ldots, n_s$ に対してサイズ $d$ の埋め込みベクトルを保存します。ここで $d$ は `config.hidden_size`、$n_s$ は `config.max_embedding_size` です。つまり、シーケンス長が $n_s = 2^{19} \approx 0.5M$、`config.hidden_size` が $d = 2^{10} \approx 1000$ の場合、位置エンコーディング行列は次のようになります。

$$X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } j \in \left[1,\ldots, n_s\right]$$

それだけで500M以上のパラメータを保存する必要があります。Axial positional encodingsは、$X_{i,j}$を2つの行列に分解します:

$$X^{1}_{i,j}, \text{ with } i \in \left[1,\ldots, d^1\right] \text{ and } j \in \left[1,\ldots, n_s^1\right]$$

および

$$X^{2}_{i,j}, \text{ with } i \in \left[1,\ldots, d^2\right] \text{ and } j \in \left[1,\ldots, n_s^2\right]$$

with:

$$d = d^1 + d^2 \text{ and } n_s = n_s^1 \times n_s^2 .$$

したがって、以下が成り立ちます。

$$X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$$

直感的には、これは位置埋め込みベクトル $x_j \in \mathbb{R}^{d}$ が、2つの分解された埋め込みベクトル $x^1_{k, l} + x^2_{l, k}$ の合成であることを意味します。ここで、`config.max_embedding_size` 次元の $j$ は $k \text{ と } l$ に分解されます。この設計により、各位置埋め込みベクトル $x_j$ が一意であることが保証されます。

上記の例を再び用いると、$d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ の軸方向位置エンコーディングにより、パラメータ数を 500 000 000 から $2^{18} + 2^{19} \approx 780 000$ に大幅に削減でき、これはメモリ使用量が 85% 減少することを意味します。

実際には、パラメータ`config.axial_pos_embds_dim`は、その和が`config.hidden_size`と等しくなるタプル $(d^1, d^2)$ に設定され、`config.axial_pos_shape`は、その積が`config.max_embedding_size`と等しくなるタプル $(n_s^1, n_s^2)$ に設定されます。この`config.max_embedding_size`は、学習中に`input_ids`の*シーケンス長*と等しくなければなりません。

### LSH自己注意

Locality sensitive hashing (LSH) self attention では、キーとクエリの射影重みが共有されています。そのため、キーとクエリの埋め込みベクトルも共有されます。LSH self attention は、[Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) で提案された locality sensitive hashing のメカニズムを用いて、共有された各キーとクエリの埋め込みベクトルを、`config.num_buckets` 個のバケットのいずれかに割り当てます。その前提は、*cosine similarity* の観点で互いにより「類似」なキーとクエリの埋め込みベクトルほど、同じバケットに割り当てられる可能性が高くなるというものです。

LSHメカニズムの精度は、`config.num_hashes`を増やすか、forward関数の引数`num_hashes`を直接増やすことで向上させることができます。これにより、LSH自己注意の出力が「通常の」フル自己注意の出力をよりよく近似するようになります。その後、バケットはソートされ、長さが`config.lsh_chunk_length`のクエリ・キー埋め込みベクトルのチャンクに分割されます。各チャンクについて、クエリ埋め込みベクトルは、それ自身に紐付けられたキーベクトルと、`config.lsh_num_chunks_before`個の直前の隣接チャンクおよび`config.lsh_num_chunks_after`個の直後の隣接チャンクのキー埋め込みベクトルに注意を払います。

詳細については、[元の論文](https://huggingface.co/papers/2001.04451)またはこの素晴らしい[ブログ記事](https://www.pragmatic.ml/reformer-deep-dive/)を参照してください。

`config.num_buckets` は、リスト $(n_{\text{buckets}}^1, n_{\text{buckets}}^2)$ に因数分解することもできます。これにより、クエリキー埋め込みベクトルは $(1,\ldots, n_{\text{buckets}})$ のいずれかに割り当てられるのではなく、$(1-1,\ldots, n_{\text{buckets}}^1-1, \ldots, 1-n_{\text{buckets}}^2, \ldots, n_{\text{buckets}}^1-n_{\text{buckets}}^2)$ のいずれかに割り当てられます。これは、非常に長いシーケンスにおいてメモリを節約するために不可欠です。

モデルをゼロから学習する場合、`config.num_buckets=None`のままにしておくことをお勧めします。これにより、シーケンス長に応じて`num_buckets`の適切な値がオンザフライで計算されます。この値は自動的に設定に保存されるため、推論時には再利用すべきです。

LSH自己注意機構を使用することで、シーケンス長を$n_s$とすると、通常はTransformerモデルにおけるメモリおよび時間のボトルネックとなるクエリとキーの行列積演算のメモリおよび時間計算量が、$\mathcal{O}(n_s \times n_s)$から$\mathcal{O}(n_s \times \log(n_s))$に削減できます。

### ローカルセルフアテンション

Local self attention は、key、query、value の射影を持つ通常の self attention レイヤーですが、`config.local_chunk_length` の長さの各チャンクにおいて、query 埋め込みベクトルがそのチャンク内の key 埋め込みベクトル、および `config.local_num_chunks_before` 個の直前の隣接チャンクと `config.local_num_chunks_after` 個の直後の隣接チャンクの key 埋め込みベクトルにのみ注意を払うように、チャンク化されています。

Local self attention を使用することで、シーケンス長を $n_s$ とすると、Transformer モデルにおいて通常、メモリおよび時間のボトルネックとなるクエリとキーの行列積演算のメモリおよび時間計算量が、$\mathcal{O}(n_s \times n_s)$ から $\mathcal{O}(n_s \times \log(n_s))$ に削減できます。

### トレーニング

学習中、シーケンス長が`config.lsh_chunk_length`と`config.local_chunk_length`の最小公倍数で割り切れる値に設定されていること、および上記の通り Axial Positional Encodings のパラメータが正しく設定されていることを確認する必要があります。Reformer はメモリ効率が高いため、64000 トークンに及ぶ長いシーケンスでもモデルを容易に学習できます。

学習には、[ReformerModelWithLMHead](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerModelWithLMHead)を次のように使用します。

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

## リソース

- [テキスト分類タスクガイド](../tasks/sequence_classification)
- [質問応答タスクガイド](../tasks/question_answering)
- [因果言語モデリングタスクのガイド](../tasks/language_modeling)
- [マスクド言語モデリングタスクのガイド](../tasks/masked_language_modeling)

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(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_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/configuration_reformer.py#L25)

**パラメータ:**

attention_head_size (`int`、*optional*、デフォルトは 64) : 投影されたキー、クエリ、ベクトル値の次元

attn_layers (`list[str]`, *任意*、デフォルトは `["local", "lsh", "local", "lsh", "local", "lsh"]`) : 昇順の注意レイヤータイプのリスト。LSHSelfAttention レイヤー (`"lsh"`) と LocalSelfAttention レイヤー (`"local"`) の間で選択できます。LSHSelfAttention レイヤーの詳細については、[LSH Self Attention](reformer#lsh-self-attention) を参照してください。LocalSelfAttention レイヤーの詳細については、[Local Self Attention](reformer#local-self-attention) を参照してください。

axial_norm_std (`float`、*optional*、デフォルト値は 1.0) : 軸方向位置エンコーディングの重み行列を初期化するための normal_initializer の標準偏差です。

axial_pos_embds (`bool`, *任意*, デフォルトは `True`) : 軸方向位置埋め込みを使用するかどうか。軸方向位置埋め込みの動作に関する詳細については、[Axial Position Encodings](reformer#axial-positional-encodings)を参照してください。

axial_pos_shape (`list[int]`、*optional*、デフォルトは`[64, 64]`) : 軸方向位置エンコーディングの位置次元です。学習中、位置次元の積はシーケンス長と等しくなければなりません。軸方向位置埋め込みの動作に関する詳細は、[Axial Position Encodings](reformer#axial-positional-encodings)を参照してください。

axial_pos_embds_dim (`list[int]`、*optional*、デフォルトは`[64, 192]`) : 軸方向位置エンコーディングの埋め込み次元です。埋め込み次元の合計は、隠れ層サイズと等しくなければなりません。軸方向位置埋め込みの動作に関する詳細は、[Axial Position Encodings](reformer#axial-positional-encodings)を参照してください。

chunk_size_lm_head (`int`、*optional*、デフォルト値は 0) : 最終的な言語モデルのフィードフォワードヘッド層のチャンクサイズです。チャンクサイズが 0 の場合、フィードフォワード層はチャンク分割されません。チャンクサイズが n の場合、フィードフォワード層は一度に n < sequence_length 個の埋め込みを処理します。フィードフォワードチャンク分割の詳細については、[How does Feed Forward Chunking work?](../glossary#feed-forward-chunking)を参照してください。

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

feed_forward_size (`int`, *任意*, デフォルトは 512) : 残差アテンションブロック内の feed_forward 層の次元数。

hash_seed (`int`, *optional*) : `LSHSelfAttention`におけるローカルセンシティブハッシングを決定論的にするためのシードです。これはテスト目的でのみ設定すべきです。評価や学習目的では、ローカルセンシティブハッシング方式で完全にランダムな回転を確保するために、`hash_seed`は`None`のままにしてください。

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

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

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

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

is_decoder (`bool`, *任意*, デフォルトは `False`) : モデルがデコーダーとして使用されるかどうかを指定します。`False` の場合、モデルはエンコーダーとして使用されます。

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

local_num_chunks_before (`int`、*optional*、デフォルトは 1) : `LocalSelfAttention` レイヤー内で、自身に対して注意を向ける直前の隣接チャンクの数。

local_num_chunks_after (`int`, *optional*, デフォルトは 0) : `LocalSelfAttention` レイヤーにおいて、自身に加えて注意を向ける後続の隣接チャンクの数。

local_attention_probs_dropout_prob (`float`、*任意*、デフォルトは 0.1) : `LocalSelfAttention` におけるアテンション確率のドロップアウト率です。

local_attn_chunk_length (`int`、*任意*、デフォルトは 64) : ローカルアテンション層における各チャンクの長さ。

lsh_attn_chunk_length (`int`, *optional*, デフォルトは 64) : `LSHSelfAttention` において、自己にアテンションを行うチャンクの長さです。チャンク化により、メモリ複雑度はシーケンス長 x シーケンス長（自己アテンション）から、チャンク長 x チャンク長 x シーケンス長 / チャンク長（チャンク化された自己アテンション）に低減されます。

lsh_attention_probs_dropout_prob (`float`、*任意*、デフォルトは 0.1) : `LSHSelfAttention` におけるアテンション確率のドロップアウト率です。

lsh_num_chunks_before (`int`、*optional*、デフォルトは 1) : `LSHSelfAttention`層において、自身に対して注意を向ける直前の隣接チャンクの数。

lsh_num_chunks_after (`int`、*optional*、デフォルトは 0) : `LSHSelfAttention` レイヤー内で、自身に注意を向けるために参照する後続の隣接チャンクの数。

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

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

num_buckets (`int` または `list[int]`、*任意*) : バケット数。ロカリティセンシティブハッシング方式を用いて、キークエリベクトルを「ハッシュ化」できるバケットの数です。各クエリキーベクトルは、`1, ..., num_buckets` のいずれかのハッシュにハッシュ化されます。バケット数は、メモリ複雑度の改善のためにリストとして因数分解することもできます。この場合、`num_buckets` が2つの因子に因数分解されている場合、各クエリキーベクトルは `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]` のいずれかのハッシュにハッシュ化されます。バケット数（または因子の積）は、シーケンス長 / lsh_chunk_length にほぼ等しくなるべきです。`num_buckets` が設定されていない場合、適切な値がオンザフライで計算されます。

num_hashes (`int`、*optional*、デフォルトは 1) : Local Sensitive Hashing スキームにおけるハッシュのラウンド数（例：ランダム回転の数）です。`num_hashes` が大きいほど、`LSHSelfAttention` の精度は高くなりますが、ハッシュ処理のメモリと計算時間も増加します。

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

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

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

classifier_dropout (`Union[float, int]`、*任意*) : クラス分類器の dropout 率。

bos_token_id (`int`, *任意*) : 語彙内でストリームの開始に使用されるトークン ID。

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

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

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

例:

```python
>>> from transformers import ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

## ReformerTokenizer[[transformers.ReformerTokenizer]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/tokenization_reformer.py#L31)

**パラメータ:**

vocab_file (`str`) : トークナイザーをインスタンス化するために必要な語彙を含む [SentencePiece](https://github.com/google/sentencepiece) ファイル（通常は *.spm* 拡張子を持っています）。

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

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

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

additional_special_tokens (`list[str]`、*任意*) : トークナイザーで使用される追加の特殊トークン。

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

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

HuggingFaceのtokenizersライブラリをベースにしたReformerのトークナイザーを構築します。[BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models)に基づいています。

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

#### save_vocabulary[[transformers.ReformerTokenizer.save_vocabulary]]

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

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

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1931)

**パラメータ:**

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

特定のヘッドを付加せず、生の隠れ状態を出力する素のReformerモデル。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.ReformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1951)

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。学習中は、input_ids の sequence_length は、該当するモデルのチャンク長（lsh、local、またはその両方）の倍数である必要があります。評価中は、インデックスは自動的にチャンク長の倍数にパディングされます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[input ID とは何か？](../glossary#input-ids)

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

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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

num_hashes (`int`, *optional*) : バケット化時に実行すべきハッシュラウンドの数です。この引数を設定すると、`config.num_hashes` で定義されているデフォルト値が上書きされます。詳細については、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig) の `num_hashes` を参照してください。

past_buckets_states (`ReformerDynamicCache`, *任意*) : `config.n_layers` の長さを持つ `tuple(torch.LongTensor, torch.Tensor` のリスト。最初の要素は形状が `(batch_size, num_heads, num_hashes, sequence_length)` の以前の *buckets*、2番目の要素は形状が `(batch_size, sequence_length, hidden_size)` の以前の *hidden_states* です。LSH Self-Attention にのみ関連する、事前計算済みの hidden-states と buckets を保持します。シーケンシャルデコーディングの高速化に使用できます。

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

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

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

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

**戻り値:** `ReformerModelOutput` または `tuple(torch.Tensor)`

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

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

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

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

  `num_predict` は `target_mapping.shape[1]` に相当します。`target_mapping` が `None` の場合、`num_predict` は `sequence_length` に相当します。
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`、*optional*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- 長さが `config.n_layers` の `tuple(torch.LongTensor, torch.Tensor` のリストで、最初の要素は形状が `(batch_size, num_heads, num_hashes, sequence_length)` の以前の *buckets*、2番目の要素は形状が `(batch_size, sequence_length, hidden_size)` の以前の *hidden_states* です。

  `past_buckets_states`入力として使用でき、シーケンシャルデコーディングを高速化できる事前計算済みバケットと隠れ状態（hidden-states）が含まれています。
- **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, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2150)

**パラメータ:**

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

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

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2176)

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。学習中は、input_ids の sequence_length は、該当するモデルのチャンク長（lsh、local、またはその両方）の倍数である必要があります。評価中は、インデックスは自動的にチャンク長の倍数にパディングされます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[input ID とは何か？](../glossary#input-ids)

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

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

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

num_hashes (`int`, *optional*) : バケット化時に実行すべきハッシュラウンドの数です。この引数を設定すると、`config.num_hashes` で定義されているデフォルト値が上書きされます。詳細については、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig) の `num_hashes` を参照してください。

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`、*任意*) : 長さ`config.n_layers`の`tuple(torch.LongTensor, torch.Tensor`のリスト。最初の要素は形状`(batch_size, num_heads, num_hashes, sequence_length)`の直前の*buckets*、2番目の要素は形状`(batch_size, sequence_length, hidden_size)`の直前の*hidden_states*です。 事前計算済みのhidden-statesとbuckets（LSH Self-Attentionでのみ関連）を保持します。シーケンシャルデコーディングの高速化に使用できます。

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

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

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

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

labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size - 1]` の範囲である必要があります。ラベルが `-100` に設定されているものは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルに対してのみ計算されます。

logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

**戻り値:** [CausalLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutput) または `tuple(torch.Tensor)`

`torch.Tensor`のタプル、または`return_dict=False`が渡された場合、あるいは`config.return_dict=False`の場合の`torch.Tensor`のタプルで、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig)および入力に応じてさまざまな要素で構成される[CausalLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutput)。

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **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, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2287)

**パラメータ:**

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

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

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.ReformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2307)

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。学習中は、input_ids の sequence_length は、該当するモデルのチャンク長（lsh、local、またはその両方）の倍数である必要があります。評価中は、インデックスは自動的にチャンク長の倍数にパディングされます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[input ID とは何か？](../glossary#input-ids)

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

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

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

num_hashes (`int`, *optional*) : バケット化時に実行すべきハッシュラウンドの数です。この引数を設定すると、`config.num_hashes` で定義されているデフォルト値が上書きされます。詳細については、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig) の `num_hashes` を参照してください。

labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスクド言語モデリング損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失はラベルが設定されたトークンのみに対して計算されます。この例では、Reformer アーキテクチャのマスクド言語モデリングタスク用の事前学習済みモデルが利用できないため、ダミーのチェックポイントを使用しています。

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

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

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

**戻り値:** [MaskedLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) または `tuple(torch.Tensor)`

設定（[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig)）と入力に応じて、さまざまな要素で構成される、[MaskedLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.MaskedLMOutput)または`torch.Tensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。

[ReformerForMaskedLM](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerForMaskedLM) の 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, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

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

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> predicted_token = tokenizer.decode(predicted_token_id)
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(
...     inputs.input_ids == tokenizer.mask_token_id, labels[:, : inputs["input_ids"].shape[-1]], -100
... )

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

## ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2425)

**パラメータ:**

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

Reformer Modelは、プーリングされた出力の上に線形層を配置したシーケンス分類/回帰ヘッドを備えたtransformerモデルです。GLUEタスクなどに使用されます。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.ReformerForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2439)

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。学習中は、input_ids の sequence_length は、該当するモデルのチャンク長（lsh、local、またはその両方）の倍数である必要があります。評価中は、インデックスは自動的にチャンク長の倍数にパディングされます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[input ID とは何か？](../glossary#input-ids)

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

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

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

num_hashes (`int`, *optional*) : バケット化時に実行すべきハッシュラウンドの数です。この引数を設定すると、`config.num_hashes` で定義されているデフォルト値が上書きされます。詳細については、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig) の `num_hashes` を参照してください。

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

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

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

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

**戻り値:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `tuple(torch.Tensor)`

設定（[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig)）と入力に応じて、さまざまな要素で構成される、[SequenceClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[ReformerForSequenceClassification](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerForSequenceClassification)の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, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

単一ラベル分類の例:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

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

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

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

```python
>>> # 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 = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
```

## ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2572)

**パラメータ:**

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

SQuADのような抽出型質問応答タスク用に、Reformer transformerの上部にスパン分類ヘッドを備えたモデル（隠れ状態の出力の上に線形層を置き、`span start logits`と`span end logits`を計算する）。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.ReformerForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2584)

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。学習中は、input_ids の sequence_length は、該当するモデルのチャンク長（lsh、local、またはその両方）の倍数である必要があります。評価中は、インデックスは自動的にチャンク長の倍数にパディングされます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[input ID とは何か？](../glossary#input-ids)

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

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

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

num_hashes (`int`, *optional*) : バケット化時に実行すべきハッシュラウンドの数です。この引数を設定すると、`config.num_hashes` で定義されているデフォルト値が上書きされます。詳細については、[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig) の `num_hashes` を参照してください。

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

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

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

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

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

**戻り値:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) または `tuple(torch.Tensor)`

設定（[ReformerConfig](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerConfig)）や入力に応じて、さまざまな要素で構成される [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[ReformerForQuestionAnswering](/docs/transformers/v5.23.0/ja/model_doc/reformer#transformers.ReformerForQuestionAnswering)の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, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

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

