精华内容
下载资源
问答
  •   条件随机场模型是由Lafferty在2001年提出的一种典型的判别式...条件随机场模型既具有判别式模型的优点,又具有产生式模型考虑到上下文标记间的转移概率,以序列化形式进行全局参数优化和解码的特点,解决了其他...

    https://blog.csdn.net/s151506879/article/details/51912595

     

    条件随机场模型是由Lafferty在2001年提出的一种典型的判别式模型。它在观测序列的基础上对目标序列进行建模,重点解决序列化标注的问题。条件随机场模型既具有判别式模型的优点,又具有产生式模型考虑到上下文标记间的转移概率,以序列化形式进行全局参数优化和解码的特点,解决了其他判别式模型(如最大熵马尔科夫模型)难以避免的标记偏置问题。

        条件随机场理论(CRFs)可以用于序列标记、数据分割、组块分析等自然语言处理任务中。在中文分词、中文人名识别、歧义消解等汉语自然语言处理任务中都有应用,表现很好。目前基于 CRFs 的主要系统实现有CRF,FlexCRF,CRF++。 缺点:训练代价大、复杂度高

     

    机器学习方法的两种分类:产生式模型和判别式模型

    假定输入x, 类别标签y

    —   产生式模型(生成模型)估计联合概率 P(x, y), 因可以根据联合概率来生成样本:HMMs

     —  判别式模型(判别模型)估计条件概率 P(y|x), 因为没有x的知识,无法生成样本,只能判断分类: SVMs,CRF,MEM

    一个举例:

        (1,0), (1,0), (2,0), (2, 1)
    产生式模型:

        p(x, y):
        P(1, 0) = 1/2, P(1, 1) = 0, P(2, 0) = 1/4, P(2, 1) = 1/4.

    判别式模型:
        P(y|x):
        P(0|1) = 1, P(1|1) = 0, P(0|2) = 1/2, P(1|2) = 1/2

    o和s分别代表观察序列和标记序列

    —产生式模型

    —     构建o和s的联合分布p(s,o);

    —判别式模型

    —     构建o和s的条件分布p(s|o);

    —产生式模型中,观察序列作为模型的一部分;判别式模型中,观察序列只作为条件,因此可以针对观察序列设计灵活的特征。

      

    一般认为判别型模型要好于生成型模型,因为它是直接根据数据对概率建模,而生成型模型还要先求两个难度相当的概率

    概率图模型,用图的形式表示概率分布。

      

    —  当然,这些随机变量之间可能有依赖关系,一般来说,也只有当这些变量之间有依赖关系的时候,我们将其单独拿出来看成一个随机场才有实际意义。

    —具有马尔科夫性质

    —体现了一个思想:离当前因素比较遥远(这个遥远要根据具体情况自己定义)的因素对当前因素的性质影响不大。

     

     

    条件随机场模型是一种无向图模型,它是在给定需要标记的观察序列的条件下,计算整个标记序列的联合概率分布,而不是在给定当前状态条件下,定义下一个状态的状态分布。即给定观察序列O,求最佳状态序列S。

     

     

    展开全文
  • 用于漫画图像面板检测的树状条件随机场模型
  • 基于多条件随机场模型的图像3D空间布局理解
  • 最大熵和条件随机场模型相融合的藏文人名识别
  • 2.掌握中文分词的常用算法,包括基于词库的分词技术、基于条件随机场模型的中文分词,熟悉算法流程,能推导算法结果。 3. 编程实现基于条件随机场模型的中文分词算法。 二、上机内容与要求 4. 使用自己熟悉的编程...

    一、上机目的
    1.了解中文分词的基本概念和原理。
    2.掌握中文分词的常用算法,包括基于词库的分词技术、基于条件随机场模型的中文分词,熟悉算法流程,能推导算法结果。
    3. 编程实现基于条件随机场模型的中文分词算法。

    二、上机内容与要求
    4. 使用自己熟悉的编程语言实现基于条件随机场模型的中文分词算法。
    5. 按照算法流程,逐步编程实现,不得调用已有的分词算法。
    6. 实例验证,包括课本“希腊的经济结构较特殊”及自行指定另一句子,给分词结果截图作为实验结果。

    三、上机步骤

    1 条件随机场模型对应于一个无向图,用于在给定需要标记的观察序列的条件下,计算整个标记序列的联合概率分布。从中文分词的角度来分析,每个词语中的每一个字都存在4种可能的状态,分别是词头(Begin)、词中(Middle)、词尾(End)和单字成词(Single),简称B、M、E、S。给定句子中的每个词则被视为条件随机场模型中的观察序列,条件随机场模型求解的就是句子中字的标记序列的联合概率分布,然后对标记序列进行回溯路径。
    求解标记序列的联合概率分布的整体思路是:准备语料库;语料库特征初步学习;词语特征学习;开始分词。
    标记序列的联合概率分布的求解公式为:
    S[字][当前状态] = MAX(P[上一个字的状态][当前状态] x S[上一个字][任何一种状态] ) + W前(后)[前(后)一个字的状态][当前的字] + R[当前状态概率]

    2 采用条件随机
    2.1准备语料库
    随机场模型是基于统计学习的方法,在采用条件随机场模型进行分词以前,需要准备一个语料库。语料库是由大量的句子组成,并且尽可能包含各种句式,语料库的质量直接影响联合概率分布和分词的效果,词语之间采用空格符分隔。例如下面的句子:
    尽管 印尼 中央 和 地方政府 已 派出 上千人 的 灭火队,但 由于 该 地区 长期 干旱 少雨,所以 火势 至今 未 得到 有效 控制。

    2.2 语料库特征学习
    根据第一步分好词的语料库,我们可以看出一个字的状态可能有四种可能,分别是词头(Begin)、词中(Middle)、词尾(End)和单字成词(Single),简称B、M、E、S;当然,标点符号也是需要标记的,但一般只有一种状态,就是单字成词。我们这一步需要做的就是把语料库中的词进行标记,根据第一步的分词结果进行标记,标记后的结果如下所示:
    尽\B管\E印\B尼\E中\B央\E和\S地\B方\M政\M府\E已\S派\B出\E上\B千\M人\E的\S灭\B火\M队\E,\S但\S由\B于\E该\S地\B区\E长\B期\E干\B旱\E少\B雨\E,\S所\B以\E火\B势\E至\B今\E未\S得\B到\E有\B效\E控\B制\E。\S
    由上面的标注的可以看出,只要将一个句子的每一个字的状态标出,即相当于已经分词;因此,可将中文分词转换成序列标注问题,对一个未分词的序列进行标注(标注状态为B,M,E,S)可知道分词结果。例如将句子“我们爱中国”分词为“我\B们\E爱\S中\B国\E”,表示将句子分词为“我们 爱 中国”。

    2.3 词语特征学习
    基于用户输入的字符串,针对字符串中的每一个字,统计它在语料库中出现的次数,例如‘希’字在语料库中出现了1352次。
    针对具体的某个字,计算它的状态分别为词头(Begin)、词中(Middle)、词尾(End)和单字成词(Single)的概率;例如:出现1352次的“希”字,其中有1208次希的状态是B,则“希”字的状态为B的概率为1208/1352=0.8935
    针对某一个字,计算它的状态分别为词头(Begin)、词中(Middle)、词尾(End)和单字成词(Single)时,每一个字都有属于自己的状态,后面这一个字也有自己的状态,计算下一个字分别为词头(Begin)、词中(Middle)、词尾(End)和单字成词(Single)的概率,这里需要注意,只考虑下一个字的状态而不管下一个字是什么字。此过程计算的就是状态之间的相互转移的矩阵,针对每一个字的4种状态,转移到4种状态,就构成了一个4*4的矩阵,矩阵中的值就是他们相互之间转移概率。
    当某一个字出现的时候,计算下一个字出现的内容,并计算两个字同时出现的概率。例如:状态为B的希字,下一个字的状态为E的腊字的概率是0.04216;还要计算当某一个字出现的时候,计算上一个字出现的内容,并计算两个字同时出现的概率。例如:状态为B的腊字,上一个字的状态为B的希字的概率是0.7024。还要考虑一个问题,就是第一个字没有前一个字,最后一个字没有后一个。

    2.4 开始分词
    求解每个字对应的特征,根据状态信息绘制字与状态的初始矩阵映射关系表,在未分词前,这个矩阵的初始值都为0。
    依据公式求解每一个字的每一种状态的值。对于一个字符串,只要先求出第一个字的四种状态下的值,后面的类似。但不同的是,计算第一个字时,没有max部分。
    第二步求映射矩阵时,总是从四个值中选一个最大值,对应的下表为0,1,2,3,然后在映射表中标记选中最大值得下标。
    完成了映射矩阵和标记了下标之后,就可以进行回溯路径了。将映射矩阵的最后一个字的最大值取出,从后往前回溯,第一个数字就是最大值的下标,然后看它标记的数字,这个数字就来源于上一个字的位置,再记录下标……,
    写出回溯路径后,就可以对字符串进行序列标记,0对应B,1对应M,2对应E,3对应S,标记完成即相当于分词完成。
    3.1 词语特征学习
    由于语料库msr_training.utf8.ic已经好了序列,帮我们省略了前两步的工作,为了方便,我把语料库另存为msr_training.utf8.txt文本文件,接下来的操作都是以这个文本文件进行的。
    根据我的思路,首先第一步就是把语料库的内容当成一个字符串进行处理。面对四百多万行的文本文件,进行普通的字符流或字节流读取操作是很费时间的,因此我想到了利用字符流+缓冲区进行操作,使读取速度大大加快。把文件的读取内容赋值给可变的StringBuffer类型的变量,待完全读取后,再赋给String类型变量,因为之后语料库的内容是不变的。
    统计输入的字符串中的每一个字在语料库中出现的次数。例如输入了“希腊的经济结构较特殊”,定义了一个数组,分别记录这十个字在语料库中的次数,每一个字分别遍历语料库进行统计,统计的结果如下:

    s = input()      #输入要分词的字符串
    ss = s     
    with open("./1.txt",'r',encoding='UTF-8') as f:
        data1 = f.read()
        #print(data)
    leng = len(s)
    d = {}
    for i in range(leng):
        d.update({s[i]:data1.count(s[i])})
    print(d)
    with open("./1.txt",'r',encoding='UTF-8') as f:
        data = f.readlines()
    len_data = len(data)
    

    在这里插入图片描述
    2 字符串中每个字分别为B M E S的概率

    #字符串中每个字分别为B M E S的概率
    R = []     #下面计算的映射矩阵
    for i in range(leng):
        B,M,E,S =0,0,0,0
        for j in range(len_data):
            if s[i] == data[j][0] and data[j][2] == 'B':
                B += 1
            if s[i] == data[j][0] and data[j][2] == 'M':
                M += 1
            if s[i] == data[j][0] and data[j][2] == 'E':
                E += 1
            if s[i] == data[j][0] and data[j][2] == 'S':
                S += 1
        r = [B/data1.count(s[i]),M/data1.count(s[i]),E/data1.count(s[i]),S/data1.count(s[i])]
        R.append(r)
        # print(s[i], '分别为B M E S 的次数:')
        # print(B, '  ', M, '  ', E, '  ', S)
        # print(s[i], '分别为B M E S 的概率:')
        # print(B/data1.count(s[i]), '  ', M/data1.count(s[i]), '  ', E/data1.count(s[i]), '  ', S/data1.count(s[i]))
    
    

    在这里插入图片描述

    2 统计当某一个字分别为B,M,E,S的状态出现时,上一个字的状态为B,M,E,S时的个数

    z_tai = []
    P = []
    for i in range(leng):
        B_B,B_M,B_E,B_S =0,0,0,0
        M_B, M_M, M_E, M_S = 0, 0, 0, 0
        E_B, E_M, E_E, E_S = 0, 0, 0, 0
        S_B, S_M, S_E, S_S = 0, 0, 0, 0
        sum_B,sum_M,sum_E,sum_S = 0,0,0,0
        z_tai = []
        for j in range(1,len_data):
            if s[i] == data[j][0] and data[j][2] == 'B' and data[j - 1][2] == 'B':
                B_B += 1
            if s[i] == data[j][0] and data[j][2] == 'B' and data[j - 1][2] == 'M':
                B_M += 1
            if s[i] == data[j][0] and data[j][2] == 'B' and data[j - 1][2] == 'E':
                B_E += 1
            if s[i] == data[j][0] and data[j][2] == 'B' and data[j - 1][2] == 'S':
                B_S += 1
            sum_B = B_B + B_M + B_E + B_S
            if s[i] == data[j][0] and data[j][2] == 'M' and data[j - 1][2] == 'B':
                M_B += 1
            if s[i] == data[j][0] and data[j][2] == 'M' and data[j - 1][2] == 'M':
                M_M += 1
            if s[i] == data[j][0] and data[j][2] == 'M' and data[j - 1][2] == 'E':
                M_E += 1
            if s[i] == data[j][0] and data[j][2] == 'M' and data[j - 1][2] == 'S':
                M_S += 1
            sum_M = M_B+M_M+M_E+M_S
    
            if s[i] == data[j][0] and data[j][2] == 'E' and data[j - 1][2] == 'B':
                E_B += 1
            if s[i] == data[j][0] and data[j][2] == 'E' and data[j - 1][2] == 'M':
                E_M += 1
            if s[i] == data[j][0] and data[j][2] == 'E' and data[j - 1][2] == 'E':
                E_E += 1
            if s[i] == data[j][0] and data[j][2] == 'E' and data[j - 1][2] == 'S':
                E_S += 1
            sum_E = E_B+E_M+E_E+E_S
    
            if s[i] == data[j][0] and data[j][2] == 'S' and data[j - 1][2] == 'B':
                S_B += 1
            if s[i] == data[j][0] and data[j][2] == 'S' and data[j - 1][2] == 'M':
                S_M += 1
            if s[i] == data[j][0] and data[j][2] == 'S' and data[j - 1][2] == 'E':
                S_E += 1
            if s[i] == data[j][0] and data[j][2] == 'S' and data[j - 1][2] == 'S':
                S_S += 1
            sum_S = S_B+S_M+S_E+S_S
        tem = [B_B,B_M,B_E,B_S,M_B,M_M,M_E,M_S,E_B,E_M,E_E,E_S,S_B,S_M,S_E,S_S]
        tem1 =[sum_B,sum_M,sum_E,sum_S]
        for z in range(len(tem1)):
            if tem1[z] == 0:
                z_tai.append([0,0,0,0])
            else:
                z_tai.append([tem[z*4]/tem1[z],tem[z*4+1]/tem1[z],tem[z*4+2]/tem1[z],tem[z*4+3]/tem1[z]])
    
        #z_tai.append([[B_B/sum_B,B_M/sum_B,B_E/sum_B,B_S/sum_B],[M_B/sum_M,M_M/sum_M,M_E/sum_M,M_S/sum_M],[E_B/sum_E,E_M/sum_E,E_E/sum_E,E_S/sum_E],[S_B/sum_S,S_M/sum_S,S_E/sum_S,S_S/sum_S]])
        print(s[i], '上一个字状态BMES的概率:')
        print(z_tai)
        P.append(z_tai)
    
    

    在这里插入图片描述4 统计当字符串中的某一个字出现在语料库时,下一个字的状态分别为为B,M,E,S同时出现的概率

    w_hou = []
    for i in range(1):
        B, M, E, S = 0, 0, 0, 0
        count = 0
        hou = []
        for j in range(1, len_data):
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'B':
                B += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'M':
                M += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'E':
                E += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'S':
                S += 1
        #print(s[0], '句首首个子前面为空时 B M E S 的概率:')
        count = data1.count(s[0])
        tem = [B, M, E, S]
        for z in range(4):
            if tem[z] == 0:
                hou.append(0)
            else:
                hou.append(tem[z]/count)
    w_hou.append(hou)
    
    for i in range(leng-1):
        B,M,E,S =0,0,0,0
        count = 0
        hou = []
        for j in range(len_data-1):
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'B':
                B += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'M':
                M += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'E':
                E += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'S':
                S += 1
    
        #print(s[i],'出现时,语料库中下一个字分别为B M E S 与字符串下一个字相同的概率:')
        count = data1.count(s[i])
        tem = [B,M,E,S]
        count = data1.count(s[0])
        tem = [B, M, E, S]
        for z in range(4):
            if tem[z] == 0:
                hou.append(0)
            else:
                hou.append(tem[z]/count)
        w_hou.append(hou)
    

    这个好像求过

    #统计当字符串中的某一个字出现在语料库时,
    #上一个字的状态分别为为B,M,E,S同时出现的个数
    # print(s[0], '出现时,语料库中下一个字分别为B M E S 与字符串下一个字相同的次数:')
    # print(0, '  ', 0, '  ', 0, '  ', 0)
    # for i in range(1,leng):
    #     B,M,E,S =0,0,0,0
    #     count = 0
    #     for j in range(1,len_data):
    #         if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'B':
    #             B += 1
    #         if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'M':
    #             M += 1
    #         if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'E':
    #             E += 1
    #         if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'S':
    #             S += 1
    #
    #     print(s[i],'出现时,语料库中下一个字分别为B M E S 与字符串下一个字相同的次数:')
    #     print(B, '  ', M, '  ', E, '  ', S)
    
    #统计当字符串中的某一个字出现在语料库时
    #上一个字的状态分别为为B,M,E,S同时出现的概率
    

    5计算这个w前
    在这里插入图片描述

    #计算第一个字的状态
    w_qian =[]
    qian =[]
    for i in range(1):
        B, M, E, S = 0, 0, 0, 0
        count = 0
        for j in range(1, len_data):
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'B':
                B += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'M':
                M += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'E':
                E += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'S':
                S += 1
        #print(s[0], '句首首个子前面为空时 B M E S 的概率:')
        count = data1.count(s[0])
        tem = [B, M, E, S]
        for z in range(4):
            if tem[z] == 0:
                qian.append(0)
            else:
                qian.append(tem[z]/count)
    w_qian.append(qian)
    
    for i in range(1,leng):
        B,M,E,S =0,0,0,0
        count = 0
        qian =[]
        for j in range(1,len_data):
            if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'B':
                B += 1
            if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'M':
                M += 1
            if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'E':
                E += 1
            if s[i] == data[j][0] and s[i-1] == data[j-1][0] and data[j-1][2] == 'S':
                S += 1
    
        #print(s[i],'出现时,语料库中上一个字分别为B M E S 与字符串上一个字相同的概率:')
        count = data1.count(s[i])
        tem = [B,M,E,S]
        for z in range(4):
            if tem[z] == 0:
                qian.append(0)
            else:
                qian.append(tem[z]/count)
        w_qian.append(qian)
    #print(w_qian)
    #希腊的经济结构较特殊   
    

    在这里插入图片描述
    6 计算w后的
    在这里插入图片描述

    #统计当字符串中的某一个字出现在语料库时,下一个字的状态分别为为B,M,E,S同时出现的概率
    w_hou = []
    for i in range(1):
        B, M, E, S = 0, 0, 0, 0
        count = 0
        hou = []
        for j in range(1, len_data):
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'B':
                B += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'M':
                M += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'E':
                E += 1
            if s[0] == data[j][0] and data[j-1][0] in '。”,、' and data[j][2] == 'S':
                S += 1
        #print(s[0], '句首首个子前面为空时 B M E S 的概率:')
        count = data1.count(s[0])
        tem = [B, M, E, S]
        for z in range(4):
            if tem[z] == 0:
                hou.append(0)
            else:
                hou.append(tem[z]/count)
    w_hou.append(hou)
    
    for i in range(leng-1):
        B,M,E,S =0,0,0,0
        count = 0
        hou = []
        for j in range(len_data-1):
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'B':
                B += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'M':
                M += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'E':
                E += 1
            if s[i] == data[j][0] and s[i+1] == data[j+1][0] and data[j+1][2] == 'S':
                S += 1
    
        #print(s[i],'出现时,语料库中下一个字分别为B M E S 与字符串下一个字相同的概率:')
        count = data1.count(s[i])
        tem = [B,M,E,S]
        count = data1.count(s[0])
        tem = [B, M, E, S]
        for z in range(4):
            if tem[z] == 0:
                hou.append(0)
            else:
                hou.append(tem[z]/count)
        w_hou.append(hou)
    

    7计算映射矩阵

    S = []
    lu_jing = []
    for i in range(1):
        ying_B = w_qian[i][0]+w_hou[i][0]+R[i][0]
        ying_M = w_qian[i][1]+w_hou[i][1]+R[i][1]
        ying_E = w_qian[i][2]+w_hou[i][2]+R[i][2]
        ying_S = w_qian[i][3]+w_hou[i][3]+R[i][3]
        s = [ying_B,ying_M,ying_E,ying_S]
        S.append(s)
        lu_jing.append([0,0,0,0])
    for i in range(1,leng):
        max1 = [P[i][0][0]*S[i-1][0], P[i][0][1]*S[i-1][1], P[i][0][2]*S[i-1][2],P[i][0][3]*S[i-1][3]]
        max1_B = max(max1)
        ying_B = max1_B+w_qian[i][0] + w_hou[i][0] + R[i][0]
        lu_B = max1.index(max1_B)
    
        max1 = [P[i][1][0] * S[i - 1][0], P[i][1][1] * S[i - 1][1], P[i][1][2] * S[i - 1][2],P[i][1][3] * S[i - 1][3]]
        max1_M = max(max1)
        ying_M = max1_M + w_qian[i][1] + w_hou[i][1] + R[i][1]
        lu_M = max1.index(max1_M)
    
        max1 = [P[i][2][0] * S[i - 1][0], P[i][2][1] * S[i - 1][1], P[i][2][2] * S[i - 1][2],P[i][2][3] * S[i - 1][3]]
        max1_E = max(max1)
        ying_E = max1_E + w_qian[i][2] + w_hou[i][2] + R[i][2]
        lu_E = max1.index(max1_E)
    
        max1 = [P[i][3][0] * S[i - 1][0], P[i][3][1] * S[i - 1][1], P[i][3][2] * S[i - 1][2],P[i][3][3] * S[i - 1][3]]
        max1_S = max(max1)
        ying_S = max1_S + w_qian[i][3] + w_hou[i][3] + R[i][3]
        lu_S = max1.index(max1_S)
    
        lu_jing.append([lu_B,lu_M,lu_E,lu_S])
        s = [ying_B, ying_M, ying_E, ying_S]
        S.append(s)
    

    在这里插入图片描述
    8回溯路径可以转换为状态标记,0代表B,1代表M,2代表E,3代表S

    hui_su=[]
    ind = S[-1].index(max(S[-1]))
    hui_su.append(ind)
    for i in range(len(lu_jing)-1,0,-1):
        tem = lu_jing[i][ind]
        hui_su.append(tem)
        ind = tem
    hui_su = hui_su[::-1]
    hui_zhuang =[]
    for i in hui_su:
        if i == 0:
            hui_zhuang.append('B')
        if i == 1:
            hui_zhuang.append('M')
        if i == 2:
            hui_zhuang.append('E')
        if i == 3:
            hui_zhuang.append('S')
    jie_gou =''
    ind_1 = []
    for i in range(leng):     #每一个字一个状态
        if hui_zhuang[i] == 'E' or hui_zhuang[i] =='S':
            ind_1.append(i)
    for i in range(leng):
        print(ss[i],end='')
        if i in ind_1:
            print('/',end='')
    

    结果
    在这里插入图片描述感觉效率很慢,希望有大佬带带小白
    写得比较简陋~感觉 给给意见修改 没动力修改 累了哈哈

    展开全文
  • 可以是是一个结构化数据序列,因此选择了解决结构化序列预测问题最有效的条件随机场模型CRFs。通过对大量历史数据进行学习,分析出数据的自身规律以及关联关系,使计算机得以自动检测异常的能力。实验结果表明了该...
  • CRFSegment 用CRF++实现基于条件随机场模型的中文分词 更多详细介绍可以查看文章:
  • 一种基于分层高阶条件随机场模型的道路场景图像分割算法,杨旸,谢明远,本文提出一种基于分层高阶条件随机场模型的道路场景图像分割方法,首先对目标图像提取多类纹理特征,构建像素级的一元势函数和成
  • 机器学习工具——条件随机场模型,包含例子和文档
  • 条件随机场模型与双向LSTM

    千次阅读 2018-05-10 10:41:30
    条件随机场模型CRF(Conditional Random Field) CRF是一种判别式模型,判别式模型是对条件分布进行建模,生成式模型是对联合分布进行建模。判别式模型评估对象是最大化条件概率p(y|x)并直接对其建模,生成式模型...

    条件随机场模型CRF(Conditional Random Field)
    CRF是一种判别式模型,判别式模型是对条件分布进行建模,生成式模型是对联合分布进行建模。判别式模型评估对象是最大化条件概率p(y|x)并直接对其建模,生成式模型评估对象是最大化联合概率p(x,y)并对其建模。
    典型的生成式模型有N-Gram语言模型,隐马尔科夫模型,马尔科夫随机场,朴素贝叶斯模型,LDA和最近很火的生成对抗网络。生成式模型先经过贝叶斯转换成Y = argmax p(y|x) = argmax p(x|y)*p(y),然后分别学习p(y)和p(x|y)的概率分布,主要通过极大似然估计的方法学习参数,如NGram、HMM、Naive Bayes,变分自编码等编码器。
    判别式模型直接通过解在满足训练样本分布下的最优化问题得到模型参数,主要用到拉格朗日乘算法,梯度下降算法,典型的判别式模型有最大熵模型,条件随机场模型,逻辑回归模型(LR),支持向量机(SVM),以及现在很流行的神经网络分类模型(LSTM,CNN)等。
    判别式模型是监督训练,有标签,生成式模型是无监督训练,无标签。
    判别式模型可以加入任何特征组合,选择特征比较灵活;
    生成式模型需要将特征引入马尔科夫链中。
    条件随机场模型主要用于序列标注问题,比如用CRF进行命名实体识别。
    以序列标注为例,比如这句话:“Bob drank coffee at Starbucks”,给这句话的每一个单词标注词性,一个简单的办法是将序列标注
    问题转换为分类问题(因为词性的数量是有限的),但是把他当成分类问题就相当于认为词性之间是相互独立的,实际上对一个序列来说,词性的出现并不是相互独立的,而是相互影响的。比如说,第二个词drank是动词,那后面紧跟的那个词是动词的可能性就很小,是名词的可能性很大,所以这是一个条件概率,不是相互独立的,把序列标注问题看成分类问题是不合理的(LSTM做序列标注就是一个分类问题,后面详细说LSTM做序列标注的优缺点)。
    而CRF就可以解决这个问题,在CRF之前有HMM,最大熵模型等方法,基本上也都是基于联合概率的方法,是生成式模型。
    CRF可以认为是基于统计的,以上面的句子为例,上面句子的标注方法有3^5=273种(假设只有名词,动词,介词三种词性),根据人的感觉,显然(名词,动词,名词,介词,名词)这种标注方式可能性最大,而(名词,动词,动词,动词,名词)这种标注方式的可能性很小,因为这不符合语法规则。
    我们要在这么多可能的标注中找一个可能性最大的标注方式当做正确的标注方式。
    怎么判断标注的可能性的大小呢(也就是标的靠不靠谱)
    假设我们给上面的所有可能的标注打分,越靠谱的打分越高,越不靠谱的打分越低,也就是说我们给(名词,动词,名词,介词,名词)这种正确的标注打高分,给(名词,动词,动词,动词,名词)这种动词相连的标注打负分。

    上面所说的动词相连就是一个特征函数,我们可以做一个特征函数集合,用这个特征函数集合给一个标注序列打分,并选出最靠谱的标注。也就是说,每一个特征函数都可以对这一个标注序列打分,将这些特征函数对同一个标注序列的打分综合起来,就是这个标注序列的综合评分。
    如果有5个特征集合,对上面的273中标注方式进行打分,那么第一种标注方式通过特征集和得到5各大分,第二个标注方式也得到5个打分,。。。,第273个标注方式也有5个打分,那么对这句话的标注用这种方法一共得到了(5+5+5+5+…+5)=273*5个打分,选择打分最高的当成对该序列的正确词性标注结果。

    如何定义CRF的特征函数
    现在,我们正式地定义一下什么是CRF中的特征函数,所谓特征函数,就是这样的函数,它接受四个参数:
    句子S:就是我们要标注此行的句子序列
    i:句子中的第i个单词
    I_i:已经标好词性的标注序列第i个词的词性(表示要评分的标注序列给第i个单词标注的词性)
    I_i-1:已经标号词性的标注序列的第i-1个词的词性(表示要评分的标注序列给第i-1个单词标注的词性)
    特征函数的输出值是0或1,0表示要平分的标注序列不符合这个特诊函数所代表的特征,1表示要平分的标注序列符合这个特征函数所代表的特征
    特征函数包括两种,转移特征和状态特征,假设每个当前词第i个词有M个特征,这M个特征由J个转移特征和L个状态特征组成,即M=J+L
    转移特征针对的是词的前后之间的限定,每个当前词都有J个特征,将这J个特征得到的打分求和是这个当前词的总打分。
    举个例子:
    我们对“Bob drank coffee at Starbucks”这句话进行词性标注,先设定转移特征函数
    假设我们的词性集合里只有三种词性(名词,动词,介词)
    转移特征函数:
    当前词是drank
    T1:if(当前标注=名词 and 前一个词的标注=动词)return 1 else 0
    T2:if(当前标注=动词 and 前一个标注=名词) return 1 else 0
    T3:if(当前标注=介词 and 前一个标注=名词) return 1 else 0
    T4:if(当前标注=名词 and 前一个标注=名词)return 1 else 0
    这里设定了三个转移特征函数,转移特征函数由当前输出词性和上一个词的词性决定,当然也可以由当前词和上一个词性以及上上一个词性决定,那样转移特征函数的个数就增加了。
    用这四个特征函数去套标注的序列,
    比如我给上面那句话标注的是‘名词,名词,动词,介词,名词’,用上面的四个转移特征函数给这个标注序列打分,
    当i=drank时,T1=0,T2=0,T3=0,T4=1 T1+T2+T3+T4=1
    当i=coffe时,T1=0,T2=1,T3=0,T4=0 T1+T2+T3+T4=1
    当i=at时,T1=0,T2=0,T3=0,T4=0, T1+T2+T3+T4=0
    当i=Starbucks时, T1=0,T2=0,T3=0,T4=0, T1+T2+T3+T4=0
    所以这个句子的这种标注方式在特征函数的约束下得到的打分为 1+1+0+0=2
    再看另一种标注方式‘名词,动词,名词,介词,名词’
    当i=drank时,T1=0,T2=1,T3=0 ,T4=0 T1+T2+T3+T4=1
    当i=coffe时,T1=1,T2=0,T3=0 ,T4=0, T1+T2+T3+T4=1
    当i=at时,T1=0,T2=0,T3=1,T4=0, T1+T2+T3+T4=1
    当i=Starbucks时, T1=0,T2=0,T3=0,T4=0, T1+T2+T3+T4=0
    在该转移特征函数的约束下,这种标注方式得到的打分为 1+1+1+0=3
    3>2,所以第二种标注方式要比第一种标注方式合理一点,在上面我们知道这5个词共有3^5=273中标注方式,对每一种标注序列都由上面的四个特征函数来打分,取分数最高的标注序列作为正确的标注序列。当然转移特征函数是人为设计的,如果你有足够的耐心设计足够多且精准的特征函数,模型的训练效果也会变得很好。
    下面介绍L个状态特征函数sk(yi,X,i)
    状态函数表示第i个词的标记概率,每个当前词都有L个状态特征函数
    所谓状态指的是需要标注的种类,在我们的例子中,有3个词性种类,也就是每个当前词有3中状态,状态函数就是计算当前词每种状态的概率
    当i=drank时,
    L1:P(i=名词)=0.3 通过其他算法(如分类算法)计算出来的
    L2:P(i=动词)=0.6 通过其他算法(如分类算法)计算出来的
    L3:P(i=介词)=0.1 通过其他算法(如分类算法)计算出来的
    每个当前词有三种状态特征函数,每一个特征函数都对应着一个权重,比如L1,L2,L3分别对应μ1,μ2,μ3
    上面介绍的转移特征函数和状态特征函数可以总结成一个公式
    ΣT(Σj=1Jλjtj(li1,li,s,i)+Σk=1Kμks(li,s,i))
    T表示一个句子的词的个数,第一项是转移特征函数和他对应的权重,第二项是状态特征函数和他对应的权重。下面为了方便会把这两个特征函数合并成一个特征函数。

    Note: 这里我们的特征函数仅仅依靠当前单词的标签和前一个单词的标签对标注序列进行判断,这样建立的CRF也叫作线性链CRF,是CRF中一种简单的情况。

    从特征函数到概率
    定义好一组特征函数后,我们要给每一个特征函数fj赋予一个权重lamdaj。只要有一个句子s和一个标注好的序列l(这是小写的L),就可以用上面的特征函数集合对标注序列I进行打分。
    这里写图片描述
    上面的公式是对已经标注的序列l的打分,(这个标注不管是不是对的),m表示特征函数集合中特征函数的个数,第一个求和行数表示每一个特征函数对这个标注序列进行打分,并把这些打分加起来作为特征函数集合对这个标注祖列的评分,如果这个标注序列符合特征函数集合中的多个函数所代表的特征,那么这个标注是正确的可能性就大,反之,如果这个标注不符合特征函数集合中所有特征函数所代表的特征,那么这个标注就很不靠谱,这个标注是错误的可能性就很大。第二个求和表示一个标注序列有n 个词,求句子的每个单词的特征值的和。

    对这个分数进行指数化和标准化,我们就可以得到标注序列l的概率值p(l|s),如下所示:
    这里写图片描述
    其中 l’指的是对同一个句子进行标注的所有可能的标注结果,比如上面的例子一共有273*5中标注方式,那上面的公式l’就有273*5中可能的结果,把这些可能的打分求和就是上面公式的分母。

    以上面的句子为例,假设特征函数集合中一共有四个特征函数,f1,f2,f3,f4.
    f1=1 如果当l_i是“副词”并且第i个单词以“ly”结尾;其他情况f1=0;不难想到,f1特征函数的权重λ1应当是正的。而且λ1越大,表示我们越倾向于采用那些把以“ly”结尾的单词标注为“副词”的标注序列
    f2=1 如果i=1,l_i=动词,并且句子s是以“?”结尾;其他情况f2=0;同样,λ2应当是正的,并且λ2越大,表示我们越倾向于采用那些把问句的第一个单词标注为“动词”的标注序列。
    f3=1 如果当l_i-1是介词,l_i是名词时;其他情况f3=0;λ3也应当是正的,并且λ3越大,说明我们越认为介词后面应当跟一个名词。
    f4=1 如果l_i和l_i-1都是介词;其他情况f4=0;同时f4对应的权重是负值,并且λ4的绝对值越大,表示我们越不认可介词后面还是介词的标注序列

    好了,一个条件随机场就这样建立起来了,让我们总结一下:
    为了建一个条件随机场,我们首先要定义一个特征函数集,每个特征函数都以整个句子s,当前位置i,位置i和i-1的标签为输入。然后为每一个特征函数赋予
    一个权重,然后针对每一个标注序列l,对所有的特征函数加权求和,必要的话,可以把求和的值转化为一个概率值。

    CRF的训练过程:

    以中文为例,给定一句话,首先将其中的人名,地名,机构名等给以特殊符号标记,比如(B-PER,M-PER,E-PER,S-PER)表示人名的开头字,中
    间字,结尾字,单个字,以此类推。将训练预料中的所以实体都标记好,接下来是确定模板,也就是特征函数,就是上面提到的1,f2,f3,f4。训练完成后,就
    确定了各个特征函数的权重,再输入一个句子就会根据权重将这些句子标记。
    总之,分三步走:
    step1:先确定特征函数
    step2:在给定的数据集上确定要学习的参数(权重)
    step3:用学习好的模型对新数据进行序列标注或序列求概率问题

    BiLSTM+CRF
    我们知道,LSTM对序列问题处理的很好,也有方法用LSTM左词性标注,当然这种方法是把序列标注问题看成一个分类问题,采用的是LSTM+softmax架构。
    有人说,LSTM的输出不仅和当前的输入有关,还和上一时刻的隐藏层输出有关,这个性质不是刚好符合序列标注问题的序列性的特点吗:当前的词的标注和前面的词的标注相关。
    在这里解释一下这个问题,LSTM当前时刻的输出由当前时刻的输入和上一时刻隐藏层的输出决定,仍是以词性标注为例,用LSTM来做词性标注,输入的是词向量,输出的是当前词的词性,这个词性由当前时刻输入的词向量和上一时刻的隐藏层输出决定,但是,当前时刻的输出和上一时刻的输出没有任何关系!! 也就是说,不管上一时刻的词性是什么,都不影响当前时刻的标注的判断!分类问题的类别之间肯定是相互独立的。有人会说,LSTM不是有记忆性嘛,上一时刻的隐藏层的信息已经传递给当前时刻了,当前时刻包含了上一时刻的信息,怎么能说当前时刻的输出和上一时刻没有关系呢?答:上一时刻的信息是由上一时刻的词向量产生的信息,而不是由上一时刻的词性产生的信息,当然,上一时刻的信息对当前的词性的判断确实会产生一定影响,但是上一时刻由词向量产生的信息对当前时刻的词性的判断的约束力是很弱的,上一时刻的词向量对这一时刻的词性的约束力要远远小于上一时刻的词性对这一时刻的词性的约束力,比如说,对“Bob drank coffee at Starbucks”这句话进行词性标注,当前时刻是’coffee ‘,用LSTM来做可能会保证这个句子整体的打分比较高,但是无法保证句子内部词性与词性之间的关联,比如LSTM可能会产生‘动词,动词’这样的标注方式,但是CRF就不可能产生这样的错误。也就是说,LSTM对序列问题的处理有强大的拟合能力,但是照顾不到内部的每个个体,无法对每个时刻的输出结果进行约束,这就是用LSTM+softmax架构做序列标注问题的弱点,及我们需要在LSTM后加CRF层的原因。
    总之:用LSTM+softmax做序列标注问题是把序列标注为看成分类问题,而分类问题的类别之间是相互独立的,但是对序列标注来说,每个当前词的标注都是和上一时刻的标注结果有关的,这就是把序列标注问题看成分类问题的先天劣势,为了克服这一问题同时要用上LSTM强大的数据拟合能力,就有人提出了LSTM+CRF的架构。
    不同于LSTM+softmax的分类架构,LSTM+CRF的架构的核心仍然是CRF模型,依赖的仍然是两类特征函数,LSTM在这里的作用就是用来求状态特征函数,LSTM的输出作为CRF模型中的状态特征函数那一项(每个词在n个标注上的概率分布),而转移特征函数那一项仍是认为设计的特征函数。

    BiLSTM+CRF中的CRF与传统的CRF之间的区别
    通过查看相关代码,我们知道BiLSTM+CRF模型是不需要设计任何特征的,那不用设计特征怎么体现CRF转移函数的约束能力呢?在BiLSTM+CRF模型中,CRF部分的转移函数体现在一个转移矩阵上,这个转移矩阵最初的值是随机初始化产生的,他是一个[class,class]大小的矩阵,不用认为设计特征也就不是0,1值这样的特征,他的值完全是由网络学习出来的,实际上这个转移矩阵是传统CRF公式中转移函数对应的权重和转移特征函数的结合。那这个转移矩阵是如何做到对相邻词性的约束的呢?这就要看BiLSTM中CRF的输入,这里CRF输入的是LSTM的输出,也就是每个词的词性标注的概率分布,根据真实标签在概率分布矩阵中找出真实标签位置对应的预测标签,将预测标签路径和真实标签路径比较,产生整个句子的误差和,根据这个误差和进行反向传播训练网络。
    转移矩阵:类别和类别之间的转移矩阵,p(i,j)就是第i个标签后面接第j个标签的概率,通过学习会得到这样的规律,这个词性后面出现某个词性的概率很大,某个词性后面出现某个词性的概率非常小。
    CRF的求解
    这里写图片描述
    在上面的分析中我们要计算一句话的打分的最大值,只能将每个词的每一种标注结果一一连接起来,如上图所示,所有的路径的打分都要一一计算,可以想象这个计算量非常庞大,如何减少计算量并找到最优路径,这是维特比算法研究的问题。这个找最优路径的过程就是CRF解码的过程,也就是说在训练好模型后在已知权重下仍然需要在所有可能的路径里选择一条最优的路径,这个解码过程不在训练过程中,在测试过程中。
    维特比算法寻找最优路径(Viterbi)
    维特比算法的思想是利用动态规划来减少需要计算的路径量,避免重复计算
    维特比算法的每一步选择都保存了之前所有步骤到当前步骤的最小总代价或最大价值以及当前代价情况下前继步骤的选择。依次完成所有步骤后,通过回溯的方法选择最优路径。
    简单来说,先计算从开始到第一个词的最大概率,得到最大概率对应的位置,将当前得到的最大概率和第一个词到第二个词所有可能概率相加,选概率和最大的位置作为第二个词的词性,在看第二个词到第三个词的概率,将现在得到的概率和第二个词到第三个词的所有概率依次相加,选概率和最大的位置作为第三个词的词性,直到这句话结束。

    HMM
    隐马尔可夫模型是一种概率图模型,概率图模型一般用来处理序列数据(如文本,语音,时序序列等),是生成式模型,对联合概率进行建模,从给定数据中学习数据的分布,获得的信息比判别式模型(对条件概率进行建模的模型)要多,对数据要求高,你的训练数据要反应数据的全貌,学习起来速度慢。
    这里写图片描述
    这个图反映了生成式模型和判别式模型的差别,判别式模型学习到一条分别线,生成式模型学习到的是整个数据的分布情况,不仅仅是一条分界线,还会有方差,均值之类的信息(完全反应数据分布)。
    隐马尔可夫模型处理的数据坑定要符合马尔科夫性:当前时刻的输出只和当前时刻的输入和前一时刻的输入有关,和t-2时刻及之前的时刻的输入无关。
    HMM五要素:
    隐藏状态集:Y={y1,y2,…yn},比如词性标注中要标注的词性,n表示词性的个数
    观测状态集:O={o1,o2,…,ot},比如一个句子,这个句子有t个词
    状态转移矩阵:比如从y1这个词性到y8这个词性概率,就是y1后面的词标记为y8的概率
    观测矩阵:就是一个句子中的每个词所有可能的标记,每个标记(词性)对应的概率
    初始概率分布:开始训练时状态转移矩阵的初始化得到的概率。
    HMM与CRF的区别
    由于马尔科夫假设的制约,HMM只能有转移矩阵这一种特征无法加入其它特征,而词性标注等序列问题除了和上一时刻的状态有关,还和上下文,语义信息等其它特征有关,这种情况HMM就没办法解决,CRF就没有这个问题,他可以很容易的特征融合,CRF不仅有转移函数这种特征,还可以融合新特征,新的特征可以加在状态特征函数那一项。

    展开全文
  • crf条件随机场模型--matlab源码

    热门讨论 2010-05-07 17:24:48
    crf条件随机场模型--matlab源码
  • 利用条件随机场模型进行中文分词

    千次阅读 2016-09-21 15:45:11
    利用条件随机场模型进行中文分词

    http://www.cnblogs.com/liufanping/p/4899842.html

          中文分词的方法非常多,基于词库是最基本的,但是当前各大互联网公司基本上不会仅仅依赖于词库的分词,一般以机器学习的分词为主,词库分词的方式为辅。在很久以前,我提过利用隐马尔科夫模型进行中文分词,条件随机场其实是隐马尔科夫模型的一次升级版本,网上有很多关于条件随机场模型的分词,但是基本上很难看懂,也许是论文的缘故,那些作者习惯了一上来就是一堆复杂的公式,我也看了一些,获取有些作者自己都没搞懂,就弄了一篇论文。本文从实践的角度,提供一种基于条件随机场模型的中文分词解决方案。

          第一步:准备语料库。

          首先,你必须得准备一个已经分好词的语料库,用于机器学习,如下图所示:

         条件随机场分词1

          如果你没有,可以在这里下载

          第二步:初步语料库特征学习

          和隐马尔科夫模型一样,条件随机场也是基于学习字的状态来进行状态分析的,对于一个字来说,它有4个状态,分别是:词头(Begin)、词中(Middle)、词尾(End)、单字成词(Single),简称B,M,E,S。

          因此需要把第一步的语料库,分析出每一个字的状态,例如:“收益”需要改进为:“收|B 益|E”, 通过将语料库的每一个分好的词,添加其状态信息,如下图所示:

          条件随机场分词2

          当然,如果你比较懒,也没有关系,我这里提供好已经分析完毕的数据,可以在这里下载

          第三步:特征学习

          有了第二步的初步学习,第三步就相对容易多了,特征学习是整个过程中非常重要的部分,在进行特征学习之前,必须弄清楚一个问题,要学习哪些特征?如下:

          1. 这一个字一共在语料库中出现的次数是多少?例如“我”字一共出现了256次。

          2. 这一个字,出现为词头(B)、词中(M)、词尾(E)、单字成词(S)的概率是多少?即为在256出现“我”字的时候,“我”作为词头的概率是多少,词中的概率是多少,依次类推。

          3. 这一个字,当为词头(B)的时候,它转移到下一个词的状态概率是多少?每一个字都有属于自己的状态,但是这个字的后面一个字,也有属于自己的状态,那么当前字的状态,到下一个字的状态(或许是B、M、E、S之一)的概率是多少。例“我”字,当“我”的状态为B的时候,后面跟的字中,状态为B的为0个,状态为M的为10个,状态为E的为20个,状态为S的0个。依次统计“我”的状态为M、E、S的时候,下一字的状态。此过程俗称:状态转移概率计算。此项会形成一个4X4的矩阵。

          截至前面三个特征学习,也许你会感觉与隐马尔科夫模型的方式没有太大区别,但是从理论上研究,条件随机场的准确率一定是高于隐马尔科夫模型的。是因为条件随机场会学习上下文关系,也就是多计算了,当一个字出现的时候,它的前一个字是什么,后一个字是什么,这个概率是多少,也就是我们第四个特征学习。

         4. 这一个字出现的时候,后面字出现的是什么,概率为多少?例如当状态为B的“我”,下一个字是“们”的概率为67.9%,例如状态为S的“我”,上一个字是“的”的概率为21%,下一个字是“爱”的概率为17.8%等等,记录每一个字在四种状态下上下文关系,是非常重要的一步。这一步中,我们仅仅记录了上一个字和下一个字的上下文关系,条件允许的情况下,我们可以记录上两个字和下两个字的上下文关系。

         利用代码,就是如下示例:

    复制代码
    /**
         * Feature for each word.
         * 
         * @author liufanping
         *
         */
        private static class Feature {
    
            /**
             * The State transition matrix
             */
            private Double[][] transfer;
    
            /**
             * The observation sequence transition matrix
             */
            private Double[] status;
    
            /**
             * The predecessor State
             */
            private TreeMap<Integer, Double> preStatus;
    
            /**
             * The next status
             */
            private TreeMap<Integer, Double> nextStatus;
    
            /**
             * Total count.
             */
            private int cnt;
    
            ... ...
    
        }
    复制代码

         上面代码中需要注意两个事项:

         1. 每一个字都会有这样一个特征类,可以利用一个哈希表,key存字,value存其特征。

         2. 记录前后上下文的preStatus ,key是上一个字和当前字状态的组合,nextStatus,key是下一个字和当前字状态的组合,例如当前字是“我”,当前字的状态是B,下一个字可能是“们”,在nextStatus中,key就是“们_B”的哈希值,value均是出现这种情况的概率。

         我相信从语料库中学习这四个特征,应该不是一件很难的事情,自己根据描述完善代码即可。

         第四步:开始分词

         既然特征已经训练好了,怎么去给一个句子分词呢?例如用户输入“希腊的经济结构较特殊”,怎么就可以进行分词了呢?其实很简单,下面就是数学计算了。

         1. 将“希腊的经济结构较特殊”变成字符数组。即“希”、“腊”、“的”、“经”、“济”、“结”、“构”、“较”、“特”、“殊”。

         2. 取出每一个字对应特征(第三步产生的内容)。

         现在每一个字的特征以及取出来了,后面怎么办呢?我们先分析下,我们其实就是在给每一个字确定它是B、M、E、S四个状态中的哪一种,因此可以绘制一个矩阵。

         条件随机场分词3

         到这里,既然是矩阵,而且是求矩阵里面的一个路径,那么很容易想到维特比算法。到这里,我们只需要计算出“希”字在B、M、E、S的状态值,后面就游刃而解。

         我们设定矩阵中的值为S, S[字][当前状态]=MAX(P[上一个字任何状态][当前状态]*S[上一个字][任何一个状态])+W[前(后)一个字_当前状态][当前字]+R[当前状态概率]  (备注:R是特征二,P是特征三,W前是特征四的上文部分,W后是特征四的下文部分)

         例如“腊”字,在为状态B上的值为:S[腊][B]=MAX(P[B][B]*S[希][B],P[M][B]*S[希][M],P[E][B]*S[希][E],P[S][B]*S[希][S])+W前[希_B][腊]+W后[的_B][腊]+R[B],同理可以计算S[腊][M],S[腊][E],S[腊][S]。

         依次类推,可以计算出后面其它字的情况。由于“希”字出现在首字,不存在其它状态转移到其状态的概率,因此,S[希][B]=W前[_B][希]+W后[腊_B][希]+R[B],依次计算出“希”字其它值。

         上面过程,希望反复用研究下,研究透后,你会发现很简单,通过计算会得到如下矩阵:

        条件随机场分词4

        看到这里,你似乎已经看到分词的结果了,在矩阵中所有值的后面,都有一个小括号,里面存放的是路径,也就是这个值是通过上一个的哪一个值过来的(因为有计算max的过程,就会有路径选择),记录下来之后,以便于路径回溯。

        当得到这个矩阵之后,我们只需要将“殊”中的最大值取出,即为1.1867对应状态是End,来自上一字的状态0,也就是“特”字的Begin,再次查看“特”字来自于上一个字“较”的Single。因此,判别状态如下

        “希/B 腊/E 的/S 经/B 济/E 结/B 构/E 较/S 特/B 殊/E”

        翻译成分词结果就是“希腊 的 经济 结构 较 特殊”。

        完成的实现分词过程,如果你对此项有点模糊,建议看下维特比算法。

        写到最后,我也要感谢您能够看到最后,这是比较简单的一种利用条件随机场进行分词的方式,复杂的,可以在这个基础上进行优化升级。

        诚挚的谢意!

    展开全文
  • 该项目在小鼠V1皮质的体内双光子钙成像数据中应用条件随机场模型。 我们在此类成像数据上建立了CRF,以识别与特定外部刺激相对应的代表性神经元集合,并识别能够执行模式完成的核心神经元。 该代码库基于Jebara集团...
  • 其模型思想是,条件随机场模型对应一个无向图 ,,Y中的元素与无向图的顶点一一对应。在条件X下,随机变量的条件概率分布符合图的马尔科夫性质,即可称当前是一个条件随机场。条件随机场模型用于在给定需要标记的观察...
  • 条件随机场模型在多种自然语言处理任务中都取得了较好的效果,但手工特征制定的方式以及庞大的特征数量增加了模型建立的难度,降低了模型运算的速度,同时易使模型“过拟合”。为了解决上述问题,提出一种张量扩展的...
  • 条件随机场模型(CRF)

    千次阅读 2016-06-16 23:25:00
    ConditionalRandomField:条件随机场,一种机器学习技术(模型) CRF由John Lafferty最早用于NLP技术领域,其在NLP技术领域中主要用于文本标注,并有多种应用场景,例如: 分词(标注字的词位信息,由字构词)词性...
  • 4. 基于条件随机场模型的中文分词改进方法 4.1.改进分词速度 4.1.1 更改存储特征值的数据结构 在保存征值时,我们可以用字典、列表等数据结构来对结果保存。经过多次对不同数据结构的测试,发现在字典内嵌套的层...
  • 基于条件随机场模型是中文分词的常用方法,是一种利用语料库进行统计学习的方法。其一般会提供一个已经人为分好词的语料库,对输入的字符串进行字字匹配,统计字符串的每一个字在语料库中出现的次数,每一个字分别为...
  • 同上一篇《以序列标注为例学习隐马尔可夫模型HMM》一样,仍旧以序列标注问题为例。 序列标注问题是给定一个序列XXX,求一个函数fff,使得XXX通过fff映射得到想要的序列YYY,即: f:X→Y f:X \rightarrow Y f:X→Y 1...
  • 为提高中文语音合成的自然度,对文本的韵律结构体系进行研究,并提出一种基于条件随机场(CRF)的韵律结构预测方法. 从一个大规模人工标注的语料库中,选取由机器生成的分词标注特征和分级的韵律边界信息,利用CRF算法...
  • 条件随机场:是给定一组输入随机变量条件下另一组输出随机变量的条件概率分布模型,特点是输出随机变量构成马尔科夫随机场。 线性链条件随机场,由输入序列对输出序列预测的判别模型,形式为对数线性模型,学习方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,566
精华内容 626
关键字:

条件随机场模型