【pytorch】循环神经网络

• 序列信息是带顺序的数据。
• 循环神经网络可以更好地处理序列信息。它通过引入状态变量存储过去的信息和当前的输入，从而可以确定当前的输出。

1. 序列模型

• 问题模型：根据历史值$x_{t-1},\dots ,x_1$预测$x_t$的值，即
  $$x_t\sim P(x_t|x_{t-1},\dots ,x_1)$$
• 为了实现这个预测，可以使用回归模型。但存在一个主要问题：输入数据($x_{t-1},\dots ,x_1$)的数量与$t$有关，即输入数据的数量随着数据量的增加而增加。有以下2种策略可以进行近似处理：
  • 自回归模型：假设在现实情况下相当长的序列$x_{t-1},\dots ,x_1$是不必要的，我们只需要满足某个长度为$\tau$的时间跨度， 即使用观测序列$x_{t-1},\dots ,x_{t-\tau }$。这样获得的最直接的好处就是参数的数量总是不变的。
  • 隐变量自回归模型：保留一些对过去观测的总结$h_{t-1}$，并且同时更新预测${\hat{x}}_t$和总结$h_t$，即
    $${\hat{x}}_t=P(x_t|h_t),h_t=g(h_{t-1},x_{t-1})$$
    
• 如何生成训练数据？ 经典方法是使用历史观测来预测下一个未来观测。这种方法基于以下假设：虽然特定值$x_t$可能会改变， 但是序列产生逻辑不变。即
  $$P(x_1,\dots ,x_T)=\prod _{t=1}^{T}P(x_t|x_{t-1},\dots ,x_1)$$
  这种假设是合理的，因为新的序列产生逻辑一定受新的数据影响， 而我们不可能用目前所掌握的数据来预测新的序列产生逻辑。
• 如果使用$x_{t-1},\dots ,x_{t-\tau }$来估计$x_t$是近似精确的，则称序列满足马尔可夫条件。特别地，如果$\tau =1$，得到一个 一阶马尔可夫模型
  $$P(x_1,\dots ,x_T)=\prod _{t=1}^{T}P(x_t|x_{t-1}),P(x_1|x_0)=P(x_1)$$
• 当假设$x_t$仅是离散值时，可以使用动态规划沿着马尔可夫链精确地计算结果，简而言之，可以利用临近值的概率求解跨距离值的概率，由此我们只需要考虑历史临近值。比如
  $$\begin{array}{rl}P(x_{t+1}|x_{t-1})& =\frac{{\sum }_{x_t}P(x_{t+1},x_t,x_{t-1})}{P(x_{t-1})}\\ & =\frac{{\sum }_{x_t}P(x_{t+1}|x_t,x_{t-1})P(x_t,x_{t-1})}{P(x_{t-1})}\\ & =\frac{{\sum }_{x_t}P(x_{t+1}|x_t)P(x_t,x_{t-1})}{P(x_{t-1})}(马尔可夫条件)\\ & =\sum _{x_t}P(x_{t+1}|x_t)P(x_t|x_{t-1})\end{array}$$
• 在许多情况下，序列数据存在一个自然的方向，在时间上是前进的，未来的事件不能影响过去，因而序列数据具有因果性。
• 下一时间步的预测称为单步预测，下$k$时间步的预测称为k步预测。k步预测必须使用我们自己的预测（而不是原始数据）来进行，由于预测错误累积，可能会相当快地偏离真实的观测结果。因此当我们试图预测更远的未来时，一旦超过某个跨度，任何预测几乎都是无用的。

2. 文本预处理

• 文本是典型的序列数据，计算机不方便直接处理文本，需要预处理转换成方便计算机处理的数字索引序列。常见的文本预处理步骤如下：
  1. 将文本作为字符串加载到内存中。
  2. 将字符串拆分为词元（如单词和字符）。
  3. 建立一个词表，将拆分的词元映射到数字索引。
  4. 将文本转换为数字索引序列，方便模型操作。
• 收集的各种文本数据称为语料，为了方便机器处理，需要将语料中的词元替换为对应的数字索引。
  • 出现频率很低的词元通常被移除，这可以降低复杂性。
  • 不存在或已删除的任何词元都将映射到一个特定的未知词元“<unk>”
  • 可以选择增加一个列表，用于保存那些被保留的词元，如填充词元（“<pad>”）； 序列开始词元（“<bos>”）； 序列结束词元（“<eos>”）。
• 文本预处理代码实现（时间机器下载）

import re, collections

