Transformers 4.37 中文文档（五十八）（1）

原文：huggingface.co/docs/transformers

RWKV

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/rwkv

概述

RWKV 模型是在此存储库中提出的。

它建议对传统 Transformer 注意力进行微调，使其线性化。这样，模型可以用作循环网络：同时传递时间戳 0 和时间戳 1 的输入与在时间戳 0 传递输入，然后在时间戳 1 传递输入以及时间戳 0 的状态是相同的（见下面的示例）。

这比常规 Transformer 更有效，并且可以处理任意长度的句子（即使模型在训练时使用固定的上下文长度）。

这个模型是由sgugger贡献的。原始代码可以在这里找到。

用法示例

import torch
from transformers import AutoTokenizer, RwkvConfig, RwkvModel
model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")
inputs = tokenizer("This is an example.", return_tensors="pt")
# Feed everything to the model
outputs = model(inputs["input_ids"])
output_whole = outputs.last_hidden_state
outputs = model(inputs["input_ids"][:, :2])
output_one = outputs.last_hidden_state
# Using the state computed on the first inputs, we will get the same output
outputs = model(inputs["input_ids"][:, 2:], state=outputs.state)
output_two = outputs.last_hidden_state
torch.allclose(torch.cat([output_one, output_two], dim=1), output_whole, atol=1e-5)

如果要确保模型在检测到'\n\n'时停止生成，我们建议使用以下停止标准：

from transformers import StoppingCriteria
class RwkvStoppingCriteria(StoppingCriteria):
    def __init__(self, eos_sequence = [187,187], eos_token_id = 537):
        self.eos_sequence = eos_sequence
        self.eos_token_id = eos_token_id
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
        last_2_ids = input_ids[:,-2:].tolist()
        return self.eos_sequence in last_2_ids
output = model.generate(inputs["input_ids"], max_new_tokens=64, stopping_criteria = [RwkvStoppingCriteria()])

RwkvConfig

class transformers.RwkvConfig

<来源>

( vocab_size = 50277 context_length = 1024 hidden_size = 4096 num_hidden_layers = 32 attention_hidden_size = None intermediate_size = None layer_norm_epsilon = 1e-05 bos_token_id = 0 eos_token_id = 0 rescale_every = 6 tie_word_embeddings = False use_cache = True **kwargs )

参数

• vocab_size (int，可选，默认为 50277) — RWKV 模型的词汇量。定义了在调用 RwkvModel 时可以表示的不同标记数量。
  
• context_length (int，可选，默认为 1024) — 此模型可以在单个前向传播中使用的最大序列长度（在 RNN 模式中使用任何序列长度）。
  
• hidden_size (int，可选，默认为 4096) — 嵌入和隐藏状态的维度。
  
• num_hidden_layers (int，可选，默认为 32) — 模型中的隐藏层数量。
  
• attention_hidden_size (int，可选) — 注意力隐藏状态的维度。如果未设置，将默认为hidden_size。
  
• intermediate_size (int，可选) — 内部前馈层的维度。如果未设置，将默认为hidden_size的 4 倍。
  
• layer_norm_epsilon (float，可选，默认为 1e-05) — 在层归一化层中使用的 epsilon。
  
• bos_token_id (int，可选，默认为 0) — 词汇表中句子开头标记的 id。默认为 0，因为 RWKV 使用与 GPTNeoX 相同的分词器。
  
• eos_token_id (int，可选，默认为 0) — 词汇表中句子结尾标记的 id。默认为 0，因为 RWKV 使用与 GPTNeoX 相同的分词器。
  
• rescale_every (int，可选，默认为 6) — 推理时，隐藏状态（以及相应输出层的权重）每rescale_every层除以 2。如果设置为 0 或负数，则不进行重新缩放。
  
• tie_word_embeddings (bool，可选，默认为False) — 是否将单词嵌入与输入标记嵌入相结合。
  
