# RWKV

## 概述

RWKV 模型（版本 4）在[此仓库](https://github.com/BlinkDL/RWKV-LM)中提出

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

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

该模型由 [sgugger](https://huggingface.co/sgugger) 贡献。原始代码可在[此处](https://github.com/BlinkDL/RWKV-LM)找到。

## 使用示例

```python
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'` 时停止生成，我们建议使用以下停止条件：

```python
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()])
```

## 备注

- 在批量生成时使用左侧填充。请参阅 [填充侧](../llm_tutorial#padding-side)。

## RwkvConfig[[transformers.RwkvConfig]]

#### transformers.RwkvConfig[[transformers.RwkvConfig]]

```python
transformers.RwkvConfig(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, vocab_size: int = 50277, context_length: int = 1024, hidden_size: int = 4096, num_hidden_layers: int = 32, attention_hidden_size: int | None = None, intermediate_size: int | None = None, layer_norm_epsilon: float = 1e-05, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 0, rescale_every: int = 6, tie_word_embeddings: bool = False, use_cache: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rwkv/configuration_rwkv.py#L25)

**参数：**

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](https://huggingface.co/RWKV/rwkv-4-169m-pile) 类似的配置。

配置对象继承自 [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 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[[transformers.RwkvModel]]

#### transformers.RwkvModel[[transformers.RwkvModel]]

```python
transformers.RwkvModel(config: RwkvConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rwkv/modeling_rwkv.py#L487)

**参数：**

config ([RwkvConfig](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.RwkvConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

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

该模型继承自 [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.RwkvModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, state: list[torch.Tensor] | None = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rwkv/modeling_rwkv.py#L508)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, input_ids_length)`) : `input_ids_length` = `sequence_length`（如果 `past_key_values` 为 `None`），否则为 `past_key_values.get_seq_length()`（输入 past key value 状态的 `sequence_length`）。输入序列中各个 token 在词汇表中的索引。如果使用了 `past_key_values`，则只需将尚未计算其 past 的 `input_ids` 作为 `input_ids` 传入。可以使用 [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__)。[什么是 input IDs？](../glossary#input-ids)

attention_mask (`torch.LongTensor`，形状为 `(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` 索引转换为对应的向量，这将非常有用。

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](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** `RwkvOutput` 或 `tuple(torch.Tensor)`

`RwkvOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[RwkvConfig](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.RwkvConfig)）和输入。

[RwkvModel](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.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]]

#### transformers.RwkvForCausalLM[[transformers.RwkvForCausalLM]]

```python
transformers.RwkvForCausalLM(config: RwkvConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rwkv/modeling_rwkv.py#L667)

**参数：**

config ([RwkvConfig](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.RwkvConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

带有语言建模头（线性层，其权重与输入嵌入共享）的 RWKV Model 变换器。

该模型继承自 [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.RwkvForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, state: list[torch.Tensor] | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rwkv/modeling_rwkv.py#L684)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, input_ids_length)`) : `input_ids_length` = `sequence_length`（如果 `past_key_values` 为 `None`），否则为 `past_key_values.get_seq_length()`（输入 past key value 状态的 `sequence_length`）。输入序列中各个 token 在词汇表中的索引。如果使用了 `past_key_values`，则只需将尚未计算其 past 的 `input_ids` 作为 `input_ids` 传入。可以使用 [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__)。[什么是 input IDs？](../glossary#input-ids)

attention_mask (`torch.LongTensor`，形状为 `(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` 索引转换为对应的向量，这将非常有用。

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](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.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](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.RwkvConfig)）和输入。

[RwkvForCausalLM](/docs/transformers/v5.23.0/zh/model_doc/rwkv#transformers.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 后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

```python
```

## Rwkv 注意力机制与循环公式

在传统的自回归 Transformer 中，注意力机制被表示为

$$O = \hbox{softmax}(QK^{T} / \sqrt{d}) V$$

其中 $Q$、$K$ 和 $V$ 是形状为 `seq_len x hidden_size` 的矩阵，分别称为查询（query）、键（key）和值（value）（它们实际上是带有批次维度和注意力头维度的更大矩阵，但我们只关注最后两个维度，因为矩阵乘法是在这两个维度上进行的，所以为了简洁起见，我们只考虑这两个维度）。那么乘积 $QK^{T}$ 的形状为 `seq_len x seq_len`，我们可以将其与 $V$ 进行矩阵乘法，得到与其他矩阵形状相同的输出 $O$。

用 softmax 的值替换它，得到：

$$O_{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}}}$$

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

相比之下，RWKV 注意力由以下公式给出

$$O_{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}}}$$

其中 $R$ 是作者提出的一个新矩阵，称为 receptance（响应度），$K$ 和 $V$ 仍然是键和值（此处的 $\sigma$ 为 sigmoid 函数）。$W$ 是一个表示 token 位置的新向量，其定义为

$$W_{0} = u \hbox{ 且 } W_{k} = (k-1)w \hbox{ 当 } k \geq 1$$

其中 $u$ 和 $w$ 是可学习参数，在代码中分别称为 `time_first` 和 `time_decay`。分子和分母都可以用递归方式表示。将它们命名为 $N_{i}$ 和 $D_{i}$，则有：

$$N_{i} = e^{u + K_{i}} V_{i} + \hat{N}_{i} \hbox{ 其中 } \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}$$

因此 `numerator_state`（代码中称为 `numerator_state`）满足

$$\hat{N}_{0} = 0 \hbox{  且  } \hat{N}_{j+1} = e^{K_{j}} V_{j} + e^{w} \hat{N}_{j}$$

和

$$D_{i} = e^{u + K_{i}} + \hat{D}_{i} \hbox{ 其中 } \hat{D}_{i} = e^{K_{i-1}} + e^{w + K_{i-2}} \cdots + e^{(i-2)w + K_{1}}$$

因此 `denominator_state`（代码中称为 `denominator_state`）满足

$$\hat{D}_{0} = 0 \hbox{  且  } \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$ 为所有 $x_{j}$ 中的最大值。因此，在这里除了保存分子状态（$\hat{N}$）和分母状态（$\hat{D}$）之外，我们还会跟踪指数中出现的所有项的最大值。因此，我们实际使用的是

$$\tilde{N}_{i} = e^{-M_{i}} \hat{N}_{i} \hbox{  且  } \tilde{D}_{i} = e^{-M_{i}} \hat{D}_{i}$$

由以下递推公式定义：

$$\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})$$

和

$$\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})$$

且 $M_{j+1} = q$。有了这些，我们便可以计算

$$N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}_{i} \hbox{  其中  } q = \max(u + K_{i}, M_{i})$$

和

$$D_{i} = e^{u + K_{i} - q} + e^{M_{i}} \tilde{D}_{i} \hbox{  其中  } q = \max(u + K_{i}, M_{i})$$

最终得到

$$O_{i} = \sigma(R_{i}) \frac{N_{i}}{D_{i}}$$

