深度学习（三十八）初识DL在自然语言序列标注中的应用-未完待续

初识DL在自然语言中的应用


原文地址：

作者：

一、自然语言序列标注

虽然之前自己对于HMM、CRF、Word2vec、Attention机制、Encode-Decode等，在自然语言领域的应用已经比较熟悉了，看过的文献、教程、算法等也很多，但是感觉都只是纸上谈兵，自己从没有好好写过代码。因为自己一直是搞计算机视觉、图像领域，最近看了一些深度学习计算机视觉领域相关最新的文献后，总是觉得学到的知识不是很多；故而决定从今日开始正式踏足自然语言领域，开始NLP学习征程……

目前我看了很多经典文献:《Natural Language Processing (almost) from Scratch》、《Learning Character-level Representations for Part-of-Speech Tagging》、《End-to-end Sequence Labeling
via Bi-directional LSTM-CNNs-CRF》、《Bidirectional LSTM-CRF Models for Sequence Tagging》 等 ,利用深度学习RNN、CNN、LSTM等网络模型做序列标注,主要包含以下几个特点:

对于自然语言来说，序列标注定义：给定一个句子X={x1,x2,……xn}，我们的目标是求解输出序列Y={y1,y2,……yn}，其中x1，x2……表示句子每个字。

以中文分词为例

(1)中文分词：目标是要把一个句子的每个字，标注成S、B、M、E，以下面的句子为例：

X={“ 人们 常 说 生活 是 一 部 教科书 ， 而 血 与 火 的 战争}”

Y={S BE S S B E S S S BME S S S S S S B E}

对于分词任务来说，我们的任务就是要给上面的每个字打上类别标签：S、B、M、E，也就是说属于4分类问题，神经网络在设计的时候，网络的最后一层就是4个神经元的softmax输出。

(2)命名实体识别：目标是要把句子的每个字标注成：BA、MA、EA、BO、MO、EO、BP、MP、EP、O等，

其中BA代表这个汉字是地址首字，MA代表这个汉字是地址中间字，EA代表这个汉字是地址的尾字；BO代表这个汉字是机构名的首字，MO代表这个汉字是机构名称的中间字，EO代表这个汉字是机构名的尾字；BP代表这个汉字是人名首字，MP代表这个汉字是人名中间字，EP代表这个汉字是人名尾字，而O代表这个汉字不属于命名实体。具体的类别根据需求而定，比如你还要识别时间、一些特定的名词类别等，那么就加入新的类别标签。

除此之外，词性标注、语义角色识别,甚至连关键词提取等都可以看成是序列标注问题，比如关键词提取的目标可以看成对每个词做一个二分类：关键词、非关键词。因为序列标注都可以用同样一个框架,搞定任务。所以后面为了简单起见,我将用上面的分词例子为例，进行讲解。

(1)最普通的方案:

既然序列标注可以看成是对每个文字进行分类，最简单的方法是:把每个文字表示成一个索引向量(专业名词又称之为One-hot
Representation)，要预测该文字的标签的时候,就用这个向量作为输入。比如我们要分类上面句子中的文字"常"，假设"常"在字典中的索引号为1020，字典的字数共10000。那么我们可以把常用数值表示x=(0,0，……1，……0)，x是一个10000维的向量，除了第1020维的数值为1之外，其它的全部为0。用x向量作为神经网络的输入层，网络设计成三层MLP结构。神经网络的输出为4个神经元softmax层，对应于"常"分别属于S、B、M、E标签的概率,

OK,这是对于我等,只专注于计算机机视觉与深度学习,然而却完全没有接触过NLP的解决方案。首先上面的方案,不是不可行,而是精度非常非常低罢了(达到精度30%应该还是有的,哈哈,毕竟四个类别没有任何信息,等概率也可以到达25%精度)

虽然上面讲的方案很低级，然而后面我将以这个方案作为基础思路，对上面的方案存在的问题进行讲解，然后对方案做一步一步的改进,直到最后我们设计、训练出来的网络，可以与现有的世界最牛逼的序列标注算法相匹敌.

(2)第一次改进-上下文窗口

一般来说,我们在设计神经网络的时候,网络的输入层,不仅仅是一个文字,而是采用上下文窗口.可能以前我们遇到深度学习一般是思路是:输入层为xi,输入就是yi。xi表示一个句子中的某个文字,图片示例,一一映射:

然而一般对于自然语言来说,我们一般很难通过一个字,判断这个字的标签,比如上面"常",如果是单独的一个文字,我们根本无法确定其标签,其具体标签还得看"常"在该句子中的上下文信息,对于上面的分词例子,"常"在该句子中的分类标签是S;.然而对于下面的句子:

"我经常独自一人吃饭"
中"常"的标签就应该是B.

因此让神经网络的输入层为单个文字:"常",进行预测类别标签,显然是不合理的.一般来说我们会采用上下文窗口(这个就像图像处理的卷积窗口感受野一样)神经网络的输入应该是:

(2)第二次改进-字向量

(3)第三次改进-序列标签约束MLP+CRF

(5)第五次改进-RNN、LSTM+CRF

(6)第六次改进双向LSTM+CRF

(7)第七次改进双向LSTM+CNN+CRF

(4)细节改进-字向量无监督预训练

二、采用上下文窗口+词向量-简单MLP中文分词尝试

作为自己学习NLP的第一站，当然是先用最简单的网络做最简单的任务，练练手再说。

神经网络的输入：

“ 人们 常 说 生活 是 一 部 教科书 ， 而 血 与 火 的 战争……
”。

S BE S S B E S S S BME S S S S S S B E

神经网络的输出：

下面是我用简单的MLP，进行中文分词的源码测试，因此记录一下自己的第一个自然语言程序：

#coding=utf-8
from collections import OrderedDict
import os
import random
import numpy
import theano
from theano import tensor as T
from Preprocess.LoadData import  Segment,write
import numpy as np

# 打乱样本数据
def shuffle(lol, seed):
for l in lol:
random.seed(seed)
random.shuffle(l)

#输入一个长句，我们根据窗口获取每个win内的数据，作为一个样本。或者也可以称之为作为RNN的某一时刻的输入
def contextwin(l, win):

assert (win % 2) == 1
assert win >= 1
l = list(l)

lpadded = win // 2 * [-1] + l + win // 2 * [-1]#在一个句子的末尾、开头，可能win size内不知，我们用-1 padding
out = [lpadded[i:(i + win)] for i in range(len(l))]

assert len(out) == len(l)
return out

# 输出结果，用于脚本conlleval.pl的精度测试，该脚本需要自己下载，在windows下调用命令为:perl conlleval.pl < filename
def conlleval(p, g, w, filename):
out = ''
for sl, sp, sw in zip(g, p, w):
out += 'BOS O O\n'
for wl, wp, w in zip(sl, sp, sw):
out += w + ' ' + wl + ' ' + wp + '\n'
out += 'EOS O O\n\n'

f = open(filename, 'w')
f.writelines(out)
f.close()

class RNNSLU(object):
def __init__(self, nh, nc, ne, de, cs):
'''
nh ::隐藏层神经元个数
nc ::输出层标签分类类别
ne :: 单词的个数
de :: 词向量的维度
cs :: 上下文窗口
'''
#词向量实际为(ne, de)，外加1行，是为了边界标签-1而设定的
self.emb = theano.shared(name='embeddings',value=0.2 * numpy.random.uniform(-1.0, 1.0,(ne+1, de)).astype(theano.config.floatX))#词向量空间
self.wx = theano.shared(name='wx',value=0.2 * numpy.random.uniform(-1.0, 1.0,(de * cs, nh)).astype(theano.config.floatX))#输入数据到隐藏层的权重矩阵
self.wh = theano.shared(name='wh', value=0.2 * numpy.random.uniform(-1.0, 1.0,(nh, nh)).astype(theano.config.floatX))#上一时刻隐藏到本时刻隐藏层循环递归的权值矩阵
self.w = theano.shared(name='w',value=0.2 * numpy.random.uniform(-1.0, 1.0,(nh, nc)).astype(theano.config.floatX))#隐藏层到输出层的权值矩阵
self.bh = theano.shared(name='bh', value=numpy.zeros(nh,dtype=theano.config.floatX))#隐藏层偏置参数
self.b = theano.shared(name='b',value=numpy.zeros(nc,dtype=theano.config.floatX))#输出层偏置参数

