开源项目kcws代码分析--基于深度学习的分词技术

http://blog.csdn.net/pirage/article/details/53424544

分词原理

本小节内容参考待字闺中的两篇博文:

  1. 97.5%准确率的深度学习中文分词(字嵌入+Bi-LSTM+CRF)
  2. 如何深度理解Koth的深度分词?

简单的说,kcws的分词原理就是:

  1. 对语料进行处理,使用word2vec对语料的字进行嵌入,每个字特征为50维。
  2. 得到字嵌入后,用字嵌入特征喂给双向LSTM, 对输出的隐层加一个线性层,然后加一个CRF就得到本文实现的模型。
  3. 于最优化方法,文本语言模型类的貌似Adam效果更好, 对于分类之类的,貌似AdaDelta效果更好。

另外,字符嵌入的表示可以是纯预训练的,但也可以在训练模型的时候再fine-tune,一般而言后者效果更好。对于fine-tune的情形,可以在字符嵌入后,输入双向LSTM之前加入dropout进一步提升模型效果。

具体的解决方案,基于双向LSTM与CRF的神经网络结构

如上图所示,单层圆圈代表的word embedding输入层,菱形代表学习输入的决定性方程,双层圆圈代表随机变量。信息流将输入层的word embedding送到双向LSTM, l(i)代表word(i)和从左边传入的历史信号,r(i)代表word(i)以及从右边传入的未来的信号,用c(i)连接这两个向量的信息,代表词word(i)。

先说Bi-LSTM这个双向模型,LSTM的变种有很多,基本流程都是一样的,文献中同样采用上一节说明的三个门,控制送入memory cell的输入信息,以及遗忘之前阶段信息的比例,再对细胞状态进行更新,最后用tanh方程对更新后的细胞状态再做处理,与sigmoid叠加相乘作为最终输出。具体的模型公式见下图,经过上一节的解释,这些符号应该不太陌生了。

双向LSTM说白了,就是先从左至右,顺序学习输入词序列的历史信息,再从右至左,学习输入词序列未来影响现在的信息,结合这两种方式的最终表示有效地描述了词的内容,在多种标注应用上取得了好效果。

如果说双向LSTM并不特殊,这个结构中另一个新的尝试,就是将深度神经网络最后学出来的结果,作为特征,用CRF模型连接起来,用P来表示双向LSTM神经网络学习出来的打分输出矩阵,它是一个 nxk 的矩阵,n是输入词序列个数,k是标记类型的数目, P(ij)指的是在一个输入句子中,第i个词在第j个tag标记上的可能性(打分)。另外一个特征函数是状态转移矩阵 A,A(ij) 代表从tag i转移到tag j的可能性(打分),但这个转移矩阵实际上有k+2维,其中包括句子的开始和结束两个状态,用公式表示如下图:

s(X,y)=∑i=0nAyi,yi+1+∑i=1nPi,yi

在给定输入序列X,最终定义的输出y序列的概率,则使用softmax函数表示如下:

p(y|X)=es(X,y)∑y?∈YXes(X,y?)

而在训练学习目标函数的时候,要优化的就是下面这个预测输出标记序列的log概率,其中 Y(X)代表的是所有可能的tag标记序列集合,那么最后学习得到的输出,就是概率最大的那个标记序列。如果只是模拟输出的bigram交互影响方式,采用动态规划即可求解下列方程。

log(p(y|X))=s(X,y)?log(∑y?∈YXes(X,y?))

=s(X,y)?logaddy?∈YXs(X,y?)

y?=argmaxy?∈YXs(X,y?)

至此,基于双向LSTM与CRF的神经网络结构已经介绍完毕,文献中介绍的是在命名实体识别方面的一个实践应用,这个思路同样可以用在分词上。具体的实践和调参,也得应场景而异,Koth在上一篇博客中已经给出了自己的践行,读者们可以借鉴参考。

代码结构与实践

koth大神开源的项目地址为:https://github.com/koth/kcws

