Transformers documentation

RWKV

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2023-05-09 贡献至 Hugging Face Transformers。

RWKV

概述

RWKV 模型(版本 4)在此仓库中提出

它建议对传统 Transformer 注意力机制进行微调,使其变为线性。这样一来,该模型就可以作为循环网络使用:同时传入时间戳 0 和时间戳 1 的输入,与先传入时间戳 0 的输入、再传入时间戳 1 的输入以及时间戳 0 的状态是等价的(参见下方示例)。

这比常规 Transformer 更高效,并且可以处理任意长度的句子(即使模型在训练时使用了固定的上下文长度)。

该模型由 sgugger 贡献。 原始代码可在此处找到。

使用示例

import torch

from transformers import AutoTokenizer, RwkvModel


model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")

inputs = tokenizer("This is an example.", return_tensors="pt").to(model.device)
# 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.Tensor, **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

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 50277context_length: int = 1024hidden_size: int = 4096num_hidden_layers: int = 32attention_hidden_size: int | None = Noneintermediate_size: int | None = Nonelayer_norm_epsilon: float = 1e-05bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 0rescale_every: int = 6tie_word_embeddings: bool = Falseuse_cache: bool = True )

参数

  • vocab_size (int,可选,默认为 50277) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • context_length (int,可选,默认值为 1024) — 该模型在单次前向传播中可使用的最大序列长度(在 RNN 模式下使用时,可以使用任意序列长度)。
  • hidden_size (int,可选,默认为 4096) — 隐藏表示的维度。
  • num_hidden_layers (int,可选,默认为 32) — Transformer 解码器中的隐藏层数量。
  • attention_hidden_size (int, 可选) — 注意力隐藏状态的维度。如果未设置,则默认为 hidden_size。
  • intermediate_size (int,可选) — MLP 表示的维度。
  • layer_norm_epsilon (float,可选,默认为 1e-05) — 层归一化层所使用的 epsilon 值。
  • bos_token_id (int,可选,默认为 0) — 词汇表中用于表示流起始的 Token id。
  • eos_token_id (Union[int, list[int]],可选,默认为 0) — 词汇表中用于表示流结束(end-of-stream)的 token id。
  • rescale_every (int,可选,默认为 6) — 在推理阶段,每经过 rescale_every 层,隐藏状态(以及对应输出层的权重)都会除以 2。如果设置为 0 或负数,则不进行重新缩放。
  • tie_word_embeddings (bool,可选,默认为 False) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
  • use_cache (bool,可选,默认为 True) — 模型是否应返回最后一次键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。

这是用于存储 RwkvModel 配置的类。它根据指定的参数实例化 Rwkv 模型,并定义模型架构。使用默认值实例化配置将生成与 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: RwkvConfig )

参数

  • config (RwkvConfig) — 模型的配置类,包含模型的所有参数。使用配置文件进行初始化时,不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

原始的 Rwkv 模型,输出原始隐藏状态,顶部未添加任何特定的头。

