# Reformer

## 概述

Reformer 模型由 Nikita Kitaev、Łukasz Kaiser 和 Anselm Levskaya 在论文 [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451) 中提出。

该论文的摘要如下：

*大型 Transformer 模型在许多任务上都能取得最先进的结果，但训练这些模型的成本可能高得令人望而却步，尤其是在处理长序列时。我们提出了两种技术来提高 Transformer 的效率。首先，我们用基于局部敏感哈希的注意力机制替换了点积注意力，将其复杂度从 O(L^2) 降低到 O(Llog(L))，其中 L 是序列长度。此外，我们使用可逆残差层来替代标准残差层，这使得在训练过程中只需存储一次激活值，而不是 N 次，其中 N 是层数。由此产生的模型 Reformer 在性能上与 Transformer 模型相当，同时在内存效率上更高，在处理长序列时速度也更快。*

该模型由 [patrickvonplaten](https://huggingface.co/patrickvonplaten) 贡献。作者的代码可在[此处](https://github.com/google/trax/tree/master/trax/models/reformer)找到。

## 使用技巧

- 由于 PyTorch 中的一个 bug，Reformer **无法**与 *torch.nn.DataParallel* 配合使用，请参阅 [issue #36035](https://github.com/pytorch/pytorch/issues/36035)。
- 使用轴向位置编码（更多详情请参见下文）。这是一种通过将位置编码矩阵分解为更小的矩阵，从而避免在序列长度非常大时生成巨大的位置编码矩阵的机制。
- 用 LSH（局部敏感哈希）注意力替换传统注意力（更多细节见下文）。这是一种避免在注意力层中计算完整的 query-key 乘积的技术。
- 通过使用可逆 Transformer 层来避免存储每一层的中间结果，从而在反向传播过程中获取这些结果（从下一层的输入中减去残差即可恢复它们），或者重新计算给定层内部的结果（效率低于直接存储，但能节省内存）。
- 按块计算前馈操作，而不是对整个批次进行计算。

### 轴向位置编码

轴向位置编码最初在 Google 的 [trax 库](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) 中实现，并由该模型论文的开发者进一步完善。在处理超长输入序列的模型中，传统的位置 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{ 其中 } i \in \left[1,\ldots, d\right] \text{ 且 } j \in \left[1,\ldots, n_s\right]$$

仅这一项就需要存储超过 5 亿个参数。轴向位置编码将 $X_{i,j}$ 分解为两个矩阵：

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

和

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

使用：

$$d = d^1 + d^2 \text{ 且 } 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}$ 现在是两个分解后的嵌入向量的组合：$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` 被设置为一个元组 $(d^1, d^2)$，其元素之和必须等于 `config.hidden_size`；`config.axial_pos_shape` 被设置为一个元组 $(n_s^1, n_s^2)$，其元素之积必须等于 `config.max_embedding_size`，而在训练期间，该值必须等于 `input_ids` 的 *序列长度*。

### LSH 自注意力

In Locality sensitive hashing (LSH) self attention the key and query projection weights are tied. Therefore, the key query embedding vectors are also tied. LSH self attention uses the locality sensitive hashing mechanism proposed in [Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) to assign each of the tied key query embedding vectors to one of `config.num_buckets` possible buckets. The premise is that the more "similar" key query embedding vectors (in terms of *cosine similarity*) are to each other, the more likely they are assigned to the same bucket.

通过增加 `config.num_hashes` 或直接增加 forward 函数的参数 `num_hashes`，可以提高 LSH 机制的精度，从而使 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 自注意力机制，可以将查询-键矩阵乘法操作的内存和时间复杂度从 $\mathcal{O}(n_s \times n_s)$ 降低到 $\mathcal{O}(n_s \times \log(n_s))$，其中 $n_s$ 为序列长度。该操作通常是 Transformer 模型中的内存和时间瓶颈。

### 局部自注意力

局部自注意力本质上是一个带有键、查询和值投影的“常规”自注意力层，但被分块处理，使得在长度为 `config.local_chunk_length` 的每个块中，查询嵌入向量仅关注其所在块内的键嵌入向量，以及前 `config.local_num_chunks_before` 个相邻块和后 `config.local_num_chunks_after` 个相邻块中的键嵌入向量。

使用本地自注意力，查询-键矩阵乘法操作的内存和时间复杂度可以从 $\mathcal{O}(n_s \times n_s)$ 降低到 $\mathcal{O}(n_s \times \log(n_s))$，其中 $n_s$ 为序列长度。该操作通常是 Transformer 模型中的内存和时间瓶颈。

### 训练

在训练期间，我们必须确保序列长度设置为可被 `config.lsh_chunk_length` 和 `config.local_chunk_length` 的最小公倍数整除的值，并且 Axial Positional Encodings 的参数已按照上述说明正确设置。Reformer 的内存效率非常高，因此可以轻松地在长达 64000 个 token 的序列上训练模型。

在训练时，[ReformerModelWithLMHead](/docs/transformers/v5.23.0/zh/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`，*可选*，默认为 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`, *可选*，默认为 1.0)：用于初始化轴向位置编码权重矩阵的 normal_initializer 的标准差。

axial_pos_embds (`bool`，*可选*，默认为 `True`)：是否使用轴向位置嵌入。有关轴向位置嵌入工作原理的更多信息，请参阅 [Axial Position Encodings](reformer#axial-positional-encodings)。

axial_pos_shape (`list[int]`, *可选*, 默认为 `[64, 64]`) : 轴向位置编码的位置维度。在训练期间，位置维度的乘积必须等于序列长度。有关轴向位置嵌入工作原理的更多信息，请参阅 [Axial Position Encodings](reformer#axial-positional-encodings)。

axial_pos_embds_dim (`list[int]`, *可选*, 默认为 `[64, 192]`) : 轴向位置编码的嵌入维度。嵌入维度之和必须等于隐藏层大小。有关轴向位置编码工作原理的更多信息，请参阅 [Axial Position Encodings](reformer#axial-positional-encodings)。

chunk_size_lm_head (`int`, *可选*，默认为 0)：最终语言模型前馈头层的块大小。块大小为 0 表示前馈层不进行分块。块大小为 n 表示前馈层每次处理 n < sequence_length 个嵌入。有关前馈分块的更多信息，请参阅 [前馈分块是如何工作的？](../glossary#feed-forward-chunking)。

eos_token_id (`Union[int, list[int]]`，*可选*，默认为 `2`)：词汇表中用于表示流结束（end-of-stream）的 token id。

feed_forward_size (`int`，*可选*，默认为 512)：残差注意力块中 feed_forward 层的维度。

hash_seed (`int`, *可选*) : 可用于使 `LSHSelfAttention` 中的局部敏感哈希具有确定性的种子。此参数仅应在测试目的下设置。出于评估和训练目的，应将 `hash_seed` 保留为 `None`，以确保局部敏感哈希方案中的旋转完全随机。

hidden_act (`str`，*可选*，默认为 `relu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.05`)：嵌入层、编码器和池化层中所有全连接层的 dropout 概率。

hidden_size (`int`，*可选*，默认为 `256`)：隐藏表示的维度。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

is_decoder (`bool`，*可选*，默认为 `False`)：模型是否用作解码器。如果为 `False`，则模型用作编码器。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

local_num_chunks_before (`int`，*可选*，默认为 1)：在 `LocalSelfAttention` 层中，自身需要关注的先前相邻块的数量。

local_num_chunks_after (`int`，*可选*，默认为 0)：在 `LocalSelfAttention` 层中，除自身外，需要关注的后续相邻块的数量。

local_attention_probs_dropout_prob (`float`, *可选*, 默认值为 0.1) : `LocalSelfAttention` 中注意力概率的 dropout 比率。

local_attn_chunk_length (`int`，*可选*，默认为 64)：局部注意力层中每个块（chunk）的长度。

lsh_attn_chunk_length (`int`, *可选*，默认为 64)：`LSHSelfAttention` 中关注自身的块长度。分块将内存复杂度从序列长度 x 序列长度（自注意力）降低为块长度 x 块长度 x 序列长度 / 块长度（分块自注意力）。

lsh_attention_probs_dropout_prob (`float`, *可选*, 默认值为 0.1) : `LSHSelfAttention` 中注意力概率的 dropout 比率。

lsh_num_chunks_before (`int`，*可选*，默认为 1)：在 `LSHSelfAttention` 层中，自身需要关注的先前相邻块的数量。

lsh_num_chunks_after (`int`，*可选*，默认为 0)：在 `LSHSelfAttention` 层中，自身需要关注的后续相邻块的数量。

max_position_embeddings (`int`，*可选*，默认值为 `4096`)：该模型可能使用的最大序列长度。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

num_buckets (`int` 或 `list[int]`，*可选*) : 桶的数量，查询键向量可以通过局部敏感哈希方案“哈希”到这些桶中。每个查询键向量被哈希到 `1, ..., num_buckets` 中的一个哈希值。桶的数量也可以分解为一个列表，以改善内存复杂度。在这种情况下，如果 `num_buckets` 被分解为两个因子，则每个查询键向量被哈希到 `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]` 中的一个哈希值。桶的数量（或因子的乘积）应大致等于序列长度 / lsh_chunk_length。如果未设置 `num_buckets`，则会动态计算一个合适的值。

num_hashes (`int`, *可选*，默认为 1)：局部敏感哈希方案中的哈希轮数（例如随机旋转的次数）。`num_hashes` 越高，`LSHSelfAttention` 的精度越高，但哈希过程所需的内存和时间也越多。

vocab_size (`int`，*可选*，默认值为 `320`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

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`, *可选*) : 词表中用于表示流开始的 Token id。

pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。

这是用于存储 ReformerModel 配置的类。它根据指定的参数实例化 Reformer 模型，并定义模型架构。使用默认值实例化配置将生成与 [google/reformer-crime-and-punishment](https://huggingface.co/google/reformer-crime-and-punishment) 类似的配置

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/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` 加载合并。

构建一个 Reformer 分词器（基于 HuggingFace 的 tokenizers 库）。基于 [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models)。

该分词器继承自 [TokenizersBackend](/docs/transformers/v5.23.0/zh/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/zh/model_doc/reformer#transformers.ReformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

未附加任何特定头部的裸 Reformer 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

num_hashes (`int`, *可选*) : 在分桶过程中应执行的哈希轮数。设置此参数会覆盖 `config.num_hashes` 中定义的默认值。 有关更多信息，请参阅 [ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig) 中的 `num_hashes`。

past_buckets_states (`ReformerDynamicCache`, *可选*) : 一个 `tuple(torch.LongTensor, torch.Tensor` 的列表，长度为 `config.n_layers`，其中第一个元素是形状为 `(batch_size, num_heads, num_hashes, sequence_length)` 的先前 *buckets*，第二个元素是形状为 `(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`。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/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/zh/model_doc/reformer#transformers.ReformerConfig)）和输入。

[ReformerModel](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, num_predict, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层的隐藏状态序列。

  `num_predict` 对应于 `target_mapping.shape[1]`。如果 `target_mapping` 为 `None`，则 `num_predict` 对应于 `sequence_length`。
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回) -- 一个长度为 `config.n_layers` 的 `tuple(torch.LongTensor, torch.Tensor` 列表，其中第一个元素是形状为 `(batch_size, num_heads, num_hashes, sequence_length)` 的先前 *buckets*，第二个元素是形状为 `(batch_size, sequence_length, hidden_size)` 的先前 *hidden_states*。

  包含预计算的桶和隐藏状态，可用于（参见 `past_buckets_states` 输入）加速顺序解码。
- **hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(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/zh/model_doc/reformer#transformers.ReformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

带有 `language modeling` 头的 Reformer 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

num_hashes (`int`, *可选*) : 在分桶过程中应执行的哈希轮数。设置此参数会覆盖 `config.num_hashes` 中定义的默认值。 有关更多信息，请参阅 [ReformerConfig](/docs/transformers/v5.23.0/zh/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*，第二个元素是形状为 `(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`。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

labels (`torch.LongTensor`，形状为 `(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` 个 token 的 logits。如果为 `0`，则计算所有 `input_ids` 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当可观。如果为 `torch.Tensor`，则必须是一维张量，对应于序列长度维度中需要保留的索引。这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。

**返回：** [CausalLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutput) 或 `tuple(torch.Tensor)`

一个 [CausalLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig)）和输入。

[ReformerModelWithLMHead](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerModelWithLMHead) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 语言建模损失（用于下一个 token 预测）。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(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/zh/model_doc/reformer#transformers.ReformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

带有 `language modeling` 头的 Reformer 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

num_hashes (`int`, *可选*) : 在分桶过程中应执行的哈希轮数。设置此参数会覆盖 `config.num_hashes` 中定义的默认值。 有关更多信息，请参阅 [ReformerConfig](/docs/transformers/v5.23.0/zh/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`。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [MaskedLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `tuple(torch.Tensor)`

一个 [MaskedLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig)）和输入。

[ReformerForMaskedLM](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerForMaskedLM) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 掩码语言建模（MLM）损失。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(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/zh/model_doc/reformer#transformers.ReformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Reformer 模型，顶部带有用于序列分类/回归任务的头部（在池化输出之上添加一个线性层），例如用于 GLUE 任务。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

num_hashes (`int`, *可选*) : 在分桶过程中应执行的哈希轮数。设置此参数会覆盖 `config.num_hashes` 中定义的默认值。 有关更多信息，请参阅 [ReformerConfig](/docs/transformers/v5.23.0/zh/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`。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [SequenceClassifierOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 或 `tuple(torch.Tensor)`

一个 [SequenceClassifierOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig)）和输入。

[ReformerForSequenceClassification](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerForSequenceClassification) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 分类损失（如果 config.num_labels==1，则为回归损失）。
- **logits**（形状为 `(batch_size, config.num_labels)` 的 `torch.Tensor`）-- 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(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/zh/model_doc/reformer#transformers.ReformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

用于抽取式问答任务（如 SQuAD）的 Reformer 转换器，其顶部带有跨度分类头（在隐藏状态输出之上添加一个线性层，用于计算`span start logits`和`span end logits`）。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

num_hashes (`int`, *可选*) : 在分桶过程中应执行的哈希轮数。设置此参数会覆盖 `config.num_hashes` 中定义的默认值。 有关更多信息，请参阅 [ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig) 中的 `num_hashes`。

start_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度起始位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

end_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度结束位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 或 `tuple(torch.Tensor)`

一个 [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ReformerConfig](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerConfig)）和输入。

[ReformerForQuestionAnswering](/docs/transformers/v5.23.0/zh/model_doc/reformer#transformers.ReformerForQuestionAnswering) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 总跨度提取损失是起始位置和结束位置的交叉熵之和。
- **start_logits**（形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`）-- 跨度起始分数（SoftMax 之前）。
- **end_logits**（形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`）-- 跨度结束分数（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(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)
...
```

