动手学深度学习-学习笔记（二）

本文的内容包括：文本预处理，语言模型和循环神经网络基础

一、文本预处理

文本是一类序列数据，一篇文章可以看作是字符或单词的序列。文本预处理一般包括四个步骤：

（1）读入文本

import collections
import re
# 逐行读取文本
def read_time_machine():
    with open('/home/kesci/input/timemachine7163/timemachine.txt', 'r') as f:
        lines = [re.sub('[^a-z]+', ' ', line.strip().lower()) for line in f]
    return lines


lines = read_time_machine()
print('# sentences %d' % len(lines))

（2）分词：将一个句子划分成若干个词（token），转换为一个词的序列。

def 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)
tokens[0:2]

（3）建立字典（vocabulary），将每个词映射到一个唯一的索引（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])

 （4）将文本从词的序列转换为索引的序列，方便输入模型 

for i in range(8, 10):
    print('words:', tokens[i])
    print('indices:', vocab[tokens[i]])

 输出为：

words: ['the', 'time', 'traveller', 'for', 'so', 'it', 'will', 'be', 'convenient', 'to', 'speak', 'of', 'him', '']
indices: [1, 2, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0]
words: ['was', 'expounding', 'a', 'recondite', 'matter', 'to', 'us', 'his', 'grey', 'eyes', 'shone', 'and']
indices: [20, 21, 22, 23, 24, 16, 25, 26, 27, 28, 29, 30]

上述分词手段有如下缺点：

（1）标点符号通常可以提供语义信息，但是我们的方法直接将其丢弃了

（2）类似“shouldn't", "doesn't"这样的词会被错误地处理

（3）类似"Mr.", "Dr."这样的词会被错误地处理

也可以采用现有的工具进行分词： spaCy和NLTK

text = "Mr. Chen doesn't agree with my suggestion."

import spacy  # 采用spacy
nlp = spacy.load('en_core_web_sm')
doc = nlp(text)
print([token.text for token in doc])

from nltk.tokenize import word_tokenize  # 采用NLTK
from nltk import data
data.path.append('/home/kesci/input/nltk_data3784/nltk_data')
print(word_tokenize(text))

两种方法的输出均为

['Mr.', 'Chen', 'does', "n't", 'agree', 'with', 'my', 'suggestion', '.']

二、语言模型

一段自然语言文本可以看作是一个离散时间序列，给定一个长度为T的词的序列w1,w2,…,wT，语言模型的目标就是评估该序列是否合理，即计算该序列的概率：

假设序列w1,w2,…,wT中的每个词是依次生成的，有

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

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

 其中n(w1)为语料库中以w1作为第一个词的文本的数量，n为语料库中文本的总数量。

给定w1情况下，w2的条件概率可以计算为：

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

 n 元语法（n-gram）：是基于统计的语言模型，为了解决随着序列长度增加，计算和存储多个词共同出现的概率的复杂度会呈指数增加的问题。n元语法通过马尔可夫假设简化模型，马尔科夫假设是指一个词的出现只与前面n个词相关，即n阶马尔可夫链（Markov chain of order n），如果n=1，那么有P(w3∣w1,w2)=P(w3∣w2)。基于n−1阶马尔可夫链，语言模型可改写为：

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

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

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

 n元语法可能具有参数空间过大以及数据稀疏的缺陷。

时序数据的采样

在训练中需要每次随机读取小批量样本和标签。时序数据的一个样本通常包含连续的字符。假设时间步数为5，样本序列为5个字符，即“想”“要”“有”“直”“升”。该样本的标签序列为这些字符分别在训练集中的下一个字符，即“要”“有”“直”“升”“机”，即X=“想要有直升”，Y=“要有直升机”。

现在我们考虑序列“想要有直升机，想要和你飞到宇宙去”，如果时间步数为5，有以下可能的样本和标签：

• X：“想要有直升”，Y：“要有直升机”
• X：“要有直升机”，Y：“有直升机，”
• X：“有直升机，”，Y：“直升机，想”
• ...
• X：“要和你飞到”，Y：“和你飞到宇”
• X：“和你飞到宇”，Y：“你飞到宇宙”
• X：“你飞到宇宙”，Y：“飞到宇宙去”

可以看到，如果序列的长度为T，时间步数为n，那么一共有T−n个合法的样本，但是这些样本有大量的重合，通常采用更加高效的采样方式。有两种方式对时序数据进行采样，分别是随机采样和相邻采样。

随机采样：每个样本是原始序列上任意截取的一段序列，相邻的两个随机小批量在原始序列上的位置不一定相毗邻。

相邻采样：在相邻采样中，相邻的两个随机小批量在原始序列上的位置相毗邻。

三、循环神经网络基础

目的是基于当前的输入与过去的输入序列，预测序列的下一个字符。循环神经网络引入一个隐藏变量H，用Ht表示H在时间步t的值。Ht的计算基于Xt和Ht−1，可以认为Ht记录了到当前字符为止的序列信息，利用Ht对序列的下一个字符进行预测。 

 

裁剪梯度 ：

循环神经网络中较容易出现梯度衰减或梯度爆炸，这会导致网络几乎无法训练。裁剪梯度（clip gradient）是一种应对梯度爆炸的方法。假设把所有模型参数的梯度拼接成一个向量 g，并设裁剪的阈值是θ。裁剪后的梯度

的L2范数不超过 θ

困惑度

通常使用困惑度（perplexity）来评价语言模型的好坏。困惑度是对交叉熵损失函数做指数运算后得到的值。特别地，

• 最佳情况下，模型总是把标签类别的概率预测为1，此时困惑度为1；
• 最坏情况下，模型总是把标签类别的概率预测为0，此时困惑度为正无穷；
• 基线情况下，模型总是预测所有类别的概率都相同，此时困惑度为类别个数。

显然，任何一个有效模型的困惑度必须小于类别个数。在本例中，困惑度必须小于词典大小vocab_size。

定义模型训练函数

跟之前章节的模型训练函数相比，这里的模型训练函数有以下几点不同：

1. 使用困惑度评价模型。
2. 在迭代模型参数前裁剪梯度。
3. 对时序数据采用不同采样方法将导致隐藏状态初始化的不同。