该模型继承自 PreTrainedModel。请查阅父类文档,了解该库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用,有关通用用法和行为的所有事项,请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestate: list[torch.Tensor] | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → RwkvOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length 如果 past_key_values 为 None 否则 past_key_values.get_seq_length() (sequence_length 输入序列中各 token 在词表中的索引。

    如果使用了 past_key_values,则只需将尚未计算其过去状态的 input_ids 作为 input_ids 传入。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ,可选) — 用于避免对填充(padding)标记索引执行注意力机制的掩码。掩码值取自 [0, 1]:1 表示未屏蔽的标记,0 表示被屏蔽的标记。什么是注意力掩码? [0, 1]:
    • 1 表示未被屏蔽的 token,
    • 对于被掩码的 token,值为 0。

    什么是注意力掩码?

  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • state (tuple,包含五个形状为 (batch_size, hidden_size, num_hidden_layers) 的 torch.Tensor,可选) — 如果传入该参数,模型将在所有块中使用之前的状态(这将使模型输出针对提供的 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 而不是普通元组。

返回值

RwkvOutput 或 tuple(torch.Tensor)

RwkvOutput 或 torch.Tensor 元组(当传入 return_dict=False 或 config.return_dict=False 时),其包含的元素取决于配置(RwkvConfig)和输入。

RwkvModel 的 forward 方法重写了 __call__ 特殊方法。

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

  • last_hidden_state(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选)— 模型最后一层输出的隐藏状态序列。

  • state(五个形状为 (batch_size, hidden_size, num_hidden_layers) 的 torch.Tensor 组成的 list)— 模型在最后一个时间步的状态。可以在前向方法中与下一个 input_ids 一起使用,以避免提供旧的 input_ids。

  • 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 之后的权重,用于在自注意力头中计算加权平均值。

RwkvLMHeadModel

类 transformers.RwkvForCausalLM

< >

( config: RwkvConfig )

参数

  • config (RwkvConfig) — 模型的配置类,包含模型的所有参数。使用配置文件进行初始化时,不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

RWKV 模型,顶部带有语言建模头(一个线性层,其权重与输入嵌入共享)。

该模型继承自 PreTrainedModel。请查阅父类文档,了解该库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用,有关通用用法和行为的所有事项,请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestate: list[torch.Tensor] | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → RwkvCausalLMOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length 如果 past_key_values 为 None 否则 past_key_values.get_seq_length() (sequence_length 输入序列中各 token 在词表中的索引。

    如果使用了 past_key_values,则只需将尚未计算其过去状态的 input_ids 作为 input_ids 传入。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ,可选) — 用于避免对填充(padding)标记索引执行注意力机制的掩码。掩码值取自 [0, 1]:1 表示未屏蔽的标记,0 表示被屏蔽的标记。什么是注意力掩码? [0, 1]:
    • 1 表示未被屏蔽的 token,
    • 对于被掩码的 token,值为 0。

    什么是注意力掩码?

  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • state (tuple,包含五个形状为 (batch_size, hidden_size, num_hidden_layers) 的 torch.Tensor,可选) — 如果传入该参数,模型将在所有块中使用之前的状态(这将使模型输出针对提供的 input_ids 的结果,就好像模型将 state_input_ids + input_ids 作为上下文添加一样)。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length),可选) — 用于语言建模的标签。请注意,模型内部会对标签进行移位,因此您可以设置 labels = input_ids 索引的取值范围为 [-100, 0, ..., config.vocab_size] 所有设置为 -100 的标签都会被忽略(即被掩码),损失仅针对 [0, ..., config.vocab_size] 范围内的标签进行计算
  • use_cache (bool,可选) — 如果设置为 True,将返回最后的状态,可用于快速生成下一个 logits。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量中的 attentions。
  • output_hidden_states (bool,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • logits_to_keep (Union[int, torch.Tensor], 可选,默认为 0) — 如果为 int,则计算最后 logits_to_keep 个 token 的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成过程只需要最后一个 token 的 logits,仅针对该 token 进行计算可以节省内存,对于长序列或大词汇量而言,这种节省相当显著。 如果为 torch.Tensor,则必须是一维张量,对应于序列长度维度中需要保留的索引。 这在使用打包张量格式(将批次和序列长度合并为单一维度)时非常有用。

返回值

RwkvCausalLMOutput 或 tuple(torch.Tensor)

RwkvCausalLMOutput 或 torch.Tensor 元组(当传入 return_dict=False 或 config.return_dict=False 时),其包含的元素取决于配置(RwkvConfig)和输入。

RwkvForCausalLM 的 forward 方法重写了 __call__ 特殊方法。

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

  • loss (torch.Tensor,形状为 (1,),可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits(形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor)— 语言建模头的预测分数(SoftMax 之前每个词汇表 token 的分数)。

  • state(五个形状为 (batch_size, hidden_size, num_hidden_layers) 的 torch.Tensor 组成的 list)— 模型在最后一个时间步的状态。可以在前向方法中与下一个 input_ids 一起使用,以避免提供旧的 input_ids。

  • 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 之后的权重,用于在自注意力头中计算加权平均值。

示例:

Rwkv 注意力机制与循环公式

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

其中 $Q$、 KK 和 VV 是形状为 seq_len x hidden_size 的矩阵,分别称为查询(query)、键(key)和值(value)(它们实际上是包含批次维度和注意力头维度的更大矩阵,但我们只关注最后两个维度,因为矩阵乘法是在这两个维度上进行的,所以为了简洁起见,我们只考虑这两个维度)。乘积 QKTQK^{T} 的形状为 seq_len x seq_len ,我们可以将其与 VV 进行矩阵乘法,得到形状与其他矩阵相同的输出 OO 。

用 softmax 的值替换 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}}}

