二. 文本预处理，语言模型，RNN

2020-02-14 本文已影响0人 copain_sir

1.文本预处理

文本是一类序列数据，一篇文章可以看作是字符或单词的序列，本节将介绍文本数据的常见预处理步骤，预处理通常包括以下步骤：

1.1读入文本

import re

def read():
    with open('data/Pride and Prejudice.txt', 'r') as f:
        lines = [re.sub('[^a-z]+', ' ', line.strip().lower()) for line in f]
    return lines

lines = read()
print('sentences %d' % len(lines))  # 4263

read函数里，全部字母变成小写，lines的每一个元素都是一个句子

1.2. 分词

对于中文分词，目前jieba分词用的比较广发，而且功能全面也更精确，具体用法参考https://www.jianshu.com/p/883c2171cdb5
我们对每个句子进行分词，也就是将一个句子划分成若干个词（token），转换为一个词的序列。

ef tokenize(sentences, token='word'):
    """Split sentences into word or char tokens"""
    if token == 'word':
        return [sentence.split(' ') for sentence in sentences]
    elif token == 'char':
        return [list(sentence) for sentence in sentences]
    else:
        print('ERROR: unkown token type '+token)

tokens = tokenize(lines)
print(tokens[4:5])

[['however', 'little', 'known', 'the', 'feelings', 'or', 'views', 'of', 'such', 'a', 'man', 'may', 'be', 'on', ...

1.3. 建立字典

将每个词映射到一个唯一的索引（index）

class Vocab(object):
    def __init__(self, tokens, min_freq=0, use_special_tokens=False):
        counter = count_corpus(tokens)  # : 
        self.token_freqs = list(counter.items())
        self.idx_to_token = []
        if use_special_tokens:
            # padding, begin of sentence, end of sentence, unknown
            self.pad, self.bos, self.eos, self.unk = (0, 1, 2, 3)
            self.idx_to_token += ['', '', '', '']
        else:
            self.unk = 0
            self.idx_to_token += ['']
        self.idx_to_token += [token for token, freq in self.token_freqs
                        if freq >= min_freq and token not in self.idx_to_token]
        self.token_to_idx = dict()
        for idx, token in enumerate(self.idx_to_token):
            self.token_to_idx[token] = idx

    def __len__(self):
        return len(self.idx_to_token)

    def __getitem__(self, tokens):
        if not isinstance(tokens, (list, tuple)):
            return self.token_to_idx.get(tokens, self.unk)
        return [self.__getitem__(token) for token in tokens]

    def to_tokens(self, indices):
        if not isinstance(indices, (list, tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]

def count_corpus(sentences):
    tokens = [tk for st in sentences for tk in st]
    return collections.Counter(tokens)  # 返回一个字典，记录每个词的出现次数

vocab = Vocab(tokens)
print(list(vocab.token_to_idx.items())[0:10])

[('', 0), ('chapter', 1), ('it', 2), ('is', 3), ('a', 4), ('truth', 5), ('universally', 6), ('acknowledged', 7), ('that', 8), ('single', 9)]

2.语言模型

假设序列 $w_1, w_2, \ldots, w_T$ 中的每个词是依次生成的，我们有

$\begin{align*} P(w_1, w_2, \ldots, w_T) &= \prod_{t=1}^T P(w_t \mid w_1, \ldots, w_{t-1})\\ &= P(w_1)P(w_2 \mid w_1) \cdots P(w_T \mid w_1w_2\cdots w_{T-1}) \end{align*}$

例如，一段含有4个词的文本序列的概率

$P(w_1, w_2, w_3, w_4) = P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_1, w_2) P(w_4 \mid w_1, w_2, w_3).$

语言模型的参数就是词的概率以及给定前几个词情况下的条件概率。设训练数据集为一个大型文本语料库，如维基百科的所有条目，词的概率可以通过该词在训练数据集中的相对词频来计算，例如， $w_1$ 的概率可以计算为：

$\hat P(w_1) = \frac{n(w_1)}{n}$

其中 $n(w_1)$ 为语料库中以 $w_1$ 作为第一个词的文本的数量， $n$ 为语料库中文本的总数量。
类似的，给定 $w_1$ 情况下， $w_2$ 的条件概率可以计算为：

$\hat P(w_2 \mid w_1) = \frac{n(w_1, w_2)}{n(w_1)}$

其中 $n(w_1, w_2)$ 为语料库中以 $w_1$ 作为第一个词， $w_2$ 作为第二个词的文本的数量。

n元语法

序列长度增加，计算和存储多个词共同出现的概率的复杂度会呈指数级增加。 $n$ 元语法通过马尔可夫假设简化模型，马尔科夫假设是指一个词的出现只与前面 $n$ 个词相关，即 $n$ 阶马尔可夫链（Markov chain of order $n$ ），如果 $n=1$ ，那么有 $P(w_3 \mid w_1, w_2) = P(w_3 \mid w_2)$ 。基于 $n-1$ 阶马尔可夫链，我们可以将语言模型改写为

$P(w_1, w_2, \ldots, w_T) = \prod_{t=1}^T P(w_t \mid w_{t-(n-1)}, \ldots, w_{t-1}) .$

以上也叫 $n$ 元语法（ $n$ -grams），它是基于 $n - 1$ 阶马尔可夫链的概率语言模型。例如，当 $n=2$ 时，含有4个词的文本序列的概率就可以改写为：

$\begin{align*} P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_1, w_2) P(w_4 \mid w_1, w_2, w_3)\\ &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_2) P(w_4 \mid w_3) \end{align*}$

