python 中文NLP预处理包

文章目录

• 自然语言处理

• 一、文本预处理

• 读入文本
• 分词
• 建立字典
• 将词转为索引
• 用现有工具进行分词

• 二、语言模型(基于统计)

• 语言模型
• n元语法

• 三、语言模型数据集

• 读取数据集
• 建立字符索引
• 时序数据的采样

• 随机采样
• 相邻采样

自然语言处理

一、文本预处理

把字符/单词 --> 数值 --> 才能被网络计算blabla

读入文本

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
     	# f可迭代的，每次处理f的一行；strip去前后缀的换行/制表符等；lower用于转为小写
     	# re.sub 正则表达式的替换函数；
     	# [^a-z]表示非小写a~z; + 表示长度至少为1
     	# 结合后面的 ' '，表示把不属于a~z的长度至少为1的字符串替换为空格

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

输出： # sentences 3221 —— timemachine.txt这个文件有3221行

分词

对每个句子进行分词，也就是将一个句子划分成若干个词（token），转换为一个词的序列。

# sentences 一个列表，每个列表元素为一个字符串，一个句子；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]  # 字符级别的分隔：对sentences中的句子，直接从字符串转换成列表
    else:
        print('ERROR: unkown token type '+token)

tokens = tokenize(lines)
tokens[0:2]

[[‘the’, ‘time’, ‘machine’, ‘by’, ‘h’, ‘g’, ‘wells’, ‘’], [’’]]
对lines进行分词，得到tokens，2维的，输出两列，第一列就是[‘the’, ‘time’, ‘machine’, ‘by’, ‘h’, ‘g’, ‘wells’, ‘’]，第二列可能原来就是空的，所以输出 [’’]

建立字典

为了方便模型处理，我们需要将字符串转换为数字。因此我们需要先构建一个字典（vocabulary），将每个词映射到一个唯一的索引编号。

# 向Vocab查询一个词，会返回索引编号；提供一个索引编号，会返回对应的词。
# Vocab参数说明：
# 一个token可以理解为上面那个代码返回的值，是一个二维的列表；这里tokens是语料库中所有的token；
# min_freq是一个阈值，构建这个字典时，语料库中有些词出现次数非常少，对于出现次数小于min_freq的词就忽略掉
# use_special_tokens ：是否使用特殊的token

# 函数大概步骤说明：去重复，筛选token，有时候还需要添加特殊的token 
#                --> 选出构建字典时常用的token。将token映射到索引

class Vocab(object):
    def __init__(self, tokens, min_freq=0, use_special_tokens=False):
        counter = count_corpus(tokens)  # <key,value> : <词，词频>  
        self.token_freqs = list(counter.items())   # 去重完成，且计算出了词频，之后进行token的增删
        self.idx_to_token = []  # 记录最终需要维护的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 += ['<pad>', '<bos>', '<eos>', '<unk>']
            # padding, begin of sentence, end of sentence, unknown
            # padding: 模型每次处理的一般是batch，
            #      e.g.用SGD训练，每次训练的是一个二维的矩阵，一行是一个句子，当长度不等时候需要补足token，pad用来补足
            # bos/eos：添加在句子的开始/结尾处，表示句子的开始/结束
            # unk: 如果输入一个在语料库中不存在的词，aka: “未登录词”,当作unk处理
        else:
            self.unk = 0  # if use_special_tokens=FALSE,则只有unk这一个标志
            self.idx_to_token += ['<unk>']
        self.idx_to_token += [token for token, freq in self.token_freqs
                        if freq >= min_freq and token not in self.idx_to_token] 
                        # ...not in self...是为了防止语料库当中有 <pad><bos>..这几个词
                        # 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) 
        
	# 该函数定义了Vocab这个类的索引,词到索引的映射
    def __getitem__(self, tokens):   # tokens可以是list/tuple/char
        if not isinstance(tokens, (list, tuple)):
            return self.token_to_idx.get(tokens, self.unk)
        return [self.__getitem__(token) for token in tokens]
	
	# 和getitem类似，只不过是给索引，返回词
    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):  # sentences就是前面的token，二维的列表
    tokens = [tk for st in sentences for tk in st]  # 展平得到一维列表tokens
    return collections.Counter(tokens)  # 返回一个字典，记录每个词的出现次数

例子，用Time Machine作为语料构建字典：

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

[(’< unk>’, 0), (‘the’, 1), (‘time’, 2), (‘machine’, 3), (‘by’, 4), (‘h’, 5), (‘g’, 6), (‘wells’, 7), (‘i’, 8), (‘traveller’, 9)]

将词转为索引