请注意, QKTQK^{T} 中对应于 $j > i$ 的条目会被屏蔽(求和到 j 为止),因为注意力机制不允许查看未来的 token(只能查看过去的 token)。

相比之下,RWKV 的注意力机制由以下公式给出 Oi=σ(Ri)∑j=1ieWi−j+KjVj∑j=1ieWi−j+KjO_{i} = \sigma(R_{i}) \frac{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}} V_{j}}{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}}}

其中 RR 是作者提出的一个新矩阵,称为 receptance, KK 而 VV 仍然是键和值(此处的 $\sigma$ 为 sigmoid 函数)。 WW 是一个表示 token 位置的新向量,其定义为 W0=u and Wk=(k−1)w for k≥1W_{0} = u \hbox{ and } W_{k} = (k-1)w \hbox{ for } k \geq 1

其中 uu 和 ww 是代码中分别称为 time_first 和 time_decay 的可学习参数。分子和分母都可以用递归形式表示。将它们命名为 NiN_{i} 和 DiD_{i} ,我们有: Ni=eu+KiVi+N^i where N^i=eKi−1Vi−1+ew+Ki−2Vi−2⋯+e(i−2)w+K1V1N_{i} = e^{u + K_{i}} V_{i} + \hat{N}_{i} \hbox{ where } \hat{N}_{i} = e^{K_{i-1}} V_{i-1} + e^{w + K_{i-2}} V_{i-2} \cdots + e^{(i-2)w + K_{1}} V_{1}

因此 N^i\hat{N}_{i} ((在代码中称为 numerator_state )满足 N^0=0 and N^j+1=eKjVj+ewN^j\hat{N}_{0} = 0 \hbox{ and } \hat{N}_{j+1} = e^{K_{j}} V_{j} + e^{w} \hat{N}_{j}

以及 Di=eu+Ki+D^i where D^i=eKi−1+ew+Ki−2⋯+e(i−2)w+K1D_{i} = e^{u + K_{i}} + \hat{D}_{i} \hbox{ where } \hat{D}_{i} = e^{K_{i-1}} + e^{w + K_{i-2}} \cdots + e^{(i-2)w + K_{1}}

因此 D^i\hat{D}_{i} ((在代码中称为 denominator_state )满足 D^0=0 and D^j+1=eKj+ewD^j\hat{D}_{0} = 0 \hbox{ and } \hat{D}_{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j}

实际使用的递推公式稍微复杂一些,因为出于数值稳定性的考虑,我们不希望计算大数的指数。通常,softmax 不会直接计算,而是将最大项的指数从分子和分母中同时除以: exi∑j=1nexj=exi−M∑j=1nexj−M\frac{e^{x_{i}}}{\sum_{j=1}^{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}}

其中 MM 是所有 $x_{j}$ 的最大值。因此,除了保存分子状态($\hat{N}$)和分母状态($\hat{D}$)之外,我们还跟踪指数中遇到的所有项的最大值。因此,我们实际使用的是 N~i=e−MiN^i and D~i=e−MiD^i\tilde{N}_{i} = e^{-M_{i}} \hat{N}_{i} \hbox{ and } \tilde{D}_{i} = e^{-M_{i}} \hat{D}_{i}

由以下递推公式定义: N~0=0 and N~j+1=eKj−qVj+ew+Mj−qN~j where q=max⁡(Kj,w+Mj)\tilde{N}_{0} = 0 \hbox{ and } \tilde{N}_{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})

且 D~0=0 and D~j+1=eKj−q+ew+Mj−qD~j where q=max⁡(Kj,w+Mj)\tilde{D}_{0} = 0 \hbox{ and } \tilde{D}_{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})

且 $M_{j+1} = q$。有了这些,我们便可以计算 Ni=eu+Ki−qVi+eMiN~i where q=max⁡(u+Ki,Mi)N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})

以及 Di=eu+Ki−q+eMiD~i where q=max⁡(u+Ki,Mi)D_{i} = e^{u + K_{i} - q} + e^{M_{i}} \tilde{D}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})

最终得到 Oi=σ(Ri)NiDiO_{i} = \sigma(R_{i}) \frac{N_{i}}{D_{i}}

Update on GitHub