def readlines(file):
    """将UTF-8文件内容加载到文本行的列表中"""
    with open(file, "r", encoding="utf-8") as f:
        lines = f.readlines()
    # 为简单起见，忽略标点符号，并将所有字母转换为小写
    return [re.sub("[^A-Za-z]+", " ", line).strip().lower() for line in lines]


def tokenize(lines: list[str], token="word"):
    """将文本行拆分为单词或字符词元"""
    if token == "word":
        return [line.split() for line in lines]
    elif token == "char":
        return [list(line) for line in lines]
    else:
        raise Exception(f"不支持的词元类型：{token}")


class Vocab:
    """文本词表"""

    def __init__(
        self,
        tokens: list[list[str]],
        min_freq: int = 0,
        reserved_tokens: list[str] = [],
    ):
        # 按频率降序排序
        self.__token_freqs = sorted(
            self.count_tokens(tokens).items(), key=lambda x: x[1], reverse=True
        )

        self.__ordered_tokens = ["<unk>"] + reserved_tokens
        for token, freq in self.__token_freqs:
            if freq < min_freq:
                break
            if token not in self.__ordered_tokens:
                self.__ordered_tokens.append(token)

        self.__idx_of_tokens = {
            token: idx for idx, token in enumerate(self.__ordered_tokens)
        }

    def __len__(self):
        """词表大小"""
        return len(self.__ordered_tokens)

    def count_tokens(self, tokens: list[list[str]]):
        """统计词元的频率"""
        tokens = [token for line in tokens for token in line]
        return collections.Counter(tokens)

    def to_index(self, tokens: list[str] | tuple[str] | str):
        """根据词元获取索引"""
        if isinstance(tokens, str):
            return self.__idx_of_tokens.get(tokens, self.idx_of_unk)
        return [self.to_index(token) for token in tokens]

    def to_token(self, indices: list[int] | int):
        """根据索引获取词元"""
        if isinstance(indices, int):
            return self.__ordered_tokens[indices]
        return [self.__ordered_tokens[index] for index in indices]

    @property
    def idx_of_unk(self):
        """未知词元的索引"""
        return 0

    @property
    def token_freqs(self):
        """词元频率"""
        return self.__token_freqs
    
    @property
    def content(self):
        """词表内容"""
        return list(self.__idx_of_tokens.items())


def load_corpus(max_tokens: int = None):
    """加载文本训练语料"""
    lines = readlines("time_machine.txt")
    tokens = tokenize(lines, "char")
    vocab = Vocab(tokens)
    corpus = [vocab.to_index(token) for line in tokens for token in line]
    if max_tokens is not None:
        corpus = corpus[:max_tokens]
    return corpus, vocab


if __name__ == "__main__":
    corpus, vocab = load_corpus()
    print(len(corpus), len(vocab))
    print(vocab.token_freqs[:10])
    print(vocab.content[:10])

3. 语言模型

• 假设长度为$T$的文本序列中的词元依次为$x_1,x_2,\dots ,x_T$，在给定这样的文本序列时，语言模型的目标是估计序列的联合概率$$P(x_1,x_2,\dots ,x_T)$$
• 只需要一次抽取一个词元$x_t\sim P(x_t|x_{t-1},\dots ,x_1)$，即根据模型估计的概率分布抽取第一个词元$x_1$，然后基于$x_1$抽取第二个词元$x_2$，依此类推，一个理想的语言模型就能够基于模型本身生成自然文本。
• 为了训练语言模型，我们需要计算单词的概率， 以及给定前面几个单词后出现某个单词的条件概率。 这些概率本质上就是语言模型的参数。
  • 估计单词的概率可以根据给定词的相对词频来计算
  • 估计给定几个单词后出现某个单词的条件概率使用连续单词对出现频率之比的方法存在问题：连续单词对出现频率很低，很难估计条件概率。处理这种问题的常见策略是执行某种形式的拉普拉斯平滑， 具体方法是在所有计数中添加一个小常量。例如：（$n$表示训练集中单词的总数，$m$表示唯一单词的数量）
    $$\begin{array}{rl}\hat{P}(x)& =\frac{n(x)+{ϵ}_1/m}{n+{ϵ}_1}\\ \hat{P}(x^{\prime }|x)& =\frac{n(x,x^{\prime })+{ϵ}_2\hat{P}(x^{\prime })}{n+{ϵ}_2}\\ \hat{P}(x^{\prime \prime }|x,x^{\prime })& =\frac{n(x,x^{\prime },x^{\prime \prime })+{ϵ}_3\hat{P}(x^{\prime \prime })}{n+{ϵ}_3}\end{array}$$其中${ϵ}_1,{ϵ}_2,{ϵ}_3$是超参数，取值控制平滑程度。当${ϵ}_i=0$时，不应用平滑，当${ϵ}_i\to +\infty$时，$\hat{P}(x)$接近$1/m$，$\hat{P}(x^{\prime }|x)$接近$\hat{P}(x^{\prime })$，$\hat{P}(x^{\prime \prime }|x,x^{\prime })$接近$\hat{P}(x^{\prime \prime })$，即越与上下文没有关系。
    然而，这样的模型很容易变得无效：
    • 需要存储所有的计数。
    • 完全忽略了单词的意思，想根据上下文调整这类模型其实是相当困难的。
    • 长单词序列大部分是没出现过的。