• use_cache (bool，可选，默认为True) — 模型是否应返回最后一个状态。
  

这是存储 RwkvModel 配置的配置类。它用于根据指定的参数实例化一个 RWKV 模型，定义模型架构。使用默认值实例化配置将产生类似于 RWVK-4 RWKV/rwkv-4-169m-pile架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import RwkvConfig, RwkvModel
>>> # Initializing a Rwkv configuration
>>> configuration = RwkvConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = RwkvModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

RwkvModel

class transformers.RwkvModel

<来源>

( config )

参数

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

裸的 RWKV 模型变压器输出原始隐藏状态，没有特定的头部。

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None state: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.rwkv.modeling_rwkv.RwkvOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。
  如果使用past_key_values，则只有那些没有计算过去的input_ids应该作为input_ids传递。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(batch_size, input_ids_length)的torch.LongTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

• 对于未被“掩码”的标记为 1，
  
• 对于被“掩码”的标记为 0。
  

• 目前RwkvModel不使用这个，但将在未来支持。
  什么是注意力掩码？
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。
  
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor元组，可选）— 如果传递，模型将在所有块中使用先前的状态（这将为提供的input_ids提供输出，就好像模型将state_input_ids + input_ids作为上下文）。
  
• use_cache（bool，可选）— 如果设置为True，则返回上一个状态，并可用于快速生成下一个对数。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.models.rwkv.modeling_rwkv.RwkvOutput或tuple(torch.FloatTensor)

一个transformers.models.rwkv.modeling_rwkv.RwkvOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（RwkvConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
  
• state（形状为(batch_size, hidden_size, num_hidden_layers)的五个torch.FloatTensor列表）- 模型在最后一个时间步的状态。可以在前向方法中与下一个input_ids一起使用，以避免提供旧的input_ids。
  
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoTokenizer, RwkvModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> model = RwkvModel.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

RwkvLMHeadModel

class transformers.RwkvForCausalLM

<来源>

( config )

参数

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

带有语言建模头部的 RWKV 模型变压器（线性层，其权重与输入嵌入绑定）。

该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None state: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）- 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_length=past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。
  如果使用past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

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

• 这目前RwkvModel没有使用，但将来会支持。
  什么是注意力掩码？
  
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
  
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor元组，可选） — 如果传递，模型将在所有块中使用先前的状态（这将为提供的input_ids产生输出，就好像模型将state_input_ids + input_ids作为上下文）。
  
• use_cache (bool，可选) — 如果设置为True，则返回上一个状态，并可用于快速生成下一个 logits。
  
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
  
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩盖），损失仅计算在[0, ..., config.vocab_size]中的标签。
  

返回

transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput或tuple(torch.FloatTensor)

一个transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（RwkvConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
  
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor列表） — 模型在最后一个时间步的状态。可以在前向方法中与下一个input_ids一起使用，以避免提供旧的input_ids。
  
• 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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

例如：

>>> import torch
>>> from transformers import AutoTokenizer, RwkvForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> model = RwkvForCausalLM.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

Rwkv 注意力和循环公式

在传统的自回归 Transformer 中，注意力写为O=softmax(QKT/d)VO = \hbox{softmax}(QK^{T} / \sqrt{d}) VO=softmax(QKT/d)V

其中QQQ，KKK 和VVV 是形状为seq_len x hidden_size的矩阵，分别命名为查询、键和值（实际上它们是带有批处理维度和注意力头维度的更大矩阵，但我们只关心最后两个，这是矩阵乘积发生的地方，所以为了简单起见，我们只考虑这两个）。乘积QKTQK^{T}QKT 然后具有形状seq_len x seq_len，我们可以将其与VVV 进行矩阵乘积，得到与其他相同形状的输出OOO。

用其值替换 softmax 得到：Oi=∑j=1ieQiKjT/dVj∑j=1ieQiKjT/dO_{i} =  \frac{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}}  V_{j}}{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} /  \sqrt{d}}}Oi=∑j=1ieQiKjT/d∑j=1ieQiKjT/dVj