当 $n$ 分别为1、2和3时，我们将其分别称作一元语法（unigram）、二元语法（bigram）和三元语法（trigram）。例如，长度为4的序列 $w_1, w_2, w_3, w_4$ 在一元语法、二元语法和三元语法中的概率分别为

$\begin{aligned} P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2) P(w_3) P(w_4) ,\\ P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_2) P(w_4 \mid w_3) ,\\ P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_1, w_2) P(w_4 \mid w_2, w_3) . \end{aligned}$

当 $n$ 较小时， $n$ 元语法往往并不准确。例如，在一元语法中，由三个词组成的句子“你走先”和“你先走”的概率是一样的。然而，当 $n$ 较大时， $n$ 元语法需要计算并存储大量的词频和多词相邻频率。

以上都是基于统计的语言模型，属于基本概念，为后续RNN的知识做好准备

3.RNN-循环神经网络

本节介绍循环神经网络，下图展示了如何基于循环神经网络实现语言模型。我们的目的是基于当前的输入与过去的输入序列，预测序列的下一个字符。循环神经网络引入一个隐藏变量 $H$ ，用 $H_{t}$ 表示 $H$ 在时间步 $t$ 的值。 $H_{t}$ 的计算基于 $X_{t}$ 和 $H_{t-1}$ ，可以认为 $H_{t}$ 记录了到当前字符为止的序列信息，利用 $H_{t}$ 对序列的下一个字符进行预测。

image

3.1RNN的构造

我们先看循环神经网络的具体构造。假设 $\boldsymbol{X}_t \in \mathbb{R}^{n \times d}$ 是时间步 $t$ 的小批量输入， $\boldsymbol{H}_t \in \mathbb{R}^{n \times h}$ 是该时间步的隐藏变量，则：
$\boldsymbol{H}_t = \phi(\boldsymbol{X}_t \boldsymbol{W}_{xh} + \boldsymbol{H}_{t-1} \boldsymbol{W}_{hh} + \boldsymbol{b}_h).$

其中， $\boldsymbol{W}_{xh} \in \mathbb{R}^{d \times h}$ ， $\boldsymbol{W}_{hh} \in \mathbb{R}^{h \times h}$ ， $\boldsymbol{b}_{h} \in \mathbb{R}^{1 \times h}$ ， $\phi$ 函数是非线性激活函数。由于引入了 $\boldsymbol{H}_{t-1} \boldsymbol{W}_{hh}$ ， $H_{t}$ 能够捕捉截至当前时间步的序列的历史信息，就像是神经网络当前时间步的状态或记忆一样。由于 $H_{t}$ 的计算基于 $H_{t-1}$ ，上式的计算是循环的，使用循环计算的网络即循环神经网络（recurrent neural network）。
在时间步 $t$ ，输出层的输出为：
$\boldsymbol{O}_t = \boldsymbol{H}_t \boldsymbol{W}_{hq} + \boldsymbol{b}_q.$

其中 $\boldsymbol{W}_{hq} \in \mathbb{R}^{h \times q}$ ， $\boldsymbol{b}_q \in \mathbb{R}^{1 \times q}$

3.2 Code

这部分展示核心的代码，完整的代码在后面的更新中完善
基本的网络构造

rnn_layer = nn.RNN(input_size=vocab_size, hidden_size=num_hiddens)

class RNNModel(nn.Module):
    def __init__(self, rnn_layer, vocab_size):
        super(RNNModel, self).__init__()
        self.rnn = rnn_layer
        self.hidden_size = rnn_layer.hidden_size * (2 if rnn_layer.bidirectional else 1) 
        self.vocab_size = vocab_size
        self.dense = nn.Linear(self.hidden_size, vocab_size)

    def forward(self, inputs, state):
        # inputs.shape: (batch_size, num_steps)
        X = to_onehot(inputs, vocab_size)
        X = torch.stack(X)  # X.shape: (num_steps, batch_size, vocab_size)
        hiddens, state = self.rnn(X, state)
        hiddens = hiddens.view(-1, hiddens.shape[-1])  # hiddens.shape: (num_steps * batch_size, hidden_size)
        output = self.dense(hiddens)
        return output, state

训练

for epoch in range(num_epochs):
        l_sum, n, start = 0.0, 0, time.time()
        data_iter = dataset # 准备的数据
        state = None
        for X, Y in data_iter:
            if state is not None:
                # 使用detach函数从计算图分离隐藏状态
                if isinstance (state, tuple): # LSTM, state:(h, c)  
                    state[0].detach_()
                    state[1].detach_()
                else: 
                    state.detach_()
            (output, state) = model(X, state) # output.shape: (num_steps * batch_size, vocab_size)
            y = torch.flatten(Y.T)
            l = loss(output, y.long())
            
            optimizer.zero_grad()
            l.backward()
            grad_clipping(model.parameters(), clipping_theta, device)
            optimizer.step()
            l_sum += l.item() * y.shape[0]
            n += y.shape[0]