• 如果$P(x_{t+1}|x_t,\dots ,x_1)=P(x_{t+1}|x_1)$，则序列上的分布满足一阶马尔可夫性质。 阶数越高，对应的依赖关系就越长。利用这种性质可以推导出许多可以应用于序列建模的近似公式：
  $$\begin{array}{rl}P(x_1,x_2,x_3,x_4)& =P(x_1)P(x_2)P(x_3)P(x_4)\\ P(x_1,x_2,x_3,x_4)& =P(x_1)P(x_2|x_1)P(x_3|x_2)P(x_4|x_3)\\ P(x_1,x_2,x_3,x_4)& =P(x_1)P(x_2|x_1)P(x_3|x_1,x_2)P(x_4|x_2,x_3)\end{array}$$通常，涉及一个、两个和三个变量的概率公式分别被称为 一元语法、二元语法和三元语法模型。

3.1. 自然语言统计

• 时间机器使用频率前十的单词

[('the', 2477),
 ('and', 1311),
 ('of', 1285),
 ('i', 1268),
 ('a', 877),
 ('to', 766),
 ('in', 605),
 ('was', 554),
 ('that', 458),
 ('it', 452)]

• 英语最流行的词看起来很无聊， 这些词通常被称为停顿词，另外词频衰减的速度相当地快，大致遵循双对数坐标图上的一条直线，即词频满足齐普夫定律
  $$n_i\propto \frac{1}{i^{\alpha }}$$这告诉我们想要通过计数统计和平滑来建模单词是不可行的， 因为这样建模的结果会大大高估尾部单词的频率，也就是所谓的不常用单词。
• 英语除了一元语法词，单词序列也遵循齐普夫定律（也就是说有高频词组和低频词组）；另外$n$元组的词表大小并没有很大，这说明语言中存在相当多的结构， 这些结构给了我们应用模型的希望。

4. 读取长序列数据

• 序列数据是连续的，可以是任意长的，因此需要拆分序列方便模型读取。我们可以指定任意偏移量作为初始位置，拆分任意时间步长度的序列（偏移量<时间步）。为了获得覆盖性和随机性，可以从随机偏移量开始划分序列，另外对于语言建模，目标是基于到目前为止我们看到的词元来预测下一个词元， 因此标签是移位了一个词元的原始序列。在此基础上有以下两种采样策略。
  • 随机采样：每个样本都是在原始的长序列上任意捕获的子序列，两个相邻的、随机的、小批量中的子序列不一定在原始序列上相邻。
  • 顺序分区：首次是随机偏移量的，后续要保证两个相邻的小批量中的子序列在原始序列上也是相邻的。

5. 循环神经网络

• 使用$n$元语法模型$P(x_t|x_{t-1},\dots ,x_{t-n+1})$，只能考虑到前$n-1$个词元的影响，如果想考虑前$n-1$个词元之前的词的影响，则需要增加$n$，由此模型参数的数量也会随之呈指数增长，因为词表需要存储$|N_x{|}^n$个词组。因而不如使用隐变量模型
  $$P(x_t|x_{t-1},\dots ,x_1)\approx P(x_t|h_{t-1})$$
  其中$h_{t-1}$是隐状态或者隐变量，它存储了到时间步$t-1$的序列信息，我们可以基于当前输入$x_t$和先前隐状态$h_{t-1}$ 来计算时间步$t$处的隐状态：
  $$h_t=f(x_t,h_{t-1})$$
