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

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

RealmScorer

`class transformers.RealmScorer`

`forward`

RealmKnowledgeAugEncoder

`class transformers.RealmKnowledgeAugEncoder`

`forward`

RealmReader

`class transformers.RealmReader`

`forward`

RealmForOpenQA

`class transformers.RealmForOpenQA`

`block_embedding_to`

`forward`

Reformer

概述

使用提示

轴向位置编码

LSH 自注意力

本地自注意力

训练

资源

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

RealmScorer

class transformers.RealmScorer

forward

RealmKnowledgeAugEncoder

class transformers.RealmKnowledgeAugEncoder

forward

RealmReader

class transformers.RealmReader

forward

RealmForOpenQA

class transformers.RealmForOpenQA

block_embedding_to

forward

Reformer

概述

使用提示

轴向位置编码

LSH 自注意力

本地自注意力

训练

资源

热门文章

最新文章

相关电子书

`class transformers.RealmScorer`

`forward`

`class transformers.RealmKnowledgeAugEncoder`

`forward`

`class transformers.RealmReader`

`forward`

`class transformers.RealmForOpenQA`

`block_embedding_to`

`forward`