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.语言模型

假设序列中的每个词是依次生成的，我们有

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

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

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

其中为语料库中以作为第一个词，作为第二个词的文本的数量。

n元语法

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

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

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

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

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

3.RNN-循环神经网络

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

image

3.1RNN的构造

我们先看循环神经网络的具体构造。假设是时间步的小批量输入，是该时间步的隐藏变量，则：

其中，，，，函数是非线性激活函数。由于引入了，能够捕捉截至当前时间步的序列的历史信息，就像是神经网络当前时间步的状态或记忆一样。由于的计算基于，上式的计算是循环的，使用循环计算的网络即循环神经网络（recurrent neural network）。
在时间步，输出层的输出为：

其中，

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]