self.h0 = theano.shared(name='h0',value=numpy.zeros(nh,dtype=theano.config.floatX))

self.params = [self.emb, self.wx, self.wh, self.w,self.bh, self.b]#所有待学习的参数

idxs = T.itensor3()
x = self.emb[idxs].reshape((idxs.shape[0],idxs.shape[1],de*idxs.shape[2]))
y_sentence = T.imatrix('y_sentence')  # 训练样本标签,二维的(batch,sentence)

s_temp=self.forward(x)

p_y =T.nnet.softmax(T.reshape(s_temp,(s_temp.shape[0]*s_temp.shape[1],-1)))
p_y=T.reshape(p_y,s_temp.shape)
#h,p_y=step(x, self.h0)#p_y为三维矩阵，表示每个样本的值

loss=self.nll_multiclass(p_y,y_sentence)+0.0*((self.wx**2).sum()+(self.wh**2).sum()+(self.w**2).sum())

lr = T.scalar('lr')#学习率，一会儿作为输入参数

#神经网络的输出
sentence_gradients = T.grad(loss, self.params)

sentence_updates = OrderedDict((p, p - lr*g) for p, g in zip(self.params, sentence_gradients))
self.sentence_train = theano.function(inputs=[idxs,y_sentence,lr],outputs=loss,updates=sentence_updates)
#词向量归一化，因为我们希望训练出来的向量是一个归一化向量
self.normalize = theano.function(inputs=[],updates={self.emb:self.emb /T.sqrt((self.emb**2).sum(axis=1)).dimshuffle(0, 'x')})

#构造预测函数、训练函数，输入数据idxs每一行是一个样本(也就是一个窗口内的序列索引)
y_pred = T.argmax(p_y,axis=-1)
self.classify = theano.function(inputs=[idxs,y_sentence], outputs=[loss,y_pred])
#这边没有采用RNN，而是直接采用MLP进行中文分词
def forward(self,x):
x_t=x#.dimshuffle((1,0,2))
def step(x_t, h_tm1):
h_t = T.nnet.sigmoid(T.dot(x_t, self.wx) + self.bh)#通过ht-1、x计算隐藏层
s_temp=T.dot(h_t, self.w) + self.b#由于softmax不支持三维矩阵操作，所以这边需要对其进行reshape成2D，计算完毕后再reshape成3D
return h_t, s_temp
#[h,s_temp], _ = theano.scan(step,sequences=x_t,outputs_info=[T.ones(shape=(x_t.shape[1],self.h0.shape[0])) * self.h0, None])
[h,s_temp]=step(x_t,self.h0)#s_temp#.dimshuffle((1,0,2))
return  s_temp
def backward(self,x):
x_t=x#.dimshuffle((1,0,2))
def step(x_t, h_tm1):
h_t = T.nnet.tanh(T.dot(x_t, self.wx) + T.dot(h_tm1, self.wh) + self.bh)#通过ht-1、x计算隐藏层
s_temp=T.dot(h_t, self.w) + self.b#由于softmax不支持三维矩阵操作，所以这边需要对其进行reshape成2D，计算完毕后再reshape成3D
return h_t, s_temp
[h,s_temp], _ = theano.scan(step,sequences=x_t,outputs_info=[T.ones(shape=(x_t.shape[1],self.h0.shape[0])) * self.h0, None],go_backwards = True)
s_temp=s_temp#.dimshuffle((1,0,2))
return  s_temp
#训练
def train(self, x, y,learning_rate):
loss=self.sentence_train(x, y, learning_rate)
self.normalize()
return  loss
def nll_multiclass(self,p_y_given_x, y):
p_y =p_y_given_x
p_y_m = T.reshape(p_y, (p_y.shape[0] * p_y.shape[1], -1))
y_f = y.flatten(ndim=1)
return -T.mean(T.log(p_y_m)[T.arange(p_y_m.shape[0]), y_f])

#保存、加载训练模型
def save(self, folder):
for param in self.params:
numpy.save(os.path.join(folder,
param.name + '.npy'), param.get_value())
def load(self, folder):
for param in self.params:
param.set_value(numpy.load(os.path.join(folder,
param.name + '.npy')))
#为了采用batch训练，需要保证每个句子长度相同，因此这里采用均匀切分，不过有一个缺陷那就是有可能某个词刚好被切开
def convert2batch(dic,filename_list,win,length=3):
x=[]
y=[]
for f in filename_list:
xt,yt=dic.encode_index(f)#创建训练数据的索引序列
x=x+xt
y=y+yt

train_batchxs=[]
train_batchys=[]

train_seqx=[x[i:i+length] for i in range(len(x)) if i%length==0]
train_seqy=[y[i:i+length] for i in range(len(y)) if i%length==0]
for x,y in zip(train_seqx,train_seqy):
if len(x)!=length or len(y)!=length:
continue
s=contextwin(x,win)
train_batchxs.append(s)
train_batchys.append(y)

#每个句子的长度不同，不能直接转换
return  np.asarray(train_batchxs,dtype=np.int32),np.asarray(train_batchys,dtype=np.int32)

#RNN分词
def segment_train(dic,filename):
trainx,trainy=convert2batch(dic,filename,5,1000)

#计算相关参数
vocsize = len(dic.word2index)#计算词的个数
print vocsize
nclasses =len(dic.label2index)#标签数为B、M、E、S
winsize=5#窗口大小
ndim=50#词向量维度
nhidden=200#隐藏层的神经元个数
learn_rate=0.5#梯度下降学习率

#构建RNN，开始训练
rnn = RNNSLU(nh=nhidden,nc=nclasses,ne=vocsize,de=ndim,cs=winsize)

batch_size=64
n_train_batch=trainx.shape[0]/batch_size
rnn.load('model/')
epoch=0
while epoch<0:
shuffle([trainx,trainy], 345)
loss=0
for i in range(n_train_batch):
batx=trainx[i*batch_size:(i+1)*batch_size]
baty=trainy[i*batch_size:(i+1)*batch_size]
decay_lr=learn_rate*0.5**(epoch/50)
loss+=rnn.train(batx,baty,decay_lr)
print 'epoch:',epoch,'\tloss:',loss/n_train_batch
epoch+=1
if epoch%50==0:
rnn.save('model/')
#rnn.save('model/')
return  rnn
def segment_test(model,dic,test_file):
#model.load('model/')#加载训练参数
x,y=dic.encode_index(test_file)#创建训练数据的索引序列
xjieba,yjieba=dic.encode_index('Data/msr/msr_test_jieba_result.txt')#创建训练数据的索引序列
test_batchxs=[]
test_batchys=[]
s=contextwin(x,5)
test_batchxs.append(s)
test_batchys.append(y)

loss,pre=model.classify(np.asarray(test_batchxs),np.asarray(test_batchys).transpose((1,0)))
print 'loss:',loss
print pre.shape

#测试集的输出标签
print pre.shape
predictions_label=dic.decode_index(pre[0],is_label=True)
groudtrue_label=dic.decode_index(y,is_label=True)
words_test=dic.decode_index(x)

for k,(w,i,j) in enumerate(zip(words_test,groudtrue_label,predictions_label)):
print w,i,j

print 'save'
conlleval(predictions_label,groudtrue_label,words_test, 'current.test.txt')

filelist=['Data/msr/msr_training.utf8','Data/msr/pku_training.utf8','Data/msr/1.txt','Data/msr/1998.txt']
#filelist=['Data/msr/msr_training.utf8']
dic=Segment(filelist)#创建词典
print len(dic.word2index)
model=segment_train(dic,filelist)
segment_test(model,dic,'Data/msr/msr_test_gold.utf8')

再看一下结巴分词的结果：

用最简单的可以简单的看成对一个句子的每个文字进行分类。需要注意的是序列标注问题与简单的文字分类问题,最大的区别在于:,因此采用简单的神经网络进行输入输出,精度很难达到state-of-art,

三\标签约束
具体原因如下：
1、为了快速构建网络，进行批量训练，我比较懒惰，直接把一个文本，按照一个sequence 长度进行强制切分，
2、没有对一个文本的符号进行处理，而是直接扔进网络中。把句号、逗号等作为分类类别标致"S"，也一起扔进网络中
3、没有对输出序列做约束关系，导致
5、没有结合采用字向量进行网络的预训练

参考文献：
1、/article/3683718.html