请注意，QKT 中与 j>i 对应的条目被屏蔽（总和在 j 处停止），因为注意力不允许查看未来的令牌（只能查看过去的令牌）。

相比之下，RWKV 注意力由 Oi = σ(Ri)（∑j=1i eWi−j + Kj Vj）/（∑j=1i eWi−j + Kj）给出。

作者称之为接受度的新矩阵 R，K 和 V 仍然是关键和值（这里σ是 Sigmoid 函数）。W 是代表令牌位置的新向量，由 W0 = u 和 Wk = (k-1)w（对于 k≥1）给出。

u 和 w 是可学习的参数，分别在代码中称为time_first和time_decay。分子和分母都可以递归表示。将它们命名为 Ni 和 Di，我们有：Ni = e^(u + Ki)Vi + N^i 其中 N^i = e^(Ki-1)Vi-1 + e^(w + Ki-2)Vi-2 + … + e^((i-2)w + K1)Vi-1

所以 N^i（在代码中称为numerator_state）满足 N⁰ = 0 和 N^j+1 = e^Kj Vj + e^w N^j

和 Di = e^(u + Ki) + D^i 其中 D^i = e^(Ki-1) + e^(w + Ki-2) + … + e^((i-2)w + K1)

因此，(\hat{D}^{i})（在代码中称为denominator_state）满足(\hat{D}{0} = 0)和(\hat{D}{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j})。

实际使用的递归公式稍微复杂一些，因为为了数值稳定性，我们不希望计算大数的指数。通常，softmax 不是按原样计算的，而是将最大项的指数除以分子和分母：(\frac{e^{{x_{i}}}{\sum_{j=1}}{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}})。

M 是所有 xj 的最大值。因此，在保存分子状态（(\hat{N})）和分母状态（(\hat{D})）的同时，我们还跟踪遇到的所有指数项的最大值。因此，我们实际上使用(\tilde{N}{i} = e^{-M{i}} \hat{N}{i})和(\tilde{D}{i} = e^{-M_{i}} \hat{D}_{i})。

根据以下递归公式定义：N~0=0 和 N~j+1=eKj−qVj+ew+Mj−qN~j 其中 q=max⁡(Kj,w+Mj)\tilde{N}{0} = 0 \hbox{ 和 } \tilde{N}{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}{j} \hbox{ 其中 } q = \max(K{j}, w + M_{j})N~0=0 和 N_{j+1=eKj−qVj+ew+Mj−qN}j 其中 q=max(Kj,w+Mj)

根据以下递归公式定义：D~0=0 和 D~j+1=eKj−q+ew+Mj−qD~j 其中 q=max⁡(Kj,w+Mj)\tilde{D}{0} = 0 \hbox{ 和 } \tilde{D}{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}{j} \hbox{ 其中 } q = \max(K{j}, w + M_{j})D~0=0 和 D_{j+1=eKj−q+ew+Mj−qD}j 其中 q=max(Kj,w+Mj)

和Mj+1=qM_{j+1} = qMj+1=q。有了这些，我们可以计算Ni=eu+Ki−qVi+eMiN~i 其中 q=max⁡(u+Ki,Mi)N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}{i} \hbox{ 其中 } q = \max(u + K{i}, M_{i})Ni=eu+Ki−qVi+eMiN~i 其中 q=max(u+Ki,Mi)

和 Di = e^(u + Ki - q) + e^Mi D~i，其中 q = max(u + Ki, Mi)

最终给出了 Oi = σ(Ri) Ni / Di

Splinter

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

概述

Splinter 模型是由 Ori Ram、Yuval Kirstain、Jonathan Berant、Amir Globerson、Omer Levy 在 Few-Shot Question Answering by Pretraining Span Selection 中提出的。Splinter 是一个仅编码器的 transformer 模型（类似于 BERT），使用包含维基百科和多伦多图书语料库的大型语料库上的循环跨度选择任务进行预训练。

