Transformers 4.37 中文文档（五十四）（2）

Transformers 4.37 中文文档（五十四）（1）https://developer.aliyun.com/article/1565372

RealmScorer

class transformers.RealmScorer

<来源>

( config query_embedder = None )

参数

• config (RealmConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
  
• query_embedder (RealmEmbedder) — 用于输入序列的嵌入器。如果未指定，将使用与候选序列相同的嵌入器。
  

REALM 的评分器输出代表文档候选项得分（softmax 之前）的相关性分数。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None candidate_input_ids: Optional = None candidate_attention_mask: Optional = None candidate_token_type_ids: Optional = None candidate_inputs_embeds: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.realm.modeling_realm.RealmScorerOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

• 1 表示未被掩码的标记，
  
• 0 表示被掩码的标记。
  

• 什么是注意力掩码？
  
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]之间：

• 0 对应于句子 A标记。
  
• 1 对应于句子 B标记。
  

• 什么是标记类型 ID？
  
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
  什么是位置 ID？
  
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

• 1 表示头部是未被掩码的，
  
• 0 表示头部是被掩码的。
  

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  
• candidate_input_ids (torch.LongTensor of shape (batch_size, num_candidates, sequence_length)) — 词汇表中候选输入序列标记的索引。
  可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是 input IDs？
  
