分词 订阅
分词就是具有动词及形容词二者特征的词,尤指以-ing或-ed,-d,-t,-en或-n结尾的英语动词性形容词,具有形容词功能,同时又表现各种动词性特点,如时态、语态、带状语性修饰语的性能及带宾词的性能。分词分为现在分词和过去分词两种,是一种非谓语动词形式。现在分词和过去分词主要差别在于:现在分词表示“主动和进行”,过去分词表示“被动和完成”(不及物动词的过去分词不表示被动,只表示完成)。分词可以有自己的状语、宾语或逻辑主语等。 展开全文
分词就是具有动词及形容词二者特征的词,尤指以-ing或-ed,-d,-t,-en或-n结尾的英语动词性形容词,具有形容词功能,同时又表现各种动词性特点,如时态、语态、带状语性修饰语的性能及带宾词的性能。分词分为现在分词和过去分词两种,是一种非谓语动词形式。现在分词和过去分词主要差别在于:现在分词表示“主动和进行”,过去分词表示“被动和完成”(不及物动词的过去分词不表示被动,只表示完成)。分词可以有自己的状语、宾语或逻辑主语等。
信息
结    构
现在分词doing,过去分词done
外文名
participle
语    法
非谓语动词形式
中文名
分词
特    征
具有动词及形容词二者特征
表    示
进行,完成,被动
分词分词的类型
一般式doing一般被动式 done完成式having done完成被动式having been done所有否定式都是在-ing前面加not,过去分词done
收起全文
精华内容
下载资源
问答
  • 分词

    千次阅读 2018-09-07 20:41:14
    对于西方拼音语言来说,从词之间由明确的分界符,而很多亚洲语言(如汉语、日语、韩语、泰语)词之间没有明确的分界符,因此需要先对句子进行分词,才能做进一步的自然语言处理(也适用于英文词组的分割、或者手写...

    对于西方拼音语言来说,从词之间由明确的分界符,而很多亚洲语言(如汉语、日语、韩语、泰语)词之间没有明确的分界符,因此需要先对句子进行分词,才能做进一步的自然语言处理(也适用于英文词组的分割、或者手写识别,平板电脑、智能手机手写时单词间的空格可能不清楚)。

    分词的输入是一串词,分词的输出是用分界符分割的一串词。

    分词的不一致性问题

    • 越界型错误:“北京大学生” -> “北京大学”、“生”
    • 覆盖型错误:“北京大学” -> “北”、“京”、“大”、“学”
    • 颗粒度的不一致性

    分词的颗粒问题

    • 在分词的同时,找到复合词的嵌套结构。如“北京”、“大学”、“北京大学”
    • 机器翻译:一般来讲,颗粒度大翻译效果好。如“北京大学”
    • 语音识别,网页搜索:一般来讲,颗粒度小效果好。如“北京”、“大学”

    中文分词是一个已解决问题,只要采用统计语言模型,效果差不到哪去。一般不同应用该有不同的分词系统,需要针对不同的应用设计实现专门的分词系统。 构造分词器时,更好的做法是让一个分词器同时支持不同层次的词的切分,由不同的应用自行决定切分的颗粒度。通常中文分词工作的重点是继续做数据挖掘,不断完善复合词的词典(新词发现)。

    基于字符串匹配的分词方法(“查字典”)

    此方法按照不同的扫描方式,逐个查找词库进行分词。根据扫描方式可细分为:正向最大匹配,反向最大匹配,双向最大匹配,最小切分(即最短路径);总之就是各种不同的启发规则。

    全切分方法

    它首先切分出与词库匹配的所有可能的词,再运用统计语言模型决定最优的切分结果。最好的一种分词方法应该保证分完词后这个句子出现的概率最大。

    问题:穷举所有可能的分词方法并计算每种可能性的句子的概率,计算量相当大。

    技巧:看成一个动态规划(Dynamic Programming)问题,利用维特比(Viterbi)算法快速地找到最佳分词。

    维特比(Viterbi)算法

    维特比算法是一个特殊但是应用最广的动态规划算法。利用动态规划,可以解决任何一个图中的最短路径问题。维特比算法是针对一个特殊的图—— 篱笆网络(Lattice) 的有向图最短路径问题而提出的。凡是使用隐含马尔可夫模型描述的问题都要用它来解码,如语音识别、机器翻译、拼音转汉字(中文输入法)、分词。

    例如输入法,输入的可见序列为 y1,y2,...,yN,而产生它们的隐含序列是 x1,x2,...,xN

    这里写图片描述

    x1,x2,...,xN=argmaxxXP(x1,x2,...,xN|y1,y2,...,yN)

    =argmaxxXi=1NP(yi|xi)P(xi|xi1)

    P(xi|xi1) 是状态之间的转移概率P(yi|xi) 是每个状态的产生概率

    这里写图片描述

    维特比算法:

    • 从点 S 开始,对于第一个状态 x1 的各个节点,计算距离
      d(S,xi) ,只有一步所以都是最短距离。
    • 对于第二个状态 x2 的所有节点,计算 S 到它们的最短距离,计算复杂度 O(n1n2)

    d(S,x2i)=minj=1n1d(S,x1j)+d(x1j,x2i)

    • 如上从第二个状态走到第三个状态,直到最后,就得到了网络的最短路径。每一步计算的复杂度都与相邻两个状态 SiSi+1 各自的节点数目 ni,ni+1的乘积成正比,假定节点最多的状态由D个节点,长度为N,算法复杂度为 O(ND2)

    由字构词的分词方法

    可以理解为字的分类问题,也就是自然语言处理中的sequence labeling问题,通常做法里利用HMM,MAXENT,MEMM,CRF等预测文本串每个字的tag,比如B,E,I,S,这四个tag分别表示:beginning, inside, ending, single,也就是一个词的开始,中间,结束,以及单个字的词。


    一般而言,方法一和方法二在工业界用得比较多,方法三因为采用复杂的模型,虽准确率相对高,但耗时较大.

    一个文本串除了分词,还需要做词性标注,命名实体识别,新词发现等。


    《数学之美》 4 26

    http://www.flickering.cn/ads/2015/02/%E8%AF%AD%E4%B9%89%E5%88%86%E6%9E%90%E7%9A%84%E4%B8%80%E4%BA%9B%E6%96%B9%E6%B3%95%E4%B8%80/

    展开全文
  • Python中文分词 jieba 十五分钟入门与进阶

    万次阅读 多人点赞 2017-05-27 16:21:04
    整体介绍jieba 基于Python的中文分词工具,安装使用非常方便,直接pip即可,2/3都可以,功能强悍,博主十分推荐 github:https://github.com/fxsjy/jieba 开源中国地址:...

    整体介绍

    jieba 基于Python的中文分词工具,安装使用非常方便,直接pip即可,2/3都可以,功能强悍,博主十分推荐
    github:https://github.com/fxsjy/jieba
    开源中国地址:http://www.oschina.net/p/jieba/?fromerr=LRXZzk9z
    写这篇文章花费两个小时小时,阅读需要十五分钟,读完本篇文章后您将能上手jieba

    下篇博文将介绍将任意中文文本生成中文词云

    同时如果你希望使用其它分词工具,那么你可以留意我之后的博客,我会在接下来的日子里发布其他有关内容.

    三种分词模式与一个参数

    以下代码主要来自于jieba的github,你可以在github下载该源码

    import jieba
    
    seg_list = jieba.cut("我来到北京清华大学", cut_all=True, HMM=False)
    print("Full Mode: " + "/ ".join(seg_list))  # 全模式
    
    seg_list = jieba.cut("我来到北京清华大学", cut_all=False, HMM=True)
    print("Default Mode: " + "/ ".join(seg_list))  # 默认模式
    
    seg_list = jieba.cut("他来到了网易杭研大厦", HMM=False)
    print(", ".join(seg_list))
    
    seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所,后在日本京都大学深造", HMM=False)  # 搜索引擎模式
    print(", ".join(seg_list))
    
    # jieba.cut的默认参数只有三个,jieba源码如下
    # cut(self, sentence, cut_all=False, HMM=True)
    # 分别为:输入文本 是否为全模式分词 与是否开启HMM进行中文分词
    

    分词模式的运行结果

    关键词提取

    from os import path
    import jieba.analyse as analyse
    
    d = path.dirname(__file__)
    
    text_path = 'txt/lz.txt' #设置要分析的文本路径
    text = open(path.join(d, text_path)).read()
    
    for key in analyse.extract_tags(text,50, withWeight=False):
    # 使用jieba.analyse.extract_tags()参数提取关键字,默认参数为50
        print key.encode('utf-8')
        # 设置输出编码为utf-8不然在因为win下控制台默认中文字符集为gbk,所以会出现乱码
        # 当withWeight=True时,将会返回number类型的一个权重值(TF-IDF)
    

    提取关键词的运行效果

    运行结果如图所示,但是同样的我们也发现了一些问题,比如:
    问题一:
    分词错误,在运行结果中中"路明非"(龙族男主)被分成了"路明"和"明非"啷个中文词语,这是因为jieba的词库中并不含有该词的原因,同样的原因以及jieba词库比较老,因而在许多文本分词时都会产生这种情况,而这个问题我们将在第五个模块"三种可以让分词更准确的方法"解决
    问题二:
    出现非实意词语,无论在哪种语言中,都会存在大量的非实意单词,这一类词云我们需要在进行中文分词时进行去除停用词,这个问题将在下一个模块中解决

    中文歧义测试与去除停用词

    本段代码主要来自于《机器学习实践指南(第二版))》,其作者为麦好,ps:这是一本好书

    找停用词点这里:多版本中文停用词词表 + 多版本英文停用词词表 + python词表合并程序

    import jieba
    TestStr = "2010年底部队友谊篮球赛结束"
    # 因为在汉语中没有空格进行词语的分隔,所以经常会出现中文歧义,比如年底-底部-部队-队友
    # jieba 默认启用了HMM(隐马尔科夫模型)进行中文分词,实际效果不错
    
    seg_list = jieba.cut(TestStr, cut_all=True)
    print "Full Mode:", "/ ".join(seg_list) # 全模式
    
    seg_list = jieba.cut(TestStr, cut_all=False)
    print "Default Mode:", "/ ".join(seg_list) # 默认模式
    # 在默认模式下有对中文歧义有较好的分类方式
    
    seg_list = jieba.cut_for_search(TestStr) # 搜索引擎模式
    print "cut for Search","/".join(seg_list)
    

    中文歧义测试

    去除文本中的停用词

    # - * - coding: utf - 8 -*-
    #
    # 作者:田丰(FontTian)
    # 创建时间:'2017/5/27'
    # 邮箱:fonttian@163.com
    # CSDN:http://blog.csdn.net/fontthrone
    
    import sys
    import jieba
    from os import path
    
    d = path.dirname(__file__)
    stopwords_path = 'stopwords\stopwords1893.txt' # 停用词词表
    
    text_path = 'txt/lz.txt' #设置要分析的文本路径
    text = open(path.join(d, text_path)).read()
    
    def jiebaclearText(text):
        mywordlist = []
        seg_list = jieba.cut(text, cut_all=False)
        liststr="/ ".join(seg_list)
        f_stop = open(stopwords_path)
        try:
            f_stop_text = f_stop.read( )
            f_stop_text=unicode(f_stop_text,'utf-8')
        finally:
            f_stop.close( )
        f_stop_seg_list=f_stop_text.split('\n')
        for myword in liststr.split('/'):
            if not(myword.strip() in f_stop_seg_list) and len(myword.strip())>1:
                mywordlist.append(myword)
        return ''.join(mywordlist)
    
    text1 = jiebaclearText(text)
    print text1
    

    龙族中文分词去除中文停用词后的效果

    三种可以让分词更准确的方法

    方案一,在jieba中添加中文词语:
    这种方法可以有效的解决之前龙族男主"路明非"被分为"路明"和"明非"两个词的情况

    #这个只需要在源代码中加入一个语句即可
    import sys
    import jieba
    from os import path
    
    d = path.dirname(__file__)
    stopwords_path = 'stopwords\stopwords1893.txt' # 停用词词表
    
    jieba.add_word('路明非')
    # 添加的自定义中文语句的代码在这里
    # 添加的自定义中文语句的代码在这里
    # 添加的自定义中文语句的代码在这里
    
    text_path = 'txt/lz.txt' #设置要分析的文本路径
    text = open(path.join(d, text_path)).read()
    
    def jiebaclearText(text):
        mywordlist = []
        seg_list = jieba.cut(text, cut_all=False)
        liststr="/ ".join(seg_list)
        f_stop = open(stopwords_path)
        try:
            f_stop_text = f_stop.read( )
            f_stop_text=unicode(f_stop_text,'utf-8')
        finally:
            f_stop.close( )
        f_stop_seg_list=f_stop_text.split('\n')
        for myword in liststr.split('/'):
            if not(myword.strip() in f_stop_seg_list) and len(myword.strip())>1:
                mywordlist.append(myword)
        return ''.join(mywordlist)
    
    text1 = jiebaclearText(text)
    print text1
    

    运行效果如下:
    添加自定义语句之后

    方案二,添加自定义词库:
    下面的代码主要来自于jieba的github源码,你可以在github下载该例子

    #encoding=utf-8
    from __future__ import print_function, unicode_literals
    import sys
    sys.path.append("../")
    import jieba
    jieba.load_userdict("userdict.txt")
    # jieba采用延迟加载,"import jieba"不会立即触发词典的加载,一旦有必要才开始加载词典构建trie。如果你想手工初始jieba,也可以手动初始化。示例如下:
    # import jieba
    # jieba.initialize() #手动初始化(可选)
    # 在0.28之前的版本是不能指定主词典的路径的,有了延迟加载机制后,你可以改变主词典的路径:
    # 注意用户词典为主词典即优先考虑的词典,原词典此时变为非主词典
    # jieba.set_dictionary('data/dict.txt.big')
    
    import jieba.posseg as pseg
    
    test_sent = (
    "李小福是创新办主任也是云计算方面的专家; 什么是八一双鹿\n"
    "例如我输入一个带“韩玉赏鉴”的标题,在自定义词库中也增加了此词为N类\n"
    "「台中」正確應該不會被切開。mac上可分出「石墨烯」;此時又可以分出來凱特琳了。"
    )
    words = jieba.cut(test_sent)
    print('/'.join(words))
    
    print("="*40)
    
    result = pseg.cut(test_sent)
    # pseg.cut 切分,并显示词性
    # 下面是userdict.txt的内容,如果不加入这个词库,那么在运行结果中,云计算,创新办等词都将无法识别
    '''
    云计算 5
    李小福 2 nr
    创新办 3 i
    easy_install 3 eng
    好用 300
    韩玉赏鉴 3 nz
    八一双鹿 3 nz
    台中
    凱特琳 nz
    Edu Trust认证 2000
    '''
    
    

    添加用户词典

    下面这段代码主要来自于jieba的github,你可以在github下载该源码

    print('='*40)
    print('添加自定义词典/调整词典')
    print('-'*40)
    
    print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
    #如果/放到/post/中将/出错/。
    # 调整词典使 中将 变为中/将
    print(jieba.suggest_freq(('中', '将'), True))
    #494
    print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
    #如果/放到/post/中/将/出错/。
    print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
    #「/台/中/」/正确/应该/不会/被/切开
    print(jieba.suggest_freq('台中', True))
    print(jieba.suggest_freq('台中', True))
    #69
    # 调整词典使 台中 不被分词为台/中
    print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
    #「/台中/」/正确/应该/不会/被/切开
    

    并行计算

    下面这段代码主要来自于jieba的github,你可以在github下载该源码

    原理:将目标文本按行分隔后,把各行文本分配到多个python进程并行分词,然后归并结果,从而获得分词速度的可观提升

    基于python自带的multiprocessing模块,目前暂不支持windows

    import sys
    import time
    sys.path.append("../../")
    import jieba
    
    jieba.enable_parallel() # 关闭并行分词
    jieba.enable_parallel(4) # 开启并行分词模式,参数为并行进程数 
    
    url = sys.argv[1]
    content = open(url,"rb").read()
    t1 = time.time()
    words = "/ ".join(jieba.cut(content))
    
    t2 = time.time()
    tm_cost = t2-t1
    
    log_f = open("1.log","wb")
    log_f.write(words.encode('utf-8'))
    
    print('speed %s bytes/second' % (len(content)/tm_cost))
    

    实验结果:在4核3.4GHz Linux机器上,对金庸全集进行精确分词,获得了1MB/s的速度,是单进程版的3.3倍。

    展开全文
  • 使用hmmlearn中的MultinomialHMM实现中文分词

    数据
    提取码:sodv
      隐马尔可夫模型(Hidden Markov Model,HMM)是统计模型,它用来描述一个含有隐含未知参数的马尔可夫过程。其难点是从可观察的参数中确定该过程的隐含参数。然后利用这些参数来作进一步的分析,例如模式识别。

    训练集长这样:
    在这里插入图片描述
      HMM中文分词原理: 对于一个词语,比如“我爱中国”,每个字有都对应的状态:B、M、E、S中的一个。其中B表示开始,M表示中间,E表示结尾,S表示单独一个字。因此上述四个字的隐状态为:“BMME”。
      使用hmmlearn实现中文分词,我们要解决的核心问题就是计算三大矩阵:初始概率矩阵、转移概率矩阵以及发射概率矩阵。

    1. 对于初始概率矩阵,是一个1 X 4维的矩阵,我们用pi表示。pi[0]就是初始时B的概率,后面三个依次类推。怎么算这四个值呢?我们遍历训练集中每一个句子,如果该句子第一个词语长度大于等于2,那说明该句子是以M开头的,则pi[0]++;如果句子开头只有一个字,则pi[3]++。很显然,句子开头不可能是M或者E。 遍历完之后,矩阵中每个数再除以所有数之和即可(算概率)。
    2. 对于转义概率矩阵A,是一个4 X 4维的矩阵。比如A[0, 1]表示当前状态时B而下一状态是M的概率。具体计算方法:我们遍历所有句子,对每一个句子,我们找出B后面跟着M的个数,以及B后面跟着E的个数等等。遍历完成之后同样每一行除以该行总和。
    3. 对于发射概率矩阵B是一个4 X 65536(unicode)的矩阵。比如B[3, 25000]表示的意思就是unicode编码为25000的汉字状态为B的概率。计算方式为:遍历训练集中每一个字,利用ord(x)返回编码,如果该字隐状态为B,则B[0, ord(x)]++,以此类推。最后同样每一行除以该行所有数据之和。当然,按理说也可以不用unicode编码,我刚开始是这样做的:找到所有汉字的集合(不重复),大概有25000的样子,然后从0-24999编号。但是这样做的话时间代价很大,直接计算ord(x)显然更快。

    具体步骤:

    1. 数据处理。 读取txt文件,把每一个字的隐状态都表示出来:
    def load_data():
         data = open('HMM/TrainData.txt', encoding='utf-8')
         file = []
         for line in data.readlines():
             file.append(line.strip().split(' '))
         max_len = 0; temp = 0
         res = []
         for i in range(len(file)):
             for j in range(len(file[i])):
                 for k in range(len(file[i][j])):
                     res.append(file[i][j][k])
         real_file = []
         for i in range(len(file)):
             x = []
             for j in range(len(file[i])):
                 if len(file[i][j]) == 1:
                     x.append('S')
                 elif len(file[i][j]) == 2:
                     x.append('BE')
                 else:
                     str = 'B'
                     for k in range(len(file[i][j])-2):
                         str += 'M'
                     str += 'E'
                     x.append(str)
             real_file.append(x)
         return file, real_file
    

    file表示所有词语的集合,是一个二维列表,每个列表表示一句话,每句话又被分成了词语。real_file与file一一对应,只不过是编码BMES的集合。

    1. 计算三大矩阵:
    def hMM():
         file, data = load_data()    #lens表示一个出现了多少个字
         # print(list_set)
         states = ['B', 'M', 'E', 'S']   #分别表示开始中间结尾以及单个字
         A = np.zeros((4, 4))
         B = np.zeros((4, 65536))   #编码表示汉字,不用顺序
         pi = np.zeros(4)     #初始状态
    
         for i in range(len(data)):
             if data[i][0][0] == 'B':  #开头只能是B或者S
                 pi[0] += 1
             if data[i][0][0] == 'S':
                 pi[3] += 1
    
         pi /= np.sum(pi)   #初始状态
    
         for i in range(len(data)):
             for j in range(len(data[i])):
                 for k in range(len(data[i][j])):
                     B[states.index(data[i][j][k]), ord(file[i][j][k])] += 1   #隐状态为data[i][j][k]时对应汉字file[i][j][k]
                 if len(data[i][j]) == 1 and j + 1 < len(data[i]):
                     if data[i][j+1][0] == 'B':  #S后面接B
                         A[3, 0] += 1
                     if data[i][j+1][0] == 'S':  #S后面接S
                         A[3, 3] += 1
                     continue
                 A[0, 1] += data[i][j].count('BM')
                 A[0, 2] += data[i][j].count('BE')
                 A[1, 2] += data[i][j].count('ME')
                 if j + 1 < len(data[i]) and data[i][j + 1][0] == 'B':
                     A[2, 0] += 1
                 if j + 1 < len(data[i]) and data[i][j + 1][0] == 'S':
                     A[2, 3] += 1
    
         for i in range(4):
             if np.sum(A[i]) != 0:
                 A[i] = A[i] / np.sum(A[i])
    
         for i in range(4):
             B[i] /= np.sum(B[i])
    
    1. 训练模型:
    model = hmm.MultinomialHMM(n_components=len(states))
    model.startprob_ = pi
    model.emissionprob_ = B
    model.transmat_ = A
    
    1. 测试。对测试集中每一句话,对其中每一个字找到它的unicode码集合,然后利用上面训练好的模型对该集合进行解码。
    if __name__ == '__main__':
         print('请稍候...')
         model = hMM()
         dataset = []
         data = open('HMM/TestData.txt', 'r+')
         for line in data.readlines():
             temp = line.strip().split('\t')
             file = []
             for x in temp:
                 file.append(x)
             dataset.append(file)   #处理数据
         data = np.array(dataset)
         for k in range(4):    #四句话
             print('分词前:', str(data[k]))
             datas = []
             x = str(*data[k])   #变成字符串
             for j in x:
                 datas.append(ord(j))  #寻找汉字的编码,进行decode
             xd = np.asarray(datas).reshape(-1, 1)
             pre = model.predict(xd)
             final = []
             for p, q in enumerate(pre):
                 if q == 0:
                     t = p
                 elif q == 2:
                     final.append(x[t:p + 1])
                 elif q == 3:
                     final.append(x[p])
             print("分词后:", '/'.join(final))
             print('\n')
    

    完整代码:

    from hmmlearn import hmm
    import numpy as np
    
    def load_data():
         data = open('HMM/TrainData.txt', encoding='utf-8')
         file = []
         for line in data.readlines():
             file.append(line.strip().split(' '))
         max_len = 0; temp = 0
         res = []
         for i in range(len(file)):
             for j in range(len(file[i])):
                 for k in range(len(file[i][j])):
                     res.append(file[i][j][k])
         real_file = []
         for i in range(len(file)):
             x = []
             for j in range(len(file[i])):
                 if len(file[i][j]) == 1:
                     x.append('S')
                 elif len(file[i][j]) == 2:
                     x.append('BE')
                 else:
                     str = 'B'
                     for k in range(len(file[i][j])-2):
                         str += 'M'
                     str += 'E'
                     x.append(str)
             real_file.append(x)
         return file, real_file
    
    
    #训练
    def hMM():
         file, data = load_data()    #lens表示一个出现了多少个字
         # print(list_set)
         states = ['B', 'M', 'E', 'S']   #分别表示开始中间结尾以及单个字
         A = np.zeros((4, 4))
         B = np.zeros((4, 65536))   #编码表示汉字,不用顺序
         pi = np.zeros(4)     #初始状态
    
         for i in range(len(data)):
             if data[i][0][0] == 'B':  #开头只能是B或者S
                 pi[0] += 1
             if data[i][0][0] == 'S':
                 pi[3] += 1
    
         pi /= np.sum(pi)   #初始状态
    
         for i in range(len(data)):
             for j in range(len(data[i])):
                 for k in range(len(data[i][j])):
                     B[states.index(data[i][j][k]), ord(file[i][j][k])] += 1   #隐状态为data[i][j][k]时对应汉字file[i][j][k]
                 if len(data[i][j]) == 1 and j + 1 < len(data[i]):
                     if data[i][j+1][0] == 'B':  #S后面接B
                         A[3, 0] += 1
                     if data[i][j+1][0] == 'S':  #S后面接S
                         A[3, 3] += 1
                     continue
                 A[0, 1] += data[i][j].count('BM')
                 A[0, 2] += data[i][j].count('BE')
                 A[1, 2] += data[i][j].count('ME')
                 if j + 1 < len(data[i]) and data[i][j + 1][0] == 'B':
                     A[2, 0] += 1
                 if j + 1 < len(data[i]) and data[i][j + 1][0] == 'S':
                     A[2, 3] += 1
    
         for i in range(4):
             if np.sum(A[i]) != 0:
                 A[i] = A[i] / np.sum(A[i])
    
         for i in range(4):
             B[i] /= np.sum(B[i])
         #训练模型
         model = hmm.MultinomialHMM(n_components=len(states))
         model.startprob_ = pi
         model.emissionprob_ = B
         model.transmat_ = A
         return model
    
    if __name__ == '__main__':
         print('请稍候...')
         model = hMM()
         dataset = []
         data = open('HMM/TestData.txt', 'r+')
         for line in data.readlines():
             temp = line.strip().split('\t')
             file = []
             for x in temp:
                 file.append(x)
             dataset.append(file)   #处理数据
         data = np.array(dataset)
         for k in range(4):    #四句话
             print('分词前:', str(data[k]))
             datas = []
             x = str(*data[k])   #变成字符串
             for j in x:
                 datas.append(ord(j))  #寻找汉字的编码,进行decode
             xd = np.asarray(datas).reshape(-1, 1)
             pre = model.predict(xd)
             final = []
             for p, q in enumerate(pre):
                 if q == 0:
                     t = p
                 elif q == 2:
                     final.append(x[t:p + 1])
                 elif q == 3:
                     final.append(x[p])
             print("分词后:", '/'.join(final))
             print('\n')
    
    

    输出:

    分词前: ['长春市长春节讲话。']
    分词后: 长春/市长/春节/讲话/。
    
    
    分词前: ['他说的确实在理.']
    分词后:///确实/在理
    
    
    分词前: ['毛主席万岁。']
    分词后: 毛主席///。
    
    
    分词前: ['我有一台电脑。']
    分词后: 我有/一台/电脑/
    展开全文
  • 基于python中jieba包的中文分词中详细使用(一)

    万次阅读 多人点赞 2018-05-06 12:43:21
    基于python中jieba包的中文分词中详细使用(一) 01.前言 02.jieba的介绍 02.1 What 02.2特点 02.3安装与使用 02.4涉及到的算法 03.主要功能 03.01分词 03.02添加自定义词典 03.02调整词典 04.结束语 ...

    基于python中jieba包的中文分词中详细使用(一)

    01.前言

    之前的文章中也是用过一些jieba分词但是基本上都是处于皮毛,现在就现有的python环境中对其官方文档做一些自己的理解以及具体的介绍。本文主要内容也是从官网文档中获取。

    02.jieba的介绍

    02.1 What

    “jieba” (Chinese for “to stutter”)Chiese text segmention:built to be the best Python Chinse word segmenmtation module.
    "jieba"中文分词:做最好的Python中文分词组件

    02.2特点

    • 支持三种分词模式:
      精确模式,试图将句子最精确地切开,适合文本分析;
      全模式,把句子中所有的可以成词的词语都扫描处理,速度非常快,但是不能解决歧义;
      搜索引擎模式,在精确模式的基础上,对长词再次切分,提高召回率,适合用于引擎分词。
    • 支持繁体分词
    • 支持自定义词典
    • MIT授权协议

    02.3安装与使用

    鉴于当前提供各大包的组织逐渐放弃对Python2的维护,这里也强烈建议使用Python3。jieba分词的安装也是很简单的。
    全自动安装的方式:pip install jieba (window环境) pip3 install jieba (Linux环境);
    使用的方式:import jieba

    02.4涉及到的算法

    • 基于前缀词典实现高效的词图扫描,生成句子中汉字所有可能成词情况所构成的有向无环图 (DAG)
    • 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合
    • 对于未登录词,采用了基于汉字成词能力的 HMM (隐马尔科夫)模型,使用了 Viterbi 算法

    03.主要功能

    03.01分词

    • jieba.cut 方法接受三个输入参数: 需要分词的字符串;cut_all 参数用来控制是否采用全模式;HMM 参数用来控制是否使用 HMM 模型
    • jieba.cut_for_search 方法接受两个参数:需要分词的字符串;是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词,粒度比较细
    • 待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意:不建议直接输入 GBK 字符串,可能无法预料地错误解码成 UTF-8
    • jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator,可以使用 for 循环来获得分词后得到的每一个词语(unicode),或者用
    • jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
    • jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器,可用于同时使用不同词典。jieba.dt 为默认分词器,所有全局分词相关函数都是该分词器的映射。
      代码实例
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # @Date    : 2018-05-05 22:15:13
    # @Author  : JackPI (1129501586@qq.com)
    # @Link    : https://blog.csdn.net/meiqi0538
    # @Version : $Id$
    import jieba
    
    seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
    print("全模式: " + "/ ".join(seg_list))  # 全模式
    
    seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
    print("精准模式: " + "/ ".join(seg_list))  # 精确模式
    
    seg_list = jieba.cut("他来到了网易杭研大厦")  # 默认是精确模式
    print(", ".join(seg_list))
    
    seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所,后在日本京都大学深造")  # 搜索引擎模式
    print(", ".join(seg_list))
    

    输出结果

    Building prefix dict from the default dictionary ...
    Loading model from cache C:\Users\JACKPI~1\AppData\Local\Temp\jieba.cache
    Loading model cost 1.026 seconds.
    Prefix dict has been built succesfully.
    全模式: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
    精准模式: 我/ 来到/ 北京/ 清华大学
    他, 来到, 了, 网易, 杭研, 大厦
    小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, ,, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造
    [Finished in 1.7s]
    

    03.02添加自定义词典

    • 开发者可以指定自己自定义的词典,以便包含 jieba 词库里没有的词。虽然 jieba 有新词识别能力,但是自行添加新词可以保证更高的正确率
    • 用法: jieba.load_userdict(file_name) # file_name 为文件类对象或自定义词典的路径
    • 词典格式和 dict.txt 一样,一个词占一行;每一行分三部分:词语、词频(可省略)、词性(可省略),用空格隔开,顺序不可颠倒。file_name 若为路径或二进制方式打开的文件,则文件必须为 UTF-8 编码
    • 词频省略时使用自动计算的能保证分出该词的词频
      添加自定义字典举例
    创新办 3 i
    云计算 5
    凱特琳 nz
    台中
    
    • 更改分词器(默认为 jieba.dt)的 tmp_dir 和 cache_file 属性,可分别指定缓存文件所在的文件夹及其文件名,用于受限的文件系统。
      使用案例
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # @Date    : 2018-05-05 22:15:13
    # @Author  : JackPI (1129501586@qq.com)
    # @Link    : https://blog.csdn.net/meiqi0538
    # @Version : $Id$
    #导入jieba包
    import jieba
    #管理系统路径
    import sys
    sys.path.append("../")
    #获取自定义词典
    jieba.load_userdict("userdict.txt")
    #导入词性标注的包
    import jieba.posseg as pseg
    
    #添加词
    jieba.add_word('石墨烯')
    jieba.add_word('凱特琳')
    #删除词
    jieba.del_word('自定义词')
    #元组类型的测试数据
    test_sent = (
    "李小福是创新办主任也是云计算方面的专家; 什么是八一双鹿\n"
    "例如我输入一个带“韩玉赏鉴”的标题,在自定义词库中也增加了此词为N类\n"
    "「台中」正確應該不會被切開。mac上可分出「石墨烯」;此時又可以分出來凱特琳了。"
    )
    #默认分词
    words = jieba.cut(test_sent)
    print('/'.join(words))#使用/把分词的结果分开
    
    print("="*40)
    #用于词性标注
    result = pseg.cut(test_sent)
    #使用for循环把分出的词及其词性用/隔开,并添加,和空格
    for w in result:
        print(w.word, "/", w.flag, ", ", end=' ')
    
    print("\n" + "="*40)
    
    #对英文的分割
    terms = jieba.cut('easy_install is great')
    print('/'.join(terms))
    #对英文和汉字的分割
    terms = jieba.cut('python 的正则表达式是好用的')
    print('/'.join(terms))
    
    print("="*40)
    # test frequency tune
    testlist = [
    ('今天天气不错', ('今天', '天气')),
    ('如果放到post中将出错。', ('中', '将')),
    ('我们中出了一个叛徒', ('中', '出')),
    ]
    
    for sent, seg in testlist:
        print('/'.join(jieba.cut(sent, HMM=False)))
        word = ''.join(seg)
        print('%s Before: %s, After: %s' % (word, jieba.get_FREQ(word), jieba.suggest_freq(seg, True)))
        print('/'.join(jieba.cut(sent, HMM=False)))
        print("-"*40)
    

    结果

    Building prefix dict from the default dictionary ...
    Loading model from cache C:\Users\JACKPI~1\AppData\Local\Temp\jieba.cache
    Loading model cost 1.063 seconds.
    Prefix dict has been built succesfully.
    李小福/是/创新办/主任/也/是/云计算/方面/的/专家/;/ /什么/是/八一双鹿/
    /例如/我/输入/一个/带/“/韩玉赏鉴/”/的/标题/,/在/自定义/词库/中/也/增加/了/此/词为/N/类/
    /「/台中/」/正確/應該/不會/被/切開/。/mac/上/可/分出/「/石墨烯/」/;/此時/又/可以/分出/來/凱特琳/了/。
    ========================================
    李小福 / nr ,  是 / v ,  创新办 / i ,  主任 / b ,  也 / d ,  是 / v ,  云计算 / x ,  方面 / n ,  的 / uj ,  专家 / n ,  ; / x ,    / x ,  什么 / r ,  是 / v ,  八一双鹿 / nz ,  
     / x ,  例如 / v ,  我 / r ,  输入 / v ,  一个 / m ,  带 / v ,  “ / x ,  韩玉赏鉴 / nz ,  ” / x ,  的 / uj ,  标题 / n ,  , / x ,  在 / p ,  自定义 / l ,  词库 / n ,  中 / f ,  也 / d ,  增加 / v ,  了 / ul ,  此 / r ,  词 / n ,  为 / p ,  N / eng ,  类 / q ,  
     / x ,  「 / x ,  台中 / s ,  」 / x ,  正確 / ad ,  應該 / v ,  不 / d ,  會 / v ,  被 / p ,  切開 / ad ,  。 / x ,  mac / eng ,  上 / f ,  可 / v ,  分出 / v ,  「 / x ,  石墨烯 / x ,  」 / x ,  ; / x ,  此時 / c ,  又 / d ,  可以 / c ,  分出 / v ,  來 / zg ,  凱特琳 / nz ,  了 / ul ,  。 / x ,  
    ========================================
    easy_install/ /is/ /great
    python/ /的/正则表达式/是/好用/的
    ========================================
    今天天气/不错
    今天天气 Before: 3, After: 0
    今天/天气/不错
    ----------------------------------------
    如果/放到/post/中将/出错/。
    中将 Before: 763, After: 494
    如果/放到/post/中/将/出错/。
    ----------------------------------------
    我们/中/出/了/一个/叛徒
    中出 Before: 3, After: 3
    我们/中/出/了/一个/叛徒
    ----------------------------------------
    [Finished in 2.6s]
    

    03.02调整词典

    • 使用 add_word(word, freq=None, tag=None)del_word(word) 可在程序中动态修改词典。
    • 使用 suggest_freq(segment, tune=True) 可调节单个词语的词频,使其能(或不能)被分出来。
    • 注意:自动计算的词频在使用 HMM 新词发现功能时可能无效。
    >>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
    如果/放到/post/中将/出错/。
    >>> jieba.suggest_freq(('中', '将'), True)
    494
    >>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
    如果/放到/post/中/将/出错/。
    >>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
    「/台/中/」/正确/应该/不会/被/切开
    >>> jieba.suggest_freq('台中', True)
    69
    >>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
    「/台中/」/正确/应该/不会/被/切开
    
    • “通过用户自定义词典来增强歧义纠错能力” — https://github.com/fxsjy/jieba/issues/14

    04.结束语

    更多关于jieba分词的请关注下篇博客:基于python中jieba包的中文分词中详细使用(二)。关于更多是的自然语言处理,可以查看给人微信订阅号,里面包含大量的自然与处理、机器学习文章、学习资料等。
    这里写图片描述

    展开全文
  • Java中文分词组件 - word分词

    万次阅读 2019-02-10 16:17:50
    word分词是一个Java实现的分布式的中文分词组件,提供了多种基于词典的分词算法,并利用ngram模型来消除歧义。能准确识别英文、数字,以及日期、时间等数量词,能识别人名、地名、组织机构名等未登录词。能通过...
  • ElasticSearch7.0.0安装IK分词

    万次阅读 2020-03-30 16:42:53
    为什么要在elasticsearch中要使用ik这样的中文分词呢,那是因为es提供的分词是英文分词,对于中文的分词就做的非常不好了,因此我们需要一个中文分词器来用于搜索和使用。就尝试安装下IK分词。 2.去github下载对应...
  • Elasticsearch之分词器查询分词效果

    万次阅读 2019-07-31 17:20:54
    Elasticsearch之分词器中文的我们一般使用IK,如果没有指定分词器。默认使用的是standard分词。 IK分词能将中文分成词组: standard分词则会将每个中文分成一个单个的词: 其他分词器:ansj_index ...... 优劣:...
  • 如何使用中科院分词如何使用中科院分词如何使用中科院分词如何使用中科院分词
  • 以上用例是使用 analyzer 指定英文分词器查看分词结果,如果field是索引里的字段,会使用字段指定的分词器进行分词。 接下来进入测试。 默认分词器 默认使用stander分词器 在不标明的时候都是使用默认的stander...
  • “结巴”中文分词:做最好的 Python 中文分词组件,分词模块jieba,它是python比较好用的分词模块, 支持中文简体,繁体分词,还支持自定义词库。 jieba的分词,提取关键词,自定义词语。 结巴分词的原理 这里写...
  • ansj分词史上最详细教程

    万次阅读 多人点赞 2016-12-13 11:29:50
    最近的项目需要使用到分词技术。本着不重复造轮子的原则,使用了ansj_seg来进行分词。本文结合博主使用经过,教大家用最快的速度上手使用ansj分词。1.给ansj来个硬广
  • jieba中文分词组件

    万次阅读 2019-05-21 18:16:27
    分词 添加自定义词典 载入词典 调整词典 关键词提取 基于 TF-IDF 算法的关键词抽取 基于 TextRank 算法的关键词抽取 词性标注 并行分词 Tokenize:返回词语在原文的起止位置 默认模式 搜索模式 ...
  • jieba分词详解

    万次阅读 2019-02-24 18:55:10
    语音识别中有一项任务就是训练语言模型,而对于中文的语言模型,需要事先进行分词。而语音识别中的语言模型还有个特殊的要求,就是语言模型中的所有词都必须在发音词典中(也就是说每个词都要有对应的发音)。因此这就...
  • 盘古分词 - 多元分词算法

    千次阅读 2019-04-11 15:26:07
    中文分词按照分词粒度来分,分成 一元分词,二元分词,多元分词和精确分词等类型。一元分词就是最简单的分词,将所有的中文字符按照单字形式输出。二元分词按双字形式输出。多元分词则是将一句话中可能的单词组合...
  • 中文分词原理及分词工具介绍

    万次阅读 多人点赞 2018-07-31 11:00:37
    本文首先介绍下中文分词的基本原理,然后介绍下国内比较流行的中文分词工具,如jieba、SnowNLP、THULAC、NLPIR,上述分词工具都已经在github上开源,后续也会附上github链接,以供参考。 1.中文分词原理介绍 1.1 ...
  • jieba 分词如何控制分词粒度

    千次阅读 2019-03-26 20:00:47
    jieba分词如何实现分词的粒度 分词粒度的概念 我最喜欢的篮球明星是勒布朗·詹姆斯,一般我们直接称呼他为詹姆斯 以该句话为例,最好的分词结果是 “勒布朗·詹姆斯” 和 “詹姆斯”都能分离出来。这就涉及到了...
  • 对于倒排索引来说,很重要的一件事情就是需要对文本进行分词,经过分词可以获取情感、词性、质性、词频等等的数据。 Elasticsearch 分词工作原理 在 Elasticsearch 中进行行分词的需要经过分析器的3个模块,字符...
  • ElasticSearch中文分词,看这一篇就够了

    万次阅读 多人点赞 2020-06-03 16:09:11
    本文我们围绕Elasticsearch的分词器,从内置分词器的局限性出发,引出了中文分词器,然后详细介绍了ik分词器的编译,安装配置和使用。
  • 文章目录Elasticsearch7 分词器(内置分词器和自定义分词器)analysis概览char_filter...
  • jieba分词

    千次阅读 2018-08-23 17:21:39
    对于NLP(自然语言处理)来说,分词是一步重要的工作,市面上也有各种分词库,11款开放中文分词系统比较。 1.基于词典:基于字典、词库匹配的分词方法;(字符串匹配、机械分词法) 2.基于统计:基于词频度统计的...
  • 盘古分词

    千次阅读 2017-09-28 10:13:01
    盘古分词盘古分词是一个开源中文分词组件。其界面如图所示 特点 多元分词中文分词按照分词粒度来分,可以分成一元分词,二元分词,精确分词等类型。一元分词就是最简单的分词,将所有的中文字符按照单字形式输出。...
  • HanLP中文分词——字典分词

    千次阅读 2020-05-02 11:32:39
    对汉语言进行处理,首先的步骤是将汉语进行分词。汉语进行分词的一个比较 low 但有用的方法是字典拆分。 字典拆分使用启发式算法——双向文本匹配算法,结合字典,对汉语语句和段落进行拆分的方法。 from sklearn....
  • 中文分词及拼音分词

    千次阅读 2019-02-27 15:57:37
    相关软件下载 elasticsearch-analysis-ik-6.4.2.zip ...ik分词插件安装 #在elasticsearch的plugins/目录下创建ik文件夹 cd elasticsearch/plugins/ mkdir ik #解压文件 cd ik unzip /es/tools/elast...
  • analysis是指把全文本转换成一系列单词(term/token)的过程,也叫分词。 analysis是通过分词器analyzer来实现的。 2.ES自带分词器 Standard Analyzer——默认分词器,按词切分,小写处理 Simple Analyzer——...
  • elasticsearch使用中文分词器和拼音分词器,自定义分词器 1. 到github 下载分词器 上面有已经编译好打好的包。下载后在es安装目录下的plugins/目录下创建ik和pinyin两个文件夹,把下载好的zip包解压在里面。重启es就...
  • 开源的中文分词包有很多,这次选用的分词算法库是结巴分词,它是非常流行的中文分词包,有多个语言的版本,这次采用了java版的。从结巴分词的github的主页上下载代码后,根据例子,填写少量代码就可以实现任意文本的...
  • 在采集美女站时,需要对关键词进行分词,最终采用的是python的结巴分词方法. 中文分词是中文文本处理的一个基础性工作,结巴分词利用进行中文分词。其基本实现原理有三点: 基于Trie树结构实现高效的词图扫描,...
  • 中文分词的基本原理以及jieba分词的用法

    万次阅读 多人点赞 2017-01-21 13:15:40
    结巴分词是国内程序员用Python开发的一个中文分词模块,可能是最好的Python中文分词组件? 中文分词的原理 – 1、中文分词(Chinese Word Segmentation) 指的是将一个汉字序列切分成一个一个单独的词。分词就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,235
精华内容 18,494
关键字:

分词