切分算法
完全切分
遍历文本找出在词典中的词语
正向,逆向,双向最长匹配
正向最长匹配 ,即在完全切分基础上加了一个规则:优先选取长度更长的单词
逆向最长匹配,即将正向匹配的扫描顺序改为从后到前
正向和逆向都有各自出现歧义的情况,融合两种匹配
双向最长匹配,即同时运行两者,若词数不同则返回词数少的,不然返回单字少的,否则返回逆向匹配
缺点
没有技术含量,消歧效果也不好,时间复杂度较高
针对时间复杂度,引入字典树,AC自动机
而消歧效果,则需要一些机器学习,深度学习的算法
字典树
基本原理
将文本分成单字,构建树
因为是树的结构,最坏情况的时间复杂度为O(logn),并且不需要存储所有切分结果,也比较省内存
python 版本代码实现
# -*- coding:utf-8 -*-
class TrieNode(object):
def __init__(self, value=None, count=0, parent=None):
# 值
self.value = value
# 频数统计
self.count = count
# 父结点
self.parent = parent
# 子节点,{value:TrieNode}
self.children = {}
class Trie(object):
def __init__(self):
# 创建空的根节点
self.root = TrieNode()
def insert(self, sequence):
"""
基操,插入一个序列
:param sequence: 列表
:return:
"""
cur_node = self.root
for item in sequence:
if item not in cur_node.children:
# 插入结点
child = TrieNode(value=item, count=1, parent=cur_node)
cur_node.children[item] = child
cur_node = child
else:
# 更新结点
cur_node = cur_node.children[item]
cur_node.count += 1
def search(self, sequence):
"""
基操,查询是否存在完整序列
:param sequence: 列表
:return:
"""
cur_node = self.root
mark = True
for item in sequence:
if item not in cur_node.children:
mark = False
break
else:
cur_node = cur_node.children[item]
# 如果还有子结点,说明序列并非完整
if cur_node.children:
mark = False
return mark
def delete(self, sequence):
"""
基操,删除序列,准确来说是减少计数
:param sequence: 列表
:return:
"""
mark = False
if self.search(sequence):
mark = True
cur_node = self.root
for item in sequence:
cur_node.children[item].count -= 1
if cur_node.children[item].count == 0:
cur_node.children.pop(item)
break
else:
cur_node = cur_node.children[item]
return mark
def search_part(self, sequence, prefix, suffix, start_node=None):
"""
递归查找子序列,返回前缀和后缀结点
此处简化操作,仅返回一位前后缀的内容与频数
:param sequence: 列表
:param prefix: 前缀字典,初始传入空字典
:param suffix: 后缀字典,初始传入空字典
:param start_node: 起始结点,用于子树的查询
:return:
"""
#递归时设置父节点
if start_node:
cur_node = start_node
prefix_node = start_node.parent
else:
cur_node = self.root
prefix_node = self.root
# mark代表查找是否成功。某一次查找失败,则将mark置false,不需要提取其前缀和后缀
mark = True
# 必须从第一个结点开始对比
for i in range(len(sequence)):
if i == 0:
if sequence[i] != cur_node.value:
for child_node in cur_node.children.values():
self.search_part(sequence, prefix, suffix, child_node)
mark = False
#如果当前节点不是需要查找的句子的第一个词,则停止继续查找
break
else:
if sequence[i] not in cur_node.children:
for child_node in cur_node.children.values():
self.search_part(sequence, prefix, suffix, child_node)
mark = False
break
else:
cur_node = cur_node.children[sequence[i]]
if mark:
if prefix_node.value:
# 前缀数量取序列词中最后一词的频数
if prefix_node.value in prefix:
prefix[prefix_node.value] += cur_node.count
else:
prefix[prefix_node.value] = cur_node.count
for suffix_node in cur_node.children.values():
if suffix_node.value in suffix:
suffix[suffix_node.value] += suffix_node.count
else:
suffix[suffix_node.value] = suffix_node.count
# 即使找到一部分还需继续查找子结点
for child_node in cur_node.children.values():
self.search_part(sequence, prefix, suffix, child_node)
if __name__ == "__main__":
trie = Trie()
texts = ["葬爱少年葬爱少年睦洲立哈哈", "葬爱少年阿西吧", "烈烈风中", "忘记了爱",
"埋葬了爱"]
for text in texts:
trie.insert(text)
markx = trie.search("忘记了爱")
print(markx)
markx = trie.search("忘记了")
print(markx)
markx = trie.search("忘记爱")
print(markx)
markx = trie.delete("葬爱少年王周力")
print(markx)
prefixx = {}
suffixx = {}
trie.search_part("葬爱少年", prefixx, suffixx)
print(prefixx)
print(suffixx)
适用场景
词频统计,字符串检索,停用词过滤
缺点
只是简单的切分,并非分词,消歧效果,OOV识别率都非常不理想
时间复杂度尚可改进.此处引入AC自动机
AC自动机
基本原理
和KMP算法有些类似
同样需要建树,在查找树的同时,如果遇到匹配失败,则通过fail指阻止回溯,将时间复杂度降至o(n)
python代码
# -*- coding:utf-8 -*-
from collections import defaultdict
class TrieNode(object):
def __init__(self, value=None):
# 值
self.value = value
# fail指针
self.fail = None
# 尾标志:标志为i表示第i个模式串串尾,默认为0
self.tail = 0
# 子节点,{value:TrieNode}
self.children = {}
class Trie(object):
def __init__(self, words):
print("初始化")
# 根节点
self.root = TrieNode()
# 模式串个数
self.count = 0
self.words = words
for word in words:
self.insert(word)
self.ac_automation()
print("初始化完毕")
def insert(self, sequence):
"""
基操,插入一个字符串
:param sequence: 字符串
:return:
"""
self.count += 1
cur_node = self.root
for item in sequence:
if item not in cur_node.children:
# 插入结点
child = TrieNode(value=item)
cur_node.children[item] = child
cur_node = child
else:
cur_node = cur_node.children[item]
cur_node.tail = self.count
def ac_automation(self):
"""
构建失败路径
:return:
"""
queue = [self.root]
# BFS遍历字典树
while len(queue):
temp_node = queue[0]
# 取出队首元素
queue.remove(temp_node)
for value in temp_node.children.values():
# 根的子结点fail指向根自己
if temp_node == self.root:
value.fail = self.root
else:
# 转到fail指针
p = temp_node.fail
while p:#while循环的意义是:当p不是none且没有合适的匹配,无法构建fail指针时,将fail指针还原到根节点
# 若当前节点的值有在当前节点的父节点fail指针指向的节点的子节点的值时,构建fail指针,终止循环
if value.value in p.children:
value.fail = p.children[value.value]
break
# 转到fail指针继续回溯
p = p.fail
# 若为None,表示当前结点值在之前都没出现过,则其fail指向根结点
if not p:
value.fail = self.root
# 将当前结点的所有子结点加到队列中
queue.append(value)
def search(self, text):
"""
模式匹配
:param self:
:param text: 长文本
:return:
"""
p = self.root
# 记录匹配起始位置下标
start_index = 0
# 成功匹配结果集
rst = defaultdict(list)
for i in range(len(text)):
single_char = text[i]
while single_char not in p.children and p is not self.root:
p = p.fail
# 有一点瑕疵,原因在于匹配子串的时候,若字符串中部分字符由两个匹配词组成,此时后一个词的前缀下标不会更新
# 这是由于KMP算法本身导致的,目前与下文循环寻找所有匹配词存在冲突
# 但是问题不大,因为其标记的位置均为匹配成功的字符
if single_char in p.children and p is self.root:
start_index = i
# 若找到匹配成功的字符结点,则指向那个结点,否则指向根结点
if single_char in p.children:
p = p.children[single_char]
else:
start_index = i
p = self.root
temp = p
while temp is not self.root:
# 尾标志为0不处理,但是tail需要-1从而与敏感词字典下标一致
# 循环原因在于,有些词本身只是另一个词的后缀,也需要辨识出来
if temp.tail:
rst[self.words[temp.tail - 1]].append((start_index, i))
temp = temp.fail
return rst
if __name__ == "__main__":
test_words = ["he", "she", "hers", "his"]
test_text = """ahishers"""
model = Trie(test_words)
# defaultdict(<class 'list'>, {'his': [(1, 3)], 'she': [(1, 5)], 'he': [(1, 5)], 'hers': [(1, 7)]})
print(str(model.search(test_text)))
优点
时间复杂度低
缺点:
与字典树相似.另外,大量使用指针等,用空间换时间
适用场景:
与字典树相似