主要的代码在目录kcws/kcws/train路径下。(写这篇文章的时候发现K大神做了更新,我主要还是分析之前的代码)

  • process_anno_file.py 将人民网2014训练语料进行单字切割,包括标点符号
  • generate_training.py 生成单字的vector之后,处理每篇训练语料,以“。”划分为句子,对每个句子,如果长度大于MAX_LEN(默认设置为80,在代码里改),不处理,Long lines加一,如果长度小于MAX_LEN,则生成长度为160的vector,前80为单字在字典中的index,不足80的补0,后80为每个字对应的SBME标记(S表示单字,B表示开始,M表示中间,E表示结尾)。
  • filter_sentence.py 将语料切分为训练集和测试集,作者将含有两个字以下的句子过滤掉,剩下的按照二八分,测试集最多8000篇。
  • train_cws_lstm.py 主要训练代码。

作者在项目主页上很详细的写了构建和训练的步骤,按照这些步骤来实践一下不算难,我主要遇到了以下几个问题:

  1. 之前安装tensorflow的时候没有用bazel,不了解bazel的工作方式和原理,但是这个项目必须要用,因为需要用到third_party中word2vec的类。(可以将word2vec的某些类构建为python可以import的类?)
  2. 已安装的0.8.0版本的tensorflow没有实现crf,需要升级。
  3. 安装tensorflow 0.11.0版本后运行,出现PyUnicodeUCS4_AsUTF8String的错误,查找后发现是当前安装的python默认是unicode=ucs2,需要重新编译安装python。编译的时候设置./configure –enable-unicode=ucs4 。
  4. numpy,scipy都需要重新build,setup。

主要代码分析

def main(unused_argv):
    curdir = os.path.dirname(os.path.realpath(__file__))
    trainDataPath = tf.app.flags.FLAGS.train_data_path
    if not trainDataPath.startswith("/"):
        trainDataPath = curdir + "/" + trainDataPath
    graph = tf.Graph()
    with graph.as_default():
        model = Model(FLAGS.embedding_size, FLAGS.num_tags,
                  FLAGS.word2vec_path, FLAGS.num_hidden)
        print("train data path:", trainDataPath)
        # 读取训练集batch大小的feature和label,各为80大小的数组
        X, Y = inputs(trainDataPath)
        # 读取测试集所有数据的feature和label,各为80大小的数组
        tX, tY = do_load_data(tf.app.flags.FLAGS.test_data_path)
        # 计算训练集的损失
        total_loss = model.loss(X, Y)
        # 使用AdamOptimizer优化方法
        train_op = train(total_loss)
        # 在测试集上做评测
        test_unary_score, test_sequence_length = model.test_unary_score()
        # 创建Supervisor管理模型的分布式训练
        sv = tf.train.Supervisor(graph=graph, logdir=FLAGS.log_dir)
        with sv.managed_session(master=‘‘) as sess:
            # actual training loop
            training_steps = FLAGS.train_steps
            for step in range(training_steps):
                if sv.should_stop():
                    break
                try:
                    _, trainsMatrix = sess.run(
                    [train_op, model.transition_params])
                    # for debugging and learning purposes, see how the loss gets decremented thru training steps
                    if step % 100 == 0:
                        print("[%d] loss: [%r]" % (step, sess.run(total_loss)))
                    if step % 1000 == 0:
                        test_evaluate(sess, test_unary_score,
                                  test_sequence_length, trainsMatrix,
                                  model.inp, tX, tY)
                except KeyboardInterrupt, e:
                    sv.saver.save(sess,
                              FLAGS.log_dir + ‘/model‘,
                              global_step=step + 1)
                    raise e
            sv.saver.save(sess, FLAGS.log_dir + ‘/finnal-model‘)
            sess.close()

1

Class Model:

def __init__(self, embeddingSize, distinctTagNum, c2vPath, numHidden):
    self.embeddingSize = embeddingSize
    self.distinctTagNum = distinctTagNum
    self.numHidden = numHidden
    self.c2v = self.load_w2v(c2vPath)
    self.words = tf.Variable(self.c2v, name="words")
    with tf.variable_scope(‘Softmax‘) as scope:
        self.W = tf.get_variable(
            shape=[numHidden * 2, distinctTagNum],
            initializer=tf.truncated_normal_initializer(stddev=0.01),
            name="weights",
            regularizer=tf.contrib.layers.l2_regularizer(0.001))
        self.b = tf.Variable(tf.zeros([distinctTagNum], name="bias"))
    self.trains_params = None
    self.inp = tf.placeholder(tf.int32,
                              shape=[None, FLAGS.max_sentence_len],
                              name="input_placeholder")
    pass

def length(self, data):
    used = tf.sign(tf.reduce_max(tf.abs(data), reduction_indices=2))
    length = tf.reduce_sum(used, reduction_indices=1)
    length = tf.cast(length, tf.int32)
    return length

def inference(self, X, reuse=None, trainMode=True):
    word_vectors = tf.nn.embedding_lookup(self.words, X) # 按照X顺序返回self.words中的第X行,返回的结果组成tensor。
    length = self.length(word_vectors)
    # length是shape为[batch_size]大小值为句子长度的vector
    length_64 = tf.cast(length, tf.int64)
    if trainMode:  # 训练的时候启用dropout,测试的时候关键dropout
        word_vectors = tf.nn.dropout(word_vectors, 0.5)  # 将word_vectors按照50%的概率丢弃某些词,tf增加的一个处理是将其余的词scale 1/0.5
    with tf.variable_scope("rnn_fwbw", reuse=reuse) as scope:
        forward_output, _ = tf.nn.dynamic_rnn(
            tf.nn.rnn_cell.LSTMCell(self.numHidden),
            word_vectors,
            dtype=tf.float32,
            sequence_length=length,
            scope="RNN_forward")
        backward_output_, _ = tf.nn.dynamic_rnn(
            tf.nn.rnn_cell.LSTMCell(self.numHidden),
            inputs=tf.reverse_sequence(word_vectors,
                                       length_64,
                                       seq_dim=1),
            # 训练和测试的时候,inputs的格式不同。训练时,tensor shape是[batch_size, max_time,input_size]
            # 测试时,tensor shape是[max_time,batch_size,input_size].
            # tf.reverse_sequence作用就是指定在列上操作(batch_dim表示按行操作)
            dtype=tf.float32,
            sequence_length=length,
            scope="RNN_backword")
    # tf.nn.dynamic_rnn(cell, inputs, sequence_length,time_major,...)主要参数:
    # cell:搭建好的网络,这里用LSTMCell(num_cell),num_cell表示一个lstm单元输出的维数(100)
    # inputs:word_vectors,它的shape由time_major决定,默认是false,即[batch_size,max_time,input_size],如果是测试
    #           过程,time_major设置为True,shape为[max_time,batch_size,input_size],这里直接做了reverse,省去了time_major设置。
    #         其中,batch_size=100, max_time=80句子最大长度,input_size字的向量的长度。
    # sequence_length:shape[batch_size]大小的值为句子最大长度的tensor。
    # 输出:
    #   outputs:[batch_size, max_time, cell.output_size]
    #   state: shape取决于LSTMCell中state_size的设置,返回Tensor或者tuple。

    backward_output = tf.reverse_sequence(backward_output_,
                                          length_64,
                                          seq_dim=1)
    # 这里的reverse_sequence同上。
    output = tf.concat(2, [forward_output, backward_output])
    # 连接两个三维tensor,2表示按照列连接(0表示纵向,1表示行)
    # 连接后,output的shape:[batch_size, max_time, 2*cell.output_size],即[100, 80, 2*50]
    output = tf.reshape(output, [-1, self.numHidden * 2])
    # reshape后,output的shape:[batch_size, self.numHidden * 2],即[100, 200]
    matricized_unary_scores = tf.batch_matmul(output, self.W)
    # 得到未归一化的CRF输出
    # 点乘W的shape[ 100*2, 4],生成[batch_size, 4]大小的matricized_unary_scores
    unary_scores = tf.reshape(
        matricized_unary_scores,
        [-1, FLAGS.max_sentence_len, self.distinctTagNum])
    # reshape后,unary_scores大小为[batch_size,80, 4]
    return unary_scores, length

def loss(self, X, Y):
    P, sequence_length = self.inference(X)
    # CRF损失计算,训练的时候使用,测试的时候用viterbi解码
    log_likelihood, self.transition_params = tf.contrib.crf.crf_log_likelihood(
        P, Y, sequence_length)
    # crf_log_likelihood参数(inputs,tag_indices, sequence_lengths)
    #   inputs:大小为[100, 80, 4]的tensor,CRF层的输入
    #   tag_indices:大小为[100, 80]的矩阵
    #   sequence_length:大小 [100]值为80的向量。
    # 输出:
    #   log_likelihood:[batch_size]大小的vector,log-likelihood值
    #   transition_params:[4,4]大小的矩阵
    loss = tf.reduce_mean(-log_likelihood)
    return loss

def load_w2v(self, path): #返回(num+2)*50大小的二维矩阵,其中第一行全是0,最后一行是每个词向量维度的平均值。
    fp = open(path, "r")
    print("load data from:", path)
    line = fp.readline().strip()
    ss = line.split(" ")
    total = int(ss[0])
    dim = int(ss[1])
    assert (dim == (FLAGS.embedding_size))
    ws = []
    mv = [0 for i in range(dim)]
    # The first for 0
    ws.append([0 for i in range(dim)])
    for t in range(total):
        line = fp.readline().strip()
        ss = line.split(" ")
        assert (len(ss) == (dim + 1))
        vals = []
        for i in range(1, dim + 1):
            fv = float(ss[i])
            mv[i - 1] += fv
            vals.append(fv)
        ws.append(vals)
    for i in range(dim):
        mv[i] = mv[i] / total
    ws.append(mv)
    fp.close()
    return np.asarray(ws, dtype=np.float32)

def test_unary_score(self):
    P, sequence_length = self.inference(self.inp,
                                        reuse=True,
                                        trainMode=False)
    return P, sequence_length

其他的代码比较简单,个人觉得不必要做深入分析。

总结

近一两个月开始学习TensorFlow,代码看了一些,但是总感觉临门差那么一脚。革命尚未完成,同志们仍需努力

时间: 2024-11-05 16:29:42

开源项目kcws代码分析--基于深度学习的分词技术的相关文章

《卷积神经网络的Python实现》PDF代码+《解析深度学习卷积神经网络原理与视觉实践》PDF分析

CNN正在革新几个应用领域,如视觉识别系统.自动驾驶汽车.医学发现.创新电子商务等.需要在专业项目或个人方案中利用复杂的图像和视频数据集来实现先进.有效和高效的CNN模型. 深度卷积网络DCNN是目前十分流行的深度神经网络架构,它的构造清晰直观,效果引人入胜,在图像.视频.语音.语言领域都有广泛应用. 深度学习,特别是深度卷积神经网络是人工智能的重要分支领域,卷积神经网络技术也被广泛应用于各种现实场景,在许多问题上都取得了超越人类智能的结果. <卷积神经网络的Python实现>作为深度学习领域

【原创】总结大创项目-基于深度学习的智能红绿灯调控系统

一.产品定位分析 (注:以下调研均发生于2017年5月前.) 由于此次项目最初是为了参加Intel举办的某届基于深度学习的创新应用比赛,当时召集了小组成员集思广益,想一些具有创意的点子作为此次项目的立项定题的方向.最终确立下来的有两个,一个是"智能垃圾箱"(大概构思是垃圾箱盖附近的摄像头检测欲扔进垃圾箱的垃圾类别,实时反馈到显示屏或者语音提示将其扔往正确的垃圾箱入口),但是由于被导师认为在实际投入应用中受人为因素影响太大(因为国民普遍素质仍有待提高--),进而此立意夭折:另一个项目就是

车万翔《基于深度学习的自然语言处理》中英文PDF+涂铭《Python自然语言处理实战核心技术与算法》PDF及代码

自然语言处理是人工智能领域的一个重要的研究方向,是计算机科学与语言学的交叉学科.随着互联网的快速发展,网络文本尤其是用户生成的文本呈爆炸性增长,为自然语言处理带来了巨大的应用需求.但是由于自然语言具有歧义性.动态性和非规范性,同时语言理解通常需要丰富的知识和一定的推理能力,为自然语言处理带来了极大的挑战. 近年来快速发展的深度学习技术为解决自然语言处理问题的解决提供了一种可能的思路,已成为有效推动自然语言处理技术发展的变革力量. 推荐将深度学习理论运用至NLP中的资料<基于深度学习的自然语言处理

《基于深度学习的自然语言处理》中文PDF+英文PDF+学习分析

我们做自然语言处理的,主要是进行文本分析,作为人工智能的领域之一,也一定会应用深度神经网络进行处理. 近年来快速发展的深度学习技术为解决自然语言处理问题的解决提供了一种可能的思路,已成为有效推动自然语言处理技术发展的变革力量. <基于深度学习的自然语言处理>重点介绍了神经网络模型在自然语言处理中的应用.首先介绍有监督的机器学习和前馈神经网络的基本知识,如何将机器学习方法应用在自然语言处理中,以及词向量表示(而不是符号表示)的应用,然后介绍了更多专门的神经网络结构,包括一维卷积神经网络.循环神经

TensorFlow实现基于深度学习的图像补全

目录 ■ 简介 ■ 第一步:将图像理解为一个概率分布的样本 你是怎样补全缺失信息的呢? 但是怎样着手统计呢?这些都是图像啊. 那么我们怎样补全图像?  ■ 第二步:快速生成假图像 在未知概率分布情况下,学习生成新样本 [ML-Heavy] 生成对抗网络(Generative Adversarial Net, GAN) 的架构 使用G(z)生成伪图像 [ML-Heavy] 训练DCGAN 现有的GAN和DCGAN实现 [ML-Heavy] 在Tensorflow上构建DCGANs 在图片集上跑DC

深度学习与计算机视觉(12)_tensorflow实现基于深度学习的图像补全

原文地址:Image Completion with Deep Learning in TensorFlow by Brandon Amos 原文翻译与校对:@MOLLY && 寒小阳 ([email protected]) 时间:2017年4月. 出处:http://blog.csdn.net/han_xiaoyang/article/details/52665396 声明:版权所有,转载请联系作者并注明出 简介 第一步:将图像理解为一个概率分布的样本 你是怎样补全缺失信息的呢? 但是怎

回望2017,基于深度学习的NLP研究大盘点

回望2017,基于深度学习的NLP研究大盘点 雷锋网 百家号01-0110:31 雷锋网 AI 科技评论按:本文是一篇发布于 tryolabs 的文章,作者 Javier Couto 针对 2017 年基于深度学习的自然语言处理研究进行了大盘点.雷锋网 AI 科技评论根据原文进行了编译. 在过去的几年里,深度学习(DL)架构和算法在诸如图像识别和语音处理等领域取得了世人瞩目的进步.然而在最开始的时候,深度学习在自然语言处理(Natural Language Processing, NLP)领域的

【OCR技术系列之四】基于深度学习的文字识别(3755个汉字)

上一篇提到文字数据集的合成,现在我们手头上已经得到了3755个汉字(一级字库)的印刷体图像数据集,我们可以利用它们进行接下来的3755个汉字的识别系统的搭建.用深度学习做文字识别,用的网络当然是CNN,那具体使用哪个经典网络?VGG?RESNET?还是其他?我想了下,越深的网络训练得到的模型应该会更好,但是想到训练的难度以及以后线上部署时预测的速度,我觉得首先建立一个比较浅的网络(基于LeNet的改进)做基本的文字识别,然后再根据项目需求,再尝试其他的网络结构.这次任务所使用的深度学习框架是强大

基于深度学习的图像语义分割方法综述

近年来,深度学习技术已经广泛应用到图像语义分割领域.主要对基于深度学习的图像语义分割的经典方法与研究现状进行分类.梳理和总结.根据分割特点和处理粒度的不同,将基于深度学习的图像语义分割方法分为基于区域分类的图像语义分割方法和基于像素分类的图像语义分割方法.把基于像素分类的图像语义分割方法进一步细分为全监督学习图像语义分割方法和弱监督学习图像语义分割方法.对每类方法的代表性算法进行了分析介绍,并详细总结了每类方法的基本思想和优缺点,系统地阐述了深度学习对图像语义分割领域的贡献.对图像语义分割相关实