• candidate_attention_mask（形状为(batch_size, num_candidates, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

• 1 表示未被 mask的标记，
  
• 0 表示被masked的标记。
  

• 什么是注意力掩码？
  
• candidate_token_type_ids（形状为(batch_size, num_candidates, sequence_length)的torch.LongTensor，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记，
  
• 1 对应于句子 B标记。
  

• 什么是 token type IDs？
  
• candidate_inputs_embeds（形状为(batch_size * num_candidates, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递candidate_input_ids。如果您想要更多控制权，以便将candidate_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  

返回

transformers.models.realm.modeling_realm.RealmScorerOutput或tuple(torch.FloatTensor)

一个transformers.models.realm.modeling_realm.RealmScorerOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（RealmConfig）和输入的不同元素。

• relevance_score（形状为(batch_size, config.num_candidates)的torch.FloatTensor）- 文档候选项的相关性分数（softmax 之前）。
  
• query_score（形状为(batch_size, config.retriever_proj_size)的torch.FloatTensor）- 从查询嵌入器派生的查询分数。
  
• candidate_score（形状为(batch_size, config.num_candidates, config.retriever_proj_size)的torch.FloatTensor）- 从嵌入器派生的候选分数。
  

RealmScorer 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> import torch
>>> from transformers import AutoTokenizer, RealmScorer
>>> tokenizer = AutoTokenizer.from_pretrained("google/realm-cc-news-pretrained-scorer")
>>> model = RealmScorer.from_pretrained("google/realm-cc-news-pretrained-scorer", num_candidates=2)
>>> # batch_size = 2, num_candidates = 2
>>> input_texts = ["How are you?", "What is the item in the picture?"]
>>> candidates_texts = [["Hello world!", "Nice to meet you!"], ["A cute cat.", "An adorable dog."]]
>>> inputs = tokenizer(input_texts, return_tensors="pt")
>>> candidates_inputs = tokenizer.batch_encode_candidates(candidates_texts, max_length=10, return_tensors="pt")
>>> outputs = model(
...     **inputs,
...     candidate_input_ids=candidates_inputs.input_ids,
...     candidate_attention_mask=candidates_inputs.attention_mask,
...     candidate_token_type_ids=candidates_inputs.token_type_ids,
... )
>>> relevance_score = outputs.relevance_score

RealmKnowledgeAugEncoder

class transformers.RealmKnowledgeAugEncoder

<来源>

( config )

参数

• config（RealmConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

REALM 的知识增强编码器输出掩码语言模型对数和边际对数似然损失。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None relevance_score: Optional = None labels: Optional = None mlm_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, num_candidates, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor of shape (batch_size, num_candidates, sequence_length), optional) — 用于避免在填充令牌索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

• 1 表示未被掩码的标记，
  
• 0 表示被掩码的标记。
  

• 什么是注意力掩码？
  
• token_type_ids (torch.LongTensor of shape (batch_size, num_candidates, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记。
  
• 1 对应于句子 B标记。
  

• 什么是标记类型 ID？
  
• position_ids (torch.LongTensor of shape (batch_size, num_candidates, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  什么是位置 ID？
  
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]中：

• 1 表示头部未被掩码，
  
• 0 表示头部被掩码。
  

• inputs_embeds (torch.FloatTensor of shape (batch_size, num_candidates, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  
• relevance_score (torch.FloatTensor of shape (batch_size, num_candidates), optional) — 从 RealmScorer 派生的相关性分数，如果要计算掩码语言建模损失，必须指定。
  
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。
  
• mlm_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在某些位置计算联合损失的掩码。如果未指定，损失将不会被掩码。掩码值选择在[0, 1]中：

• 1 表示未被掩码的标记，
  
• 0 表示被掩码的标记。
  

返回

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（RealmConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 掩码语言建模（MLM）损失。
  
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出和每一层的输出）。
  模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

RealmKnowledgeAugEncoder 的前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> import torch
>>> from transformers import AutoTokenizer, RealmKnowledgeAugEncoder
>>> tokenizer = AutoTokenizer.from_pretrained("google/realm-cc-news-pretrained-encoder")
>>> model = RealmKnowledgeAugEncoder.from_pretrained(
...     "google/realm-cc-news-pretrained-encoder", num_candidates=2
... )
>>> # batch_size = 2, num_candidates = 2
>>> text = [["Hello world!", "Nice to meet you!"], ["The cute cat.", "The adorable dog."]]
>>> inputs = tokenizer.batch_encode_candidates(text, max_length=10, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

RealmReader

class transformers.RealmReader

<来源>

( config )

参数

• config（RealmConfig）- 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

REALM 的读取器。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None relevance_score: Optional = None block_mask: Optional = None start_positions: Optional = None end_positions: Optional = None has_answers: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.realm.modeling_realm.RealmReaderOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(reader_beam_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  输入 ID 是什么？
  
• attention_mask（形状为(reader_beam_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

• 对于“未屏蔽”的标记为 1，
  
• 对于被“屏蔽”的标记为 0。
  

• 注意力掩码是什么？
  
• token_type_ids (torch.LongTensor of shape (reader_beam_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于一个sentence A token，
  
• 1 对应于一个sentence B token。
  

• 什么是 token type IDs?
  
• position_ids (torch.LongTensor of shape (reader_beam_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  什么是 position IDs?
  
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：

• 1 表示头部未被屏蔽，
  
• 0 表示头部被屏蔽。
  

• inputs_embeds (torch.FloatTensor of shape (reader_beam_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  
• relevance_score (torch.FloatTensor of shape (searcher_beam_size,), optional) — 相关性分数，如果要计算 logits 和边际对数损失，则必须指定。
  
• block_mask (torch.BoolTensor of shape (searcher_beam_size, sequence_length), optional) — 如果要计算 logits 和边际对数损失，则必须指定证据块的掩码。
  
• start_positions (torch.LongTensor of shape (searcher_beam_size,), optional) — 用于计算标记跨度开始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。
  
• end_positions (torch.LongTensor of shape (searcher_beam_size,), optional) — 用于计算标记跨度结束位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。
  
• has_answers (torch.BoolTensor of shape (searcher_beam_size,), optional) — 证据块是否有答案。
  

返回

transformers.models.realm.modeling_realm.RealmReaderOutput或tuple(torch.FloatTensor)

一个transformers.models.realm.modeling_realm.RealmReaderOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（RealmConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供start_positions、end_positions、has_answers时返回) — 总损失。
  
• retriever_loss (torch.FloatTensor of shape (1,), optional, 当提供start_positions、end_positions、has_answers时返回) — 检索器损失。
  
• reader_loss (torch.FloatTensor of shape (1,), optional, 当提供start_positions、end_positions、has_answers时返回) — 读者损失。
  
• retriever_correct（形状为(config.searcher_beam_size,)的torch.BoolTensor，可选）- 证据块是否包含答案。
  
• reader_correct（形状为(config.reader_beam_size, num_candidates)的torch.BoolTensor，可选）- 跨度候选是否包含答案。
  
• block_idx（形状为()的torch.LongTensor）- 预测答案最有可能出现的检索证据块的索引。
  
• candidate（形状为()的torch.LongTensor）- 预测答案最有可能出现的检索范围候选的索引。
  
• start_pos（形状为()的torch.IntTensor）- RealmReader输入中预测答案的起始位置。
  
• end_pos（形状为()的torch.IntTensor）- RealmReader输入中预测答案的结束位置。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。
  模型在每一层输出的隐藏状态以及初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

RealmReader 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

RealmForOpenQA

class transformers.RealmForOpenQA

<来源>

( config retriever = None )

参数

• config（RealmConfig）- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

用于端到端开放域问答的RealmForOpenQA。该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

block_embedding_to

<来源>

( device )

参数

• device（str或torch.device）- 将self.block_emb发送到的设备。

将self.block_emb发送到特定设备。

forward

<来源>

( input_ids: Optional attention_mask: Optional = None token_type_ids: Optional = None answer_ids: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.realm.modeling_realm.RealmForOpenQAOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(1, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(1, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 对于未被屏蔽的令牌为 1，
  
• 对于被屏蔽的令牌为 0。
  

• 注意力掩码是什么？
  
• token_type_ids（形状为(1, sequence_length)的torch.LongTensor，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记，
  
• 1 对应于句子 B标记（按设计不应在此模型中使用）。
  

• 令牌类型 ID 是什么？
  
• answer_ids（形状为(num_answers, answer_length)的list，可选）- 用于计算边际对数似然损失的答案 ID。索引应在[-1, 0, ..., config.vocab_size]中（参见input_ids文档字符串）索引设置为-1的令牌将被忽略（屏蔽），损失仅计算具有标签在[0, ..., config.vocab_size]中的令牌
  
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.models.realm.modeling_realm.RealmForOpenQAOutput或tuple(torch.FloatTensor)

一个transformers.models.realm.modeling_realm.RealmForOpenQAOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（RealmConfig）和输入的不同元素。

• reader_output（dict）- 读者输出。
  
• predicted_answer_ids（形状为(answer_sequence_length)的torch.LongTensor）- 预测的答案 ID。
  

RealmForOpenQA 的前向方法，覆盖__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> import torch
>>> from transformers import RealmForOpenQA, RealmRetriever, AutoTokenizer
>>> retriever = RealmRetriever.from_pretrained("google/realm-orqa-nq-openqa")
>>> tokenizer = AutoTokenizer.from_pretrained("google/realm-orqa-nq-openqa")
>>> model = RealmForOpenQA.from_pretrained("google/realm-orqa-nq-openqa", retriever=retriever)
>>> question = "Who is the pioneer in modern computer science?"
>>> question_ids = tokenizer([question], return_tensors="pt")
>>> answer_ids = tokenizer(
...     ["alan mathison turing"],
...     add_special_tokens=False,
...     return_token_type_ids=False,
...     return_attention_mask=False,
... ).input_ids
>>> reader_output, predicted_answer_ids = model(**question_ids, answer_ids=answer_ids, return_dict=False)
>>> predicted_answer = tokenizer.decode(predicted_answer_ids)
>>> loss = reader_output.loss

Reformer

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/reformer

概述

Reformer 模型是由 Nikita Kitaev，Łukasz Kaiser，Anselm Levskaya 在论文Reformer: The Efficient Transformer中提出的。

论文的摘要如下：

大型 Transformer  模型通常在许多任务上取得最先进的结果，但训练这些模型可能成本过高，特别是在长序列上。我们引入了两种技术来提高 Transformer  的效率。首先，我们通过使用局部敏感哈希来替换点积注意力，将其复杂度从 O(L²)改为 O(Llog(L))，其中 L  是序列的长度。此外，我们使用可逆残差层而不是标准残差，这允许在训练过程中仅存储激活一次，而不是 N 次，其中 N 是层数。结果模型  Reformer 在与 Transformer 模型相媲美的同时，内存效率更高，在长序列上速度更快。

此模型由patrickvonplaten贡献。作者的代码可以在这里找到。

使用提示

• 由于 PyTorch 中的一个错误，Reformer 不与 torch.nn.DataParallel 一起工作，请参阅问题＃36035。
  
• 使用轴向位置编码（有关更多详细信息，请参见下文）。这是一种通过将其分解为较小的矩阵来避免具有巨大位置编码矩阵（当序列长度非常大时）的机制。
  
• 通过 LSH（局部敏感哈希）注意力替换传统的注意力（有关更多详细信息，请参见下文）。这是一种避免在注意力层中计算完整的查询-键乘积的技术。
  
• 通过使用可逆 Transformer 层避免存储每层的中间结果，可以在反向传播过程中获取这些结果（从下一层的输入中减去残差即可获得它们），或者在给定层内重新计算结果（不如存储它们高效，但可以节省内存）。
  
• 按块计算前向操作，而不是整个批次。
  

轴向位置编码

轴向位置编码首次在 Google 的 trax 库中实现，并由该模型论文的作者开发。在处理非常长的输入序列的模型中，传统的位置 id  编码会为每个位置 i,…,ns存储一个大小为 d 的嵌入向量，其中 ns为  config.max_embedding_size。这意味着当序列长度为 ns=219≈0.5M，而 config.hidden_size 为  d=210≈1000 时，将得到一个位置编码矩阵：Xi,j，其中 i∈[1,…,d]，j∈[1,…,ns]

其中单独有超过 500M 个参数需要存储。轴向位置编码将 Xi,j 分解为两个矩阵：Xi,j1，其中 i∈[1,…,d1]，j∈[1,…,ns1]

和 Xi,j2，其中 i∈[1,…,d2]，且 j∈[1,…,ns2]

因此，以下成立：

Xi,j = {Xi,k1，如果 i < d1，且 k = j mod ns1Xi−d1,l2，如果 i ≥ d1，且 l = ⌊j/ns1⌋}

直观地，这意味着位置嵌入向量 xj∈Rd 现在是两个分解嵌入向量的组合：xk,l1+xl,k2，其中config.max_embedding_size维度 j 被分解为 k 和 l。这种设计确保每个位置嵌入向量 xj 是唯一的。

再次使用上面的示例，轴向位置编码与 d1=29，d2=29，ns1=29，ns2=210 可以将参数数量从 500,000,000 大幅减少到 218+219≈780,000 个参数，这意味着内存使用减少了 85%。

在实践中，参数config.axial_pos_embds_dim设置为一个元组(d1, d2)，其总和必须等于config.hidden_size，而config.axial_pos_shape设置为一个元组(ns1, ns2)，其乘积必须等于config.max_embedding_size，在训练期间必须等于input_ids的序列长度。

LSH 自注意力

在局部敏感哈希（LSH）自注意力中，键和查询投影权重是绑定的。因此，键查询嵌入向量也是绑定的。LSH 自注意力使用了角距离的实用和最优 LSH中提出的局部敏感哈希机制，将这些绑定的键查询嵌入向量分配给config.num_buckets可能的桶之一。前提是，键查询嵌入向量（按余弦相似度）越“相似”，它们被分配到同一个桶的可能性就越大。

LSH 机制的准确性可以通过增加config.num_hashes或直接增加前向函数的参数num_hashes来提高，以便 LSH 自注意力的输出更好地逼近“正常”完全自注意力的输出。然后桶被排序并分块成查询键嵌入向量块，每个块的长度为config.lsh_chunk_length。对于每个块，查询嵌入向量会关注其键向量（它们与自身相连）以及config.lsh_num_chunks_before之前相邻块和config.lsh_num_chunks_after之后相邻块的键嵌入向量。

有关更多信息，请参阅原始论文或这篇很棒的博客文章。

请注意，config.num_buckets也可以分解为一个列表(nbuckets1,nbuckets2)(n_{\text{buckets}}¹,   n_{\text{buckets}}²)(nbuckets1,nbuckets2)。这样，与其将查询键嵌入向量分配给(1,…,nbuckets)(1,\ldots,   n_{\text{buckets}})(1,…,nbuckets)中的一个，它们被分配给(1−1,…,nbuckets1−1,…,1−nbuckets2,…,nbuckets1−nbuckets2)(1-1,\ldots,  n_{\text{buckets}}¹-1, \ldots, 1-n_{\text{buckets}}², \ldots,  n_{\text{buckets}}¹-n_{\text{buckets}}²)(1−1,…,nbuckets1−1,…,1−nbuckets2,…,nbuckets1−nbuckets2)。这对于非常长的序列来说非常重要，可以节省内存。

在从头开始训练模型时，建议将config.num_buckets=None，这样根据序列长度会动态计算出一个好的num_buckets值。然后这个值会自动保存在配置中，并应该在推断中重复使用。

使用 LSH 自注意力，查询-键乘法操作的内存和时间复杂度可以从O(ns×ns)\mathcal{O}(n_s \times  n_s)O(ns×ns)减少到O(ns×log⁡(ns))\mathcal{O}(n_s \times  \log(n_s))O(ns×log(ns))，这通常代表了变压器模型中的内存和时间瓶颈，其中nsn_sns是序列长度。

本地自注意力

局部自注意力本质上是一个“普通”的自注意力层，具有键、查询和值投影，但被分块处理，以便在每个长度为config.local_chunk_length的块中，查询嵌入向量只关注其块中的键嵌入向量以及config.local_num_chunks_before之前相邻块和config.local_num_chunks_after之后相邻块的键嵌入向量。

使用局部自注意力，查询-键乘法操作的内存和时间复杂度可以从O(ns×ns)\mathcal{O}(n_s \times  n_s)O(ns×ns)减少到O(ns×log⁡(ns))\mathcal{O}(n_s \times  \log(n_s))O(ns×log(ns)，这通常代表了变压器模型中的内存和时间瓶颈，其中nsn_sns是序列长度。

训练

在训练过程中，我们必须确保序列长度设置为可以被config.lsh_chunk_length和config.local_chunk_length的最小公倍数整除，并且 Axial Positional Encodings 的参数设置正确如上所述。Reformer 非常节省内存，因此模型可以轻松地在长达 64000 个标记的序列上进行训练。

在训练时，应该使用 ReformerModelWithLMHead 如下所示：

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

资源

• 文本分类任务指南
  
• 问答任务指南
  
• 因果语言建模任务指南
  
• 掩码语言建模任务指南

Transformers 4.37 中文文档（五十四）（3）https://developer.aliyun.com/article/1565375