该论文的摘要如下：

在几个问答基准测试中，预训练模型通过在约 100,000  个注释问题和答案上进行微调达到了人类水平。我们探索了更现实的少样本设置，在这种情况下只有几百个训练示例可用，并观察到标准模型表现不佳，突显了当前预训练目标和问答之间的差异。我们提出了一种针对问答定制的新的预训练方案：循环跨度选择。给定一个包含多组循环跨度的段落，我们在每组中屏蔽所有循环跨度，然后要求模型为每个屏蔽的跨度在段落中选择正确的跨度。屏蔽的跨度将被一个特殊  token 替换，被视为问题表示，稍后在微调过程中用于选择答案跨度。结果模型在多个基准测试中获得了令人惊讶的好结果（例如，在只有 128  个训练示例的情况下，在 SQuAD 上达到了 72.7 的 F1 分数），同时在高资源设置中保持了竞争性能。

这个模型由 yuvalkirstain 和 oriram 贡献。原始代码可以在 这里 找到。

使用提示

• Splinter 被训练来预测在特定 [QUESTION] token 条件下的答案跨度。这些 token 用于上下文化问题表示，用于预测答案。这一层被称为 QASS，并且是 SplinterForQuestionAnswering 类中的默认行为。因此：
  
• 使用 SplinterTokenizer（而不是 BertTokenizer），因为它已经包含了这个特殊 token。此外，当给定两个序列时（例如在 run_qa.py 脚本中），其默认行为是使用这个 token。
  
• 如果您计划在 run_qa.py 之外使用 Splinter，请记住问题 token - 这对于您的模型的成功可能很重要，特别是在少样本设置中。
  
• 请注意，每个 Splinter 大小都有两个不同的检查点。它们基本上是相同的，只是一个还具有 QASS 层的预训练权重（tau/splinter-base-qass 和 tau/splinter-large-qass），另一个没有（tau/splinter-base 和 tau/splinter-large）。这样做是为了支持在微调时随机初始化这一层，因为在某些情况下已经证明这样做可以获得更好的结果。
  

资源

• 问答任务指南

SplinterConfig

class transformers.SplinterConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 use_cache = True pad_token_id = 0 question_token_id = 104 **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — Splinter 模型的词汇大小。定义了在调用 SplinterModel 时可以表示的不同 token 数量。
  
• hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  
• num_hidden_layers (int，optional，默认为 12) — Transformer 编码器中的隐藏层数量。
  
• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
  
• intermediate_size (int，optional，默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
  
• hidden_act (str或function，optional，默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
  
• hidden_dropout_prob (float，optional，默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
  
• attention_probs_dropout_prob (float，optional，默认为 0.1) — 注意力概率的丢弃比率。
  
• max_position_embeddings (int，optional，默认为 512) — 该模型可能被使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
  
• type_vocab_size (int，optional，默认为 2) — 调用 SplinterModel 时传递的token_type_ids的词汇表大小。
  
• initializer_range (float，optional，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• layer_norm_eps (float，optional，默认为 1e-12) — 层归一化层使用的 epsilon。
  
• use_cache (bool，optional，默认为True) — 模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在config.is_decoder=True时相关。
  
• question_token_id (int，optional，默认为 104) — [QUESTION]标记的 ID。
  

这是用于存储 SplinterModel 配置的配置类。它用于根据指定的参数实例化 Splinter 模型，定义模型架构。使用默认值实例化配置将产生类似于 Splinter tau/splinter-base架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import SplinterModel, SplinterConfig
>>> # Initializing a Splinter tau/splinter-base style configuration
>>> configuration = SplinterConfig()
>>> # Initializing a model from the tau/splinter-base style configuration
>>> model = SplinterModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

Transformers 4.37 中文文档（五十八）（2）https://developer.aliyun.com/article/1565264