初识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,进行中文分词的源码测试,因此记录一下自己的第一个自然语言程序:
-
- 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)
-
-
-
- def contextwin(l, win):
-
- assert (win % 2) == 1
- assert win >= 1
- l = list(l)
-
- lpadded = win // 2 * [-1] + l + win // 2 * [-1]
- out = [lpadded[i:(i + win)] for i in range(len(l))]
-
- assert len(out) == len(l)
- return out
-
-
-
-
-
- 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):
- ''
-
-
-
-
-
-
-
- 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')
-
-
-
- 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)
-
-
- 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')})
-
-
- y_pred = T.argmax(p_y,axis=-1)
- self.classify = theano.function(inputs=[idxs,y_sentence], outputs=[loss,y_pred])
-
- def forward(self,x):
- x_t=x
- def step(x_t, h_tm1):
- h_t = T.nnet.sigmoid(T.dot(x_t, self.wx) + self.bh)
- s_temp=T.dot(h_t, self.w) + self.b
- return h_t, s_temp
-
- [h,s_temp]=step(x_t,self.h0)
- return s_temp
- def backward(self,x):
- x_t=x
- 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)
- s_temp=T.dot(h_t, self.w) + self.b
- 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
- 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')))
-
- 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)
-
-
-
- def segment_train(dic,filename):
- trainx,trainy=convert2batch(dic,filename,5,1000)
-
-
- vocsize = len(dic.word2index)
- print vocsize
- nclasses =len(dic.label2index)
- winsize=5
- ndim=50
- nhidden=200
- learn_rate=0.5
-
-
- 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/')
-
- return rnn
- def segment_test(model,dic,test_file):
-
- 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']
-
- 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、http://blog.csdn.net/malefactor/article/details/50725480