• 假设我们在时间步$t$有小批量输入${\mathrm{X}}_{\mathrm{t}}\in {\mathbb{R}}^{n\times d}$，用${\mathrm{H}}_{\mathrm{t}}\in {\mathbb{R}}^{n\times h}$表示时间步$t$的隐变量，并引入新的权重参数${\mathrm{W}}_{\mathrm{hh}}\in {\mathbb{R}}^{h\times h}$来描述如何在当前时间步中使用前一个时间步的隐变量。 当前间步隐变量由当前时间步的输入与前一个时间步的隐变量一起计算得出（$\varphi$是隐藏层的激活函数，${\mathrm{W}}_{\mathrm{xh}}$是隐藏层的权重参数，${\mathrm{b}}_{\mathrm{h}}$是隐藏层的偏置参数）
  $${\mathrm{H}}_{\mathrm{t}}=\varphi ({\mathrm{X}}_{\mathrm{t}}{\mathrm{W}}_{\mathrm{xh}}+{\mathrm{H}}_{\mathrm{t}-1}{\mathrm{W}}_{\mathrm{hh}}+{\mathrm{b}}_{\mathrm{h}})$$
  从隐变量${\mathrm{H}}_{\mathrm{t}}$和${\mathrm{H}}_{\mathrm{t}-1}$的的关系可知， 这些变量捕获并保留了序列直到其当前时间步的历史信息， 就如当前时间步下神经网络的状态或记忆。由于在当前时间步中， 隐变量使用的定义与前一个时间步中使用的定义相同， 因此隐变量的计算是循环的。于是基于循环计算的隐状态神经网络被命名为循环神经网络（recurrent neural network，RNN）。 在循环神经网络中执行循环计算的层称为循环层。直接在隐藏层中添加上一时间步的隐变量是构建循环层最常见的方法。
• 时间步$t$的输出层与多层感知机类似
  $${\mathrm{O}}_{\mathrm{t}}={\mathrm{H}}_{\mathrm{t}}{\mathrm{W}}_{\mathrm{hq}}+{\mathrm{b}}_{\mathrm{q}}$$
• 循环神经网络的参数包括循环层的权重${\mathrm{W}}_{\mathrm{xh}},{\mathrm{W}}_{\mathrm{hh}}$和偏置${\mathrm{b}}_{\mathrm{h}}$以及输出层的权重${\mathrm{W}}_{\mathrm{hq}}$和偏置${\mathrm{b}}_{\mathrm{q}}$。值得一提的是，即使在不同的时间步，循环神经网络也总是使用这些模型参数。
• 隐状态中
  $${\mathrm{X}}_{\mathrm{t}}{\mathrm{W}}_{\mathrm{xh}}+{\mathrm{H}}_{\mathrm{t}-1}{\mathrm{W}}_{\mathrm{hh}}=\mathrm{cat}({\mathrm{X}}_{\mathrm{t}},{\mathrm{H}}_{\mathrm{t}-1},1)\mathrm{cat}({\mathrm{W}}_{\mathrm{xh}},{\mathrm{W}}_{\mathrm{hh}},0)$$
  即沿列（轴1）拼接矩阵${\mathrm{X}}_{\mathrm{t}}$和${\mathrm{H}}_{\mathrm{t}-1}$，沿行（轴0）拼接矩阵${\mathrm{W}}_{\mathrm{xh}}$和${\mathrm{W}}_{\mathrm{hh}}$，得到的两个矩阵再相乘与分别相乘再相加的结果相等。

6. 困惑度

• 一个更好的语言模型应该能让我们更准确地预测下一个词元。 因此，它应该允许我们在压缩序列时花费更少的比特。 所以我们可以通过一个序列中所有的$n$个词元的交叉熵损失的平均值来衡量：
  $$\frac{1}{n}\sum _{t=1}^n(-\log P(x_t|x_{t-1},\dots ,x_1))$$
  由于历史原因，自然语言处理的科学家更喜欢使用一个叫做困惑度的量，上式是它的指数
  $$\exp (\frac{1}{n}\sum _{t=1}^n(-\log P(x_t|x_{t-1},\dots ,x_1)))$$
  困惑度的最好的理解是下一个词元的实际选择数的调和平均数。
• 在最好的情况下，模型总是完美地估计标签词元的概率为1。 在这种情况下，模型的困惑度为1。
• 在最坏的情况下，模型总是预测标签词元的概率为0。 在这种情况下，困惑度是正无穷大。
• 在词元之间没有相关性的情况下，模型的预测是词表的所有可用词元上的均匀分布。 在这种情况下，困惑度等于词表中唯一词元的数量。 事实上，如果我们在没有任何压缩的情况下存储序列， 这将是我们能做的最好的编码方式。 因此，这种方式提供了一个重要的上限， 而任何实际模型都必须超越这个上限。