使用字典，我们可以将原文本中的句子从单词序列转换为索引序列

for i in range(8, 10):
    print('words:', tokens[i])  # tokens[i] 第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"这样的词会被错误地处理(会被分成 shouldn 和 t)
3. 类似"Mr.", "Dr."这样的词会被错误地处理

我们可以通过引入更复杂的规则来解决这些问题，但是事实上，有一些现有的工具可以很好地进行分词，我们在这里简单介绍其中的两个：spaCy和NLTK。

下面是一个简单的例子：

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

spaCy:

import spacy
nlp = spacy.load('en_core_web_sm')  # 导入language
doc = nlp(text)
print([token.text for token in doc])

[‘Mr.’, ‘Chen’, ‘does’, “n’t”, ‘agree’, ‘with’, ‘my’, ‘suggestion’, ‘.’] <–分词结果

NLTK：

from nltk.tokenize import word_tokenize
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’, ‘.’]

课后习题：

二、语言模型(基于统计)

语言模型的目标：评估该序列是否合理，即计算该序列的概率。这里主要介绍基于统计的模型，主要是$\boldsymbol{n}$元语法（$\boldsymbol{n}$-gram）

语言模型

假设序列$w_1, w_2, \ldots, w_T$中的每个词是依次生成的，我们有
KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ P(w_1, w_2, \l…
例如，一段含有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个词的文本序列的概率就可以改写为：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ P(w_1, w_2, w_…

当$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$元语法需要计算并存储大量的词频和多词相邻频率（计算和存储的开销很大）。

思考：n元语法可能有哪些缺陷？
Ans ：

1. 参数空间大
   如果n=3，我们需要维护的参数有$P(w_1) ，P(w_2 \mid w_1)， P(w_3 \mid w_1, w_2)$，如果字典大小为V，则需要维护的参数数量为$V+V^2+V^3$。n元模型的参数规模和n是呈指数关系，所以计算和存储开销都很大。
2. 数据稀疏
   很多词的词频都很小，还有些基本不出现，以及一些词的搭配不会多次出现，所以计算出来的概率很多都是0。稀疏问题严重

三、语言模型数据集

读取数据集

代码讲解：

with open('/home/kesci/input/jaychou_lyrics4703/jaychou_lyrics.txt') as f:
    corpus_chars = f.read()
print(len(corpus_chars))
print(corpus_chars[: 40])
corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ') # 换行、回车替换为空格
corpus_chars = corpus_chars[: 10000]   # 保留前1w个字符

63282
想要有直升机
想要和你飞到宇宙去
想要和你融化在一起
融化在宇宙里
我每天每天每

建立字符索引

代码讲解

idx_to_char = list(set(corpus_chars)) # 去重，得到索引到字符的映射
char_to_idx = {char: i for i, char in enumerate(idx_to_char)} # 字符到索引的映射
vocab_size = len(char_to_idx)
print(vocab_size)

corpus_indices = [char_to_idx[char] for char in corpus_chars]  # 将每个字符转化为索引，得到一个索引的序列
sample = corpus_indices[: 20]
print('chars:', ''.join([idx_to_char[idx] for idx in sample]))
print('indices:', sample)

1027
chars: 想要有直升机 想要和你飞到宇宙去 想要和
indices: [1022, 648, 1025, 366, 208, 792, 199, 1022, 648, 641, 607, 625, 26, 155, 130, 5, 199, 1022, 648, 641]

上面第6行corpus_indices = [char_to_idx[char] for char in corpus_char]意义（评论区的同学解释到）：
这段中corpus_char包含了一个char的list
char_to_idx是一个字典 形式是[(字符，索引号)]
而for char in corpus_char 表示把 corpus_char中的字符一个一个取出，然后将每个char对应的char_to_idx字典中的索引号取出，构成一段索引叫corpus_indices
比如这段代码中idx_to_char = [ ‘我’， ‘是’] char_to_idx = [(‘我’，0)， （‘是’，1）] 那corpus_char[‘我’] = 0 而corpus_indices = [0,1]

定义函数load_data_jay_lyrics，在后续章节中直接调用。

时序数据的采样

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

在循环神经网络中有详细解释。Y标签可以理解为，为了预测 “想要有直升”的下一个字。
举个例子：
现在考虑序列“想要有直升机，想要和你飞到宇宙去”，如果时间步数为5，有以下可能的样本和标签：

• $X$：“想要有直升”，：“要有直升机”
• $X$：“要有直升机”，：“有直升机，”
• $X$：“有直升机，”，：“直升机，想”
• …
• $X$：“要和你飞到”，：“和你飞到宇”
• $X$：“和你飞到宇”，：“你飞到宇宙”
• $X$：“你飞到宇宙”，：“飞到宇宙去”
  可以看到，如果序列的长度为$T$，时间步数为$n$，那么一共有$T-n$个合法的样本，但是这些样本有大量的重合，我们通常采用更加高效的采样方式。我们有两种方式对时序数据进行采样，分别是随机采样和相邻采样。

随机采样

下面的代码每次从数据里随机采样一个小批量。其中批量大小batch_size是每个小批量的样本数，num_steps是每个样本所包含的时间步数。 在随机采样中，每个样本是原始序列上任意截取的一段序列，相邻的两个随机小批量在原始序列上的位置不一定相毗邻。

e.g.: 给定一段序列作为训练数据(黑色矩形)，将数据划分成长度等于时间步数num_steps的分组(紫色[ ])，从这些分组中选出batch_size个，作为一个批量。函数data_iter_random的参数中，corpus_indices就是训练数据，device控制返回的数据返回到什么设备上，

import torch
import random
def data_iter_random(corpus_indices, batch_size, num_steps, device=None):
    # 减1是因为对于长度为n的序列，X最多只有包含其中的前n - 1个字符
    num_examples = (len(corpus_indices) - 1) // num_steps  # 下取整，得到不重叠情况下的样本个数
    example_indices = [i * num_steps for i in range(num_examples)]  # 每个样本的第一个字符在corpus_indices中的下标
    random.shuffle(example_indices)

    def _data(i):
        # 返回从i开始的长为num_steps的序列
        return corpus_indices[i: i + num_steps]
    if device is None:
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    for i in range(0, num_examples, batch_size):
        # 每次选出batch_size个随机样本
        batch_indices = example_indices[i: i + batch_size]  # 当前batch的各个样本的首字符的下标
        X = [_data(j) for j in batch_indices]
        Y = [_data(j + 1) for j in batch_indices]
        yield torch.tensor(X, device=device), torch.tensor(Y, device=device)

测试这个函数，输入从0到29的连续整数作为一个人工序列，设batch_size=2，num_steps=6，打印随机采样每次读取的小批量样本的输入X和标签Y。

my_seq = list(range(30))
for X, Y in data_iter_random(my_seq, batch_size=2, num_steps=6):
    print('X: ', X, '\nY:', Y, '\n')

X: tensor([[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17]])
Y: tensor([[ 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18]])

X: tensor([[ 0, 1, 2, 3, 4, 5],
[18, 19, 20, 21, 22, 23]])
Y: tensor([[ 1, 2, 3, 4, 5, 6],
[19, 20, 21, 22, 23, 24]])

相邻采样

在相邻采样中，相邻的两个随机小批量在原始序列上的位置相毗邻。（在循环神经网络有涉及，所以课程中讲到了）

例子：假设batch_size=3，则把序列三等分(黑色[ ])，则下图中标红的三个取出，就是第一个batch，绿色和蓝色分别是2、3个batch，依次取下去。

下面代码中，4，5行，这两步保证corpus_indices可以整除批量大小

7行，resize成二维tensor，第一个维度是batch_size大小，即把上图变成下图👇：

第10行，i = i * num_steps，是取出下面黄色标注的那些位置的下标👇：

def data_iter_consecutive(corpus_indices, batch_size, num_steps, device=None):
    if device is None:
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    corpus_len = len(corpus_indices) // batch_size * batch_size  # 保留下来的序列的长度
    corpus_indices = corpus_indices[: corpus_len]  # 仅保留前corpus_len个字符
    indices = torch.tensor(corpus_indices, device=device)
    indices = indices.view(batch_size, -1)  # resize成(batch_size, )
    batch_num = (indices.shape[1] - 1) // num_steps  # -1 原因与之前相同，样本不能包含最后一个字符
    for i in range(batch_num):
        i = i * num_steps
        X = indices[:, i: i + num_steps]
        Y = indices[:, i + 1: i + num_steps + 1]
        yield X, Y

X: tensor([[ 0, 1, 2, 3, 4, 5],
[15, 16, 17, 18, 19, 20]])
Y: tensor([[ 1, 2, 3, 4, 5, 6],
[16, 17, 18, 19, 20, 21]])

X: tensor([[ 6, 7, 8, 9, 10, 11],
[21, 22, 23, 24, 25, 26]])
Y: tensor([[ 7, 8, 9, 10, 11, 12],
[22, 23, 24, 25, 26, 27]])

这引用了评论区 “小罗同学”总结的知识点，谢谢 :）

课后习题：