一个简单的分词系统

最新推荐文章于 2021-07-22 22:01:33 发布
最新推荐文章于 2021-07-22 22:01:33 发布
阅读量509 收藏 1
点赞数
分类专栏： 人工智能 文章标签： 自然语言处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gh6267/article/details/105644093
版权

一、基于枚举法的中文分词工具

  •  前向最大匹配
    • 例子：我们经常有意见分歧
    • 词典：["我们"， “经常”，“有”， “有意见”， “意见”， “分歧”]
    • 我们定义max_len = 5
    • 开始执行前向匹配算法
      • （1）
        • [我们经常有]意见分歧 (词典中没有， max_len缩小一位)
        • [我们经常]有意见分歧(词典中没有， max_len缩小一位)
        • [我们经]常有意见分歧(词典中没有， max_len缩小一位)
        • [我们]经常有意见分歧(词典中有，将“我们”划分出来)
      • （2）
        • [经常有意见]分歧(词典中没有， max_len缩小一位)
        • [经常有意]见分歧(词典中没有， max_len缩小一位)
        • [经常有]意见分歧(词典中没有， max_len缩小一位)
        • [经常]有意见分歧(词典有，将“经常”划分出来
      • 。。。。。。
      • 最终我们得到划分结果为[“我们”，“经常”，“有意见”，“分歧”]
  • 后向最大匹配
    • 例子与上面的相同，过程也相似
    • （1）
      • 我们经常[有意见分歧](词典中没有， max_len缩小一位)
      • 我们经常有[意见分歧](词典中没有， max_len缩小一位)
      • 我们经常有意[见分歧](词典中没有， max_len缩小一位)
      • 我们经常有意见[分歧](词典有，将“分歧”划分出来)
    • （2）
      • 我们[经常有意见](词典中没有， max_len缩小一位)
      • 我们经[常有意见](词典中没有， max_len缩小一位)
      • 我们经常[有意见](词典中没有， max_len缩小一位)
    • 。。。。。。
    • 最终我们得到划分结果为[“我们”，“经常”，“有意见”，“分歧”]
  • 基于上面的两个分词方法，我们对给定的字符串：”我们学习人工智能，人工智能是未来“, 找出一些的分割方式
    • [我们，学习，人工智能，人工智能，是，未来]
    • [我们，学习，人工，智能，人工智能，是，未来]
    • [我们，学习，人工，智能，人工，智能，是，未来]
    • [我们，学习，人工智能，人工，智能，是，未来] .......

    • 另外我们给定unigram概率：p(我们)=0.25, p(学习)=0.15, p(人工)=0.05, p(智能)=0.1, p(人工智能)=0.2, p(未来)=0.1, p(是)=0.15

  • 我们也可以计算出每一个切分之后句子的概率

    • p(我们，学习，人工智能，人工智能，是，未来)= -log p(我们)-log p(学习)-log p(人工智能)-log p(人工智能)-log p(是)-log p(未来)
    • p(我们，学习，人工，智能，人工智能，是，未来)=-log p(我们)-log p(学习)-log p(人工)-log p(智能)-log p(人工智能)-log p(是)-log p(未来)
    • p(我们，学习，人工，智能，人工，智能，是，未来)=-log p(我们)-log p(学习)-log p(人工)-log p(智能)-log p(人工)-log p(智能)-log p(是)-log p(未来)
    • p(我们，学习，人工智能，人工，智能，是，未来)=-log p(我们)-log p(学习)-log p(人工智能)-log p(人工)-log p(智能)-log(是)-log p(未来) .....
  • import math


dic_words = [
    "北京",
    "的","天",
    "气","天气",
    "真","好","真好","啊","真好啊",
    "今","今天","课程","内容","有",
    "很","很有","意思","有意思","课",
    "程","经常","意见","意","见",
    "有意见","分歧","分","歧",
]

word_prob = {
    "北京":0.03,"的":0.08,"天":0.005,"气":0.005,
     "天气":0.06,"真":0.04,"好":0.05,"真好":0.04,"啊":0.01,"真好啊":0.02,
     "今":0.01,"今天":0.07,"课程":0.06,"内容":0.06,"有":0.05,"很":0.03,
     "很有":0.04,"意思":0.06,"有意思":0.005,"课":0.01,
     "程":0.005,"经常":0.08,"意见":0.08,"意":0.01,"见":0.005,
     "有意见":0.02,"分歧":0.04,"分":0.02, "歧":0.005
}

def cal_score(segment: list) -> float:
    sum = 0.0
    for word in segment:
        sum += (-1.0 * math.log10(word_prob.get(word)))
    return sum

def word_segment_naive(input_str: str):
    global best_segment
    segments = []
    i = 0
    L = len(input_str)
    while i < L:
        pre = input_str[0: i]
        post = input_str[i:]
        segment = []
        s1 = pre_segment_naive(pre)
        s2 = pre_segment_naive(post)
        if (len(s1) > 0 or len(pre) == 0) and len(s2) > 0:
            segment.extend(s1)
            segment.extend(s2)
        if len(segment) > 0 and segment not in segments:
            segments.append(segment)
        pre = input_str[0: i]
        post = input_str[i:]
        segment = []
        s1 = post_segment_naive(pre)
        s2 = post_segment_naive(post)
        if (len(s1) > 0 or len(pre) == 0) and len(s2) > 0:
            segment.extend(s1)
            segment.extend(s2)
        if len(segment) > 0 and segment not in segments:
            segments.append(segment)
        i += 1
    best_score = -1
    for  seg in segments:
        score = cal_score(seg)
        if score < best_score or best_score == -1:
            best_score = score
            best_segment = seg
    return best_segment

def pre_segment_naive(words: str):
    segment = []
    max_len = 5
    while len(words) > 0:
        if len(words) < max_len:
            use_len = len(words)
        else:
            use_len = max_len
        while use_len > 0:
            tmp_src = words[: use_len]
            if tmp_src in word_prob:
                segment.append(tmp_src)
                words = words[use_len: ]
                break
            else:
                use_len -= 1
        if use_len == 0:
            break
    return segment

def post_segment_naive(words: str):
    segment = []
    max_len = 5
    while len(words) > 0:
        if len(words) < max_len:
            use_len = len(words)
        else:
            use_len = max_len
        while use_len > 0:
            tmp_src = words[-use_len : ]
            if tmp_src in word_prob:
                segment.append(tmp_src)
                words = words[0 : len(words) - use_len]
                break
            else:
                use_len -= 1
        if use_len == 0:
            break
    segment.reverse()
    return segment

def Print(word: str):
    seg = word_segment_naive(word)
    for s in seg:
        print(s)

if __name__ == '__main__':
    print(word_segment_naive("北京的天气真好啊"))
    print(word_segment_naive("今天的课程内容很有意思"))
    print(word_segment_naive("经常有意见分歧"))

    输出结果为：

  • ['北京', '的', '天气', '真好啊']
    ['今天', '的', '课程', '内容', '很有', '意思']
    ['经常', '有意见', '分歧'] 

 二、基于维特比算法来优化上述流程（维比特算法）

  • 根据词典，输入的句子和 word_prob来创建带权重的有向图（Directed Graph）
  • 编写维特比算法（viterebi）算法来找出其中最好的PATH， 也就是最好的句子切分
  • 返回结果 

 

import xlrd
import math

dic_words = [
    "北京",
    "的","天",
    "气","天气",
    "真","好","真好","啊","真好啊",
    "今","今天","课程","内容","有",
    "很","很有","意思","有意思","课",
    "程","经常","意见","意","见",
    "有意见","分歧","分","歧"
]

word_prob = {
    "北京":0.03,"的":0.08,"天":0.005,"气":0.005,
     "天气":0.06,"真":0.04,"好":0.05,"真好":0.04,"啊":0.01,"真好啊":0.02,
     "今":0.01,"今天":0.07,"课程":0.06,"内容":0.06,"有":0.05,"很":0.03,
     "很有":0.04,"意思":0.06,"有意思":0.005,"课":0.01,
     "程":0.005,"经常":0.08,"意见":0.08,"意":0.01,"见":0.005,
     "有意见":0.02,"分歧":0.04,"分":0.02, "歧":0.005
}



def get_segment(words: str):
    segment = []
    tmp = ""
    for i in range(len(words)):
        tmp += words[i]
        if tmp in dic_words:
            segment.append(tmp)
            tmp = ""
    while len(tmp) > 0:
        tmp = segment[len(segment) - 1] + tmp
        del segment[len(segment) - 1]
        if tmp in dic_words:
            segment.append(tmp)
            tmp = ""
    return segment


def word_segment_viterbi(words: str):
    segment = get_segment(words)
    graph = [[] for i in range(len(segment) + 1)]

    # vector<pair<int, string, double>> v[10000]
    # v[1].push_back({2, 'offer', 0.9})

    Info = []

    for i in range(len(segment)):
        Info.append((i + 1, segment[i], -1.0 * math.log10(word_prob[segment[i]])))

    for i in range(len(segment)):
        graph[i].append(Info[i])

    for i in range(len(segment)):
        word = segment[i]
        for j in range(i + 1, len(segment)):
            word += segment[j]
            if word in dic_words:
                graph[i].append((j + 1, word, -1.0 * math.log10(word_prob[word])))

    dp = [-1 for x in range(len(segment) + 1)]
    pre = [-1 for x in range(len(segment) + 1)]
    dfs(dp, pre, graph, 0, 0, 0)
    ret = []
    L = len(dp) - 1
    while True:
        R = L
        L = pre[R]
        if R == 0:
            break
        word = ""
        for j in range(L, R):
            word += segment[j]
        ret.append(word)
    ret.reverse()
    return ret





def dfs(dp: list, pre: list, graph: list, u: int, v: int, val: int):
    pre[v] = u
    dp[v] = val
    for info in graph[v]:
        x = info[0]
        w = info[2]
        if dp[x] == -1:
            dfs(dp, pre, graph, v, x, val + w)
        elif dp[x] > (val + w):
            dfs(dp, pre, graph, v, x, val + w)


if __name__ == '__main__':
    print(word_segment_viterbi("北京的天气真好啊"))
    print(word_segment_viterbi("今天的课程内容很有意思"))
    print(word_segment_viterbi("经常有意见分歧"))

输出结果为

['北京', '的', '天气', '真好啊']
['今天', '的', '课程', '内容', '很有', '意思']
['经常', '有意见', '分歧']
 

hansy2015
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何构建高性能分词系统？（手把手教你做分词系统）
thundersssss的专栏
03-24 2385
    ictclas1.0中文词库已经出来好长时间了（网上有很多版本的，搜下就可以很容易得到），但是基于该词库基础上的系统却为数不多，很多分词组件的功能都达不到商用，比如实时添加词汇，持久化，序列化，即对词库的操作等都缺乏相应的基础支撑。   其实做一个分词系统并不是难于登天的事情，下面我就给大家将一种基于链表和二叉树的分词系统。    基于ICTCLAS 1.0，将其中的数
开源代码:Delphi词法分析全过程
WindowsAPI的专栏
01-13 2586
unit DelphiToken;interfaceuses  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,  Dialogs, StringOperations;const  WM_TOKENERROR  = WM_USER + 2034;  const  CHR_SYMHEADER  = 1
如何做简单分词
wanglin007
07-22 258
如何做简单分词 import re from operator import add num="wanglin is a good boy!" print(num.split()) # print(list(filter(None,num))) arr=list(filter(None,num)) print(arr) test=[] strstr='' for i in arr: if i!=' ' and i!='!': strstr+=i else: test.append(strst
蛮力法求最大字段和时间复杂度_C#实现前向最大匹、字典树（分词、检索）
weixin_39843338的博客
11-21 213
(给DotNet加星标，提升.Net技能)转自：Spring2Suncnblogs.com/SunSpring/p/12891504.html场景：现在有一个错词库，维护的是错词和正确词对应关系。比如：错词"我门"对应的正确词"我们"。然后在用户输入的文字进行错词校验，需要判断输入的文字是否有错词，并找出错词以便提醒用户，并且可以显示出正确词以便用户确认，如果是错词就进行替换。首先想到的...
Delphi 实现汉语分词
05-17
delphi与搜索引擎的资料很少了 分词技主了了无几今天传一个让大家参考一下 有了改进别忘记告诉我一下 谢谢
SCWS简易中文分词系统.zip
03-18
总之，SCWS简易中文分词系统是一个实用的工具，对于需要处理中文文本的PHP开发者来说，它提供了一种快速、便捷的方式来进行中文分词。通过理解和掌握其工作原理及使用方法，你可以有效地提升中文文本处理的效率和...
简单中文分词系统 v1.0
11-10
这是一套基于词频词典的机械式中文分词引擎，它能将一整段的中文文本基本正确地切分成词。 词是中文的最小语素单位，但在书写时并不像英语会在词之间用空格分开， 所以如何准确并快速分词一直是中文分词的攻关难点。...
毕业设计：基于PHP简易中文分词系统.zip
最新发布
11-14
【标题】"毕业设计：基于PHP简易中文分词系统.zip" 涉及的主要知识点是构建一个使用PHP语言实现的简单中文分词系统。在这一领域，你需要掌握以下几个关键概念和技术： 1. **PHP**: PHP（Hypertext Preprocessor）是...
npartword:golang分布式中文分词系统
03-11
npw：npartword，golang实现中文分词系统，主体分词逻辑有两个部分。 1.初步树查找字典，通过disctance或mmseg算法过滤分词 2.维特比算法解隐马尔可夫模型，对词进行隐状态标注分词 3.加入情感词典，文本情感分类...
Chinese-Word-Segmentation:一个中文分词系统
05-03
"Chinese-Word-Segmentation"是一个专为此目的设计的Java实现的中文分词系统。它的出现，为开发者和研究者提供了高效、灵活的工具，帮助他们更深入地处理和理解中文文本。 中文不同于英文，单词之间没有明显的边界...
python写的基于感知机的中文分词系统
05-26
基于字的用感知机实现的中文分词系统。完全训练后对微软的测试集精度可以达到96%多。我上传的版本是完整的代码（训练和分词），大家自己用附带的微软训练数据训练就可以了，只有一个文件。 代码总的来说写的还是很清楚的，方便自己也方便别人阅读。欢迎大家共讨论,xiatian@ict.ac.cn。
一个简单的分词系统（可以选择正向最大匹配分词或逆向最大匹配）
03-03
使用正向最大匹配FMM分词 以及逆向最大匹配BMM分词 但不是同时使用
delphi 实现简单链表和分词
02-09
实现链表，简单汉语分词 1、利用指针； 2、汉字索引，实现gbk内码作索引 3、简单分词，正向匹配 与 <<Delphi 实现带索引链表实现简单汉语分词>> 相同,当时上传错误,重新弄的.
PythonForDelphi分词.zip
07-24
PythonForDelphi分词.zip
中文分词系统
05-23
中文分词，用于文本分析，附带C++ 源代码
NLPIR分词系统的使用
lucky_xinyeol的博客
03-06 3312
前身是2000年发布的ICTCLAS，2009年更为现名。张华平博士打造。 Java课设做自动问答系统，用到了，所以记录一下使用方法，网上方法可能有点老，所以自己发现没有那么复杂。 https://github.com/NLPIR-team/NLPIR 上下载源码，结构如下： 特别注意，NLPIR分词系统中的证书，每一个月需更新一次。每个工程中的Data文件基本都是过期的，运行时，需用Li...
Python NLPIR(中科院汉语分词系统)的使用 十五分钟快速入门与完全掌握
weixin_30445169的博客
06-06 2273
前叙 博主写这篇文章使用了八十分钟,阅读需要十五分钟,读完之后你将会学会在Python中使用NLPIR2016.如果你花费更多的时间练习后半部分的例子,你将能够在一天内学会在Python中使用NLPIR2016的全部所需知识 如果你想要获取更详细的API翻译,你需要进一步学习ctypes,附赠一篇关于API翻译,虽然是java语言的,但是NLPIR的接口翻译都是一样的 ht...
中科院分词系统的大致流程
宁静
03-26 233
注：本文只是个人阅读ictclas4j的一些总结，如有不正确的地方欢迎指出 ictalas4j用到的字典主要是下面的三个：coreDict、biGramDict、nr。coreDict记录了6768个词块，里面有对应的词频和句柄（用于词性标注）；biGramDict里面记录的是词和词之间的关系，也就是相邻两个词一起出现的频率；nr记录的是中文人名角色标注，该标注来自对人民...
分词的前向最大匹配和后向最大匹配
weixin_45072810的博客
08-03 855
写在前面：常用的分词工具 结巴分词 结巴分词入口 https://github.com/fxsjy/jieba SnowNLP SnowNLP入口https://github.com/isnowfy/snownlp LTP LTP入口http://www.ltp-cloud.com/ HanNLP HanNLP入口http://github.com/hankcs/Hanlp/ … 分词的最大匹配（Segmentation Method 1：Max Matching） 前向最大匹配（forward-ma
用python实现一个基于rnn的此为标注汉语分词系统
05-28
好的，下面是一个简单的基于RNN的中文分词系统的Python实现。请注意，这只是一个示例，并不是一个完整的系统，只能处理一些简单的句子，您可以根据您的需求进行修改和扩展。 首先，需要导入相关的包和库： ```python import numpy as np import tensorflow as tf from tensorflow.contrib import rnn ``` 然后，定义一些超参数： ```python # 输入特征数 input_size = 1 # 隐藏层大小 hidden_size = 128 # 输出特征数 output_size = 4 # 学习率 learning_rate = 0.01 # 训练轮数 training_epochs = 2000 # 每轮训练的batch大小 batch_size = 32 # 每个样本的时间步数 time_steps = 20 ``` 接下来，定义一些辅助函数： ```python # 获取训练数据 def get_train_data(): train_data = [ "我 爱 你", "你 爱 我", "他 爱 她", "她 爱 他" ] labels = [ [0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ] return train_data, labels # 将中文文本转换成向量序列 def get_input_vec(text): input_vec = [] for c in text: input_vec.append([ord(c)]) return input_vec # 将向量序列转换成中文文本 def get_text(input_vec): text = "" for vec in input_vec: text += chr(vec[0]) return text # 将标签向量转换成标签字符串 def get_label(labels): if labels[0] == 1: return "S" elif labels[1] == 1: return "B" elif labels[2] == 1: return "M" elif labels[3] == 1: return "E" # 将标签字符串转换成标签向量 def get_label_vec(label): if label == "S": return [1, 0, 0, 0] elif label == "B": return [0, 1, 0, 0] elif label == "M": return [0, 0, 1, 0] elif label == "E": return [0, 0, 0, 1] ``` 然后，定义输入、输出和RNN层： ```python # 输入 x = tf.placeholder(tf.float32, [None, time_steps, input_size]) # 输出 y = tf.placeholder(tf.float32, [None, output_size]) # RNN层 cell = rnn.BasicLSTMCell(hidden_size) outputs, states = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32) ``` 接下来，定义输出层和损失函数： ```python # 输出层 W = tf.Variable(tf.truncated_normal([hidden_size, output_size], stddev=0.1)) b = tf.Variable(tf.zeros([output_size])) logits = tf.matmul(outputs[:, -1, :], W) + b prediction = tf.nn.softmax(logits) # 损失函数 loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=logits)) ``` 然后，定义优化器和训练过程： ```python # 优化器 optimizer = tf.train.AdamOptimizer(learning_rate) train_op = optimizer.minimize(loss) # 训练过程 init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) train_data, labels = get_train_data() for epoch in range(training_epochs): total_loss = 0 for i in range(0, len(train_data), batch_size): batch_data = train_data[i:i+batch_size] batch_labels = labels[i:i+batch_size] input_data = [] for text in batch_data: input_vec = get_input_vec(text) if len(input_vec) < time_steps: input_vec += [[0]] * (time_steps - len(input_vec)) else: input_vec = input_vec[:time_steps] input_data.append(input_vec) _, batch_loss = sess.run([train_op, loss], feed_dict={x: input_data, y: batch_labels}) total_loss += batch_loss if epoch % 100 == 0: print("Epoch:", epoch, "Loss:", total_loss) ``` 最后，可以使用训练好的模型进行预测： ```python # 使用训练好的模型进行预测 input_data = [[[ord("我")], [ord("爱")], [ord("你")], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0]], [[ord("你")], [ord("爱")], [ord("我")], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0]], [[ord("他")], [ord("爱")], [ord("她")], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0]], [[ord("她")], [ord("爱")], [ord("他")], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]] with tf.Session() as sess: sess.run(init) for input_vec in input_data: input_vec = [input_vec] output = sess.run(prediction, feed_dict={x: input_vec}) output_labels = [get_label_vec(np.argmax(output[0][i])) for i in range(time_steps)] output_text = get_text(input_vec[0]) i = 0 while i < time_steps: if output_labels[i][0] == 1: print(output_text[i], end=" ") i += 1 elif output_labels[i][1] == 1: j = i while j < time_steps and output_labels[j][2] == 0 and output_labels[j][3] == 0: j += 1 if j < time_steps and output_labels[j][3] == 1: j += 1 print(output_text[i:j], end=" ") i = j else: i += 1 print() ``` 这个代码实现了一个简单的基于RNN的中文分词系统，它可以将输入的中文文本分词并进行词性标注。请注意，这个代码只是一个示例，您可以根据自己的需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值