之前已经写过用LSTM来做分词的方案了，今天再来一篇用CNN的，准确来说是FCN，全卷积网络。其实这个模型的主要目的并非研究中文分词，而是练习tensorflow。本文就是练习一下如何用tensorflow处理不定长输入任务，以中文分词为例，并在最后加入了硬解码，将深度学习与词典分词结合了起来。
|
挖掘大数据，从海量信息中汲取你所不知的秘密 之前已经写过用LSTM来做分词的方案了，今天再来一篇用CNN的，准确来说是FCN，全卷积网络。其实这个模型的主要目的并非研究中文分词，而是练习tensorflow。本文就是练习一下如何用tensorflow处理不定长输入任务，以中文分词为例，并在最后加入了硬解码，将深度学习与词典分词结合了起来。 关于FCN，放到语言任务中看，（一维）卷积其实就是ngram模型，从这个角度来看其实CNN远比RNN来得自然，RNN好像就是为序列任务精心设计的，而CNN则是传统ngram模型的一个延伸。 另外不管CNN和RNN都有权值共享，看上去只是为了降低运算量的一个折中选择，但事实上里边大有道理。CNN中的权值共享是平移不变性的必然结果，而不是仅仅是降低运算量的一个选择，试想一下，将一幅图像平移一点点，或者在一个句子前插入一个无意义的空格（导致后面所有字都向后平移了一位），这样应该给出一个相似甚至相同的结果，而这要求卷积必然是权值共享的，即权值不能跟位置有关系。 RNN类模型，尤其是LSTM，一直语言任务的霸主，但最近引入门机制的卷积GCNN据说在语言模型上已经超过了LSTM（一点点），这说明哪怕在语言任务中CNN还是很有潜力的。 LSTM的优势就是能够捕捉长距离的信息，但事实上语言任务中真正长距离的任务不多，哪怕是语言模型，事实上后一个字的概率只取决于前面几个字罢了，不用取决于前面的全文，而CNN只要层数多一点，卷积核大一点，其实也能达到这个效果了。 但CNN还有一个特别的优势：CNN比RNN快多了。用显卡加速的话，显卡最擅长的就是作卷积了，因为显卡本身就是用来处理图像的，GPU对CNN的加速要比对RNN的加速明显多了... 以上内容，就使得我更偏爱CNN，就像facebook那个团队一样（那个GCNN就是他们搞出来的）。全卷积网络则是从头到尾都使用卷积，可以应对不定长输入，而输入不定长、但是输入输出长度相等的任务就更适合了。 本文的任务是用FCN做一个中文分词系统，思路还是sbme字标注法，不清楚的读者可以看回前几篇文章，有监督训练，因此需要选语料。比较好的语料有两个，一是2014年人民日报语料，二是backoff2005比赛中的语料，后者还带有评测系统。我在两个语料中都实践过了。 如果用2014人民日报语料，那么预处理代码为： import glob import re from tqdm import tqdm from collections import Counter, defaultdict import json import numpy as np import os
txt_names = glob.glob('./2014/*/*.txt')
pure_texts = [] pure_tags = [] stops = u'，。！？；、：,\.!\?;:\n' for name in tqdm(iter(txt_names)): txt = open(name).read().decode('utf-8', 'ignore') txt = re.sub('/[a-z\d]*|\[|\]', '', txt) txt = [i.strip(' ') for i in re.split('['+stops+']', txt) if i.strip(' ')] for t in txt: pure_texts.append('') pure_tags.append('') for w in re.split(' +', t): pure_texts[-1] += w if len(w) == 1: pure_tags[-1] += 's' else: pure_tags[-1] += 'b' + 'm'*(len(w)-2) + 'e' 如果用backoff2005语料，那么预处理代码为 import re from tqdm import tqdm from collections import Counter, defaultdict import json import numpy as np import os
pure_texts = [] pure_tags = [] stops = u'，。！？；、：,\.!\?;:\n' for txt in tqdm(open('msr_training.txt')): txt = [i.strip(' ').decode('gbk', 'ignore') for i in re.split('['+stops+']', txt) if i.strip(' ')] for t in txt: pure_texts.append('') pure_tags.append('') for w in re.split(' +', t): pure_texts[-1] += w if len(w) == 1: pure_tags[-1] += 's' else: pure_tags[-1] += 'b' + 'm'*(len(w)-2) + 'e' 然后将语料按照字符串长度排序，这是因为tensorflow虽然支持变长输入，但是在训练的时候，每个batch内的长度要想等，因此需要做一个简单的聚类（按长度聚类）。接着得到一个映射表，这都是很常规的： ls = [len(i) for i in pure_texts] ls = np.argsort(ls)[::-1] pure_texts = [pure_texts[i] for i in ls] pure_tags = [pure_tags[i] for i in ls]
min_count = 2 word_count = Counter(''.join(pure_texts)) word_count = Counter({i:j for i,j in word_count.iteritems() if j >= min_count}) word2id = defaultdict(int) id_here = 0 for i in word_count.most_common(): id_here += 1 word2id[i[0]] = id_here
json.dump(word2id, open('word2id.json', 'w')) vocabulary_size = len(word2id) + 1 tag2vec = {'s':[1, 0, 0, 0], 'b':[0, 1, 0, 0], 'm':[0, 0, 1, 0], 'e':[0, 0, 0, 1]} 做一个生成器，用来生成每个batch的训练样本。要注意的是，这里的batch_size只是一个上限，因为要求每个batch内的句子长度都要相同，这样子并非每个batch的size都能达到1024。 batch_size = 1024
def data(): l = len(pure_texts[0]) x = [] y = [] for i in range(len(pure_texts)): if len(pure_texts[i]) != l or len(x) == batch_size: yield x,y x = [] y = [] l = len(pure_texts[i]) x.append([word2id[j] for j in pure_texts[i]]) y.append([tag2vec[j] for j in pure_tags[i]]) 到了搭建模型的时候了，其实很简单，就是用了三层卷积叠起来，不指定输入长度，就设为None，设置padding = 'SAME'使得输入输出同样长度（基于这个目的，也不用池化），中间用relu激活，最后用softmax激活，用交叉熵作为损失函数，就完了。用tensorlfow的话，得自己写好每个过程，但其实也没多复杂。 import tensorflow as tf
embedding_size = 128 keep_prob = tf.placeholder(tf.float32)
embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0)) x = tf.placeholder(tf.int32, shape=[None, None]) embedded = tf.nn.embedding_lookup(embeddings, x) embedded_dropout = tf.nn.dropout(embedded, keep_prob) W_conv1 = tf.Variable(tf.random_uniform([3, embedding_size, embedding_size], -1.0, 1.0)) b_conv1 = tf.Variable(tf.random_uniform([embedding_size], -1.0, 1.0)) y_conv1 = tf.nn.relu(tf.nn.conv1d(embedded_dropout, W_conv1, stride=1, padding='SAME') + b_conv1) W_conv2 = tf.Variable(tf.random_uniform([3, embedding_size, embedding_size/4], -1.0, 1.0)) b_conv2 = tf.Variable(tf.random_uniform([embedding_size/4], -1.0, 1.0)) y_conv2 = tf.nn.relu(tf.nn.conv1d(y_conv1, W_conv2, stride=1, padding='SAME') + b_conv2) W_conv3 = tf.Variable(tf.random_uniform([3, embedding_size/4, 4], -1.0, 1.0)) b_conv3 = tf.Variable(tf.random_uniform([4], -1.0, 1.0)) y = tf.nn.softmax(tf.nn.conv1d(y_conv2, W_conv3, stride=1, padding='SAME') + b_conv3)
y_ = tf.placeholder(tf.float32, shape=[None, None, 4]) cross_entropy = - tf.reduce_sum(y_ * tf.log(y + 1e-20)) train_step = tf.train.AdamOptimizer().minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y, 2), tf.argmax(y_, 2)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 以上就是模型的全部了，然后训练。再次给大家推荐一下，用tqdm来辅助显示进度（实时显示进度、速度、精度），简直是绝配啊。 init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) nb_epoch = 300
for i in range(nb_epoch): d = tqdm(data(), desc=u'Epcho %s, Accuracy: 0.0'%(i+1)) k = 0 accs = [] for xxx,yyy in d: k += 1 if k%100 == 0: acc = sess.run(accuracy, feed_dict={x: xxx, y_: yyy, keep_prob:1}) accs.append(acc) d.set_description('Epcho %s, Accuracy: %s'%(i+1, acc)) sess.run(train_step, feed_dict={x: xxx, y_: yyy, keep_prob:0.5}) print u'Epcho %s Mean Accuracy: %s'%(i+1, np.mean(accs))
saver = tf.train.Saver() saver.save(sess, './ckpt/lm.ckpt') 训练过程输出（这是用macbook的cpu训练的，用gtx1060加速只需要3s一个epcho） Epcho 1, Accuracy: 0.717359: 347it [01:06, 5.21it/s] Epcho 1 Mean Accuracy: 0.56555 Epcho 2, Accuracy: 0.759943: 347it [01:08, 8.62it/s] Epcho 2 Mean Accuracy: 0.74762 Epcho 3, Accuracy: 0.598692: 347it [01:08, 5.08it/s] Epcho 3 Mean Accuracy: 0.693505 Epcho 4, Accuracy: 0.634529: 347it [01:07, 5.14it/s] Epcho 4 Mean Accuracy: 0.613064 Epcho 5, Accuracy: 0.659949: 347it [01:07, 5.16it/s] Epcho 5 Mean Accuracy: 0.643388 Epcho 6, Accuracy: 0.709635: 347it [01:07, 5.14it/s] Epcho 6 Mean Accuracy: 0.679544 Epcho 7, Accuracy: 0.742839: 271it [00:42, 2.45it/s] 训练完之后，剩下的就是预测、标注、分词了，这都是很基本的。最后可以在backoff2005的评测集上达到93%的准确率（backoff2005提供的score脚本算出的准确率），不算最优，但够了，主要还是下面的调整。 但众所周知，基于字标注法的分词，需要标签语料训练，训练完之后，就适应那一批语料了，比较难拓展到新领域；又或者说，如果发现有分错的地方，则没法很快调整过来。而基于词表的方法则容易调整，只需要增减词典或者调整词频即可。这样可以考虑怎么将深度学习与词典结合起来，这里简单地在最后的解码阶段加入硬解码（人工干预解码）。 模型预测可以得到各个标签的概率，接下来是用viterbi算法得到最优路径，但是在viterbi之前，可以利用词表对各个标签的概率进行调整。这里的做法是：添加一个add_dict.txt文件，每一行是一个词，包括词语和倍数，这个倍数就是要将相应的标签概率扩大的倍数，比如词表中指定词语“科学空间,10”，而对“科学空间挺好”进行分词时，先用模型得到这六个字的标签概率，然后查找发现“科学空间”这个词在这个句子里边，所以将第一个字为s的概率乘以10，将第二、三个字为m的概率乘以10，将第4个字为e的概率乘以10（不用归一化，因为只看相对值就行了），同样地，如果某些地方切漏了（该切的没有切），也可以加入到词表中，然后设置小于1的倍数就行了。 效果： 加入词典前：扫描 二维码 ， 关注 微 信号 。 （加入词典：微信号,10）加入词典后：扫描 二维码 ， 关注 微信号 。 当然，这只是一个经验方法。后面部分代码如下，由于这里只是演示效果，用了正则表达式遍历查找，如果追求效率，应当用AC自动机等多模式匹配工具： trans_proba = {'ss':1, 'sb':1, 'bm':1, 'be':1, 'mm':1, 'me':1, 'es':1, 'eb':1} trans_proba = {i:np.log(j) for i,j in trans_proba.iteritems()}
add_dict = {} if os.path.exists('add_dict.txt'): with open('add_dict.txt') as f: for l in f: a,b = l.split(',') add_dict[a.decode('utf-8')] = np.log(float(b))
def viterbi(nodes): paths = nodes[0] for l in range(1,len(nodes)): paths_ = paths.copy() paths = {} for i in nodes[l].keys(): nows = {} for j in paths_.keys(): if j[-1]+i in trans_proba.keys(): nows[j+i]= paths_[j]+nodes[l][i]+trans_proba[j[-1]+i] k = np.argmax(nows.values()) paths[nows.keys()[k]] = nows.values()[k] return paths.keys()[np.argmax(paths.values())]
def simple_cut(s): if s: nodes = [dict(zip('sbme', k)) for k in sess.run(y, feed_dict={x:[[word2id[i] for i in s]], keep_prob:1})[0]] for w,f in add_dict.iteritems(): for i in re.finditer(w, s): if len(w) == 1: nodes[i.start()]['s'] += f else: nodes[i.start()]['b'] += f nodes[i.end()-1]['e'] += f for j in range(i.start()+1, i.end()-1): nodes[j]['m'] *= f tags = viterbi(nodes) words = [s[0]] for i in range(1, len(s)): if tags[i] in ['s', 'b']: words.append(s[i]) else: words[-1] += s[i] return words else: return []
def cut_words(s): i = 0 r = [] for j in re.finditer('['+stops+' ]'+'|[a-zA-Z\d]+', s): r.extend(simple_cut(s[i:j.start()])) r.append(s[j.start():j.end()]) i = j.end() if i != len(s): r.extend(simple_cut(s[i:])) return r |
|
|
