自然语言处理
自然语言处理
1. NLTK python的NLP工具包
2. WordNet 英文的语义网络
3. BabelNet 多语言版的语义网络, 全部数据有29GB, 需要以科研的身份申请, 否则只能在线上用每天限量1k的接口. 等有空试验下接口.
4. 决策树分类器
5. 朴素贝叶斯分类器
6. 最大熵分类器 -- 需要补习概率论知识了
Update 2018-06-15: 浙大概率论第四版, 看了两章, 看懂贝叶斯公式了. 但是没看到有关最大熵的章节, 继续看NLTK, 百度了一些最大熵的说明, 这次大概看懂了, 但是后面的词性标注, 句法标注还是看得很懵, 貌似还是需要很多语言相关的先验知识. 下载了deep learning book 中文版, 打算直接看深度学习吧
基础知识
词向量和语言模型 http://licstar.net/archives/328
分词参考汇总
SNS文本数据挖掘 http://www.matrix67.com/blog/archives/5044
1. 基于AC自动机的分词
https://spaces.ac.cn/archives/3908
这个是基于词库（用AC自动机载入）的分词，用动态规划得到概率最大的分词结果
import ahocorasick
import math
def load_dic(dicfile):
dic = ahocorasick.Automaton()
total = 0.0
with open(dicfile, 'r', encoding='utf-8') as dicfile:
words = []
for line in dicfile:
line = line.split(' ')
count = int(line[1])
if count <= 0:
count = 1
words.append((line[0], count))
total += int(line[1])
for word,occurs in words:
dic.add_word(word, (word, math.log(occurs/total))) #这里使用了对数概率，防止溢出
dic.make_automaton()
return dic
def print_all_cut(sentence):
words = []
for i,j in dic.iter(sentence):
print(i, j)
dic = load_dic('dict.txt')
# 可以看到, 序号就是词在句中的位置
print_all_cut('最大匹配法是指从左到右逐渐匹配词库中的词语')
'''
使用动态规划,
每次用start处的概率加上本词的概率, 如果end处未赋值或者end处的值比这个小, 就用这个值代替
如果start处还没有值, 就取start之前的最大的值造一个
'''
def max_proba_cut(sentence):
paths = {0:([], 0)}
end = 0
for i,j in dic.iter(sentence):
start,end = 1+i-len(j[0]), i+1
if start not in paths:
last = max([i for i in paths if i < start])
paths[start] = (paths[last][0]+[sentence[last:start]], paths[last][1]-10)
proba = paths[start][1]+j[1]
if end not in paths or proba > paths[end][1]:
paths[end] = (paths[start][0]+[j[0]], proba)
if end < len(sentence):
return paths[end][0] + [sentence[end:]]
else:
return paths[end][0]
path = max_proba_cut('最大匹配法是指从左到右逐渐匹配词库中的词语')
print(path)
2A. 基于信息熵的新词发现
https://spaces.ac.cn/archives/3491
这是无词库的分词方式，对语料预处理，去掉中英文标点仅保留中英文数字并拆分为句子，对所有内容进行1~N元划分，分别计算支持度和熵
import numpy as np
import pandas as pd
import re
from numpy import log, min
f = open('d:/WorkPython/tmp/TianLongBaBu.txt', 'r', encoding='utf-8') # 读取文章
s = f.read() # 读取为一个字符串
# 定义要去掉的标点字
drop_dict = [u'，', u'\n', u'。', u'、', u'：', u'(', u')', u'[', u']', u'.', u',', u' ', u'\u3000', u'”', u'“', u'？', u'?',
u'！', u'‘', u'’', u'…']
for i in drop_dict: # 去掉标点字
s = s.replace(i, '')
# 为了方便调用，自定义了一个正则表达式的词典
myre = {2: '(..)', 3: '(...)', 4: '(....)', 5: '(.....)', 6: '(......)', 7: '(.......)'}
min_count = 10 # 录取词语最小出现次数
min_support = 30 # 录取词语最低支持度，1代表着随机组合
min_s = 3 # 录取词语最低信息熵，越大说明越有可能独立成词
max_sep = 4 # 候选词语的最大字数
t = [] # 保存结果用。
l = list(s) # 将字符串拆成字符列表
serial = pd.Series(l) # 给每个字符加上编号, 从0开始
t.append(serial.value_counts()) # 对每个字符计算字频, 会产生一个按字频倒序的列表, 作为t[0]
tsum = t[0].sum() # 统计总字数, .sum()函数是pandas.Series的一个函数
rt = [] # 保存结果用
for m in range(2, max_sep + 1):
print(u'正在生成%s字词...' % m)
t.append([])
for i in range(m): # 生成所有可能的m字词, 放到t[m-1]
t[m - 1] = t[m - 1] + re.findall(myre[m], s[i:])
t[m - 1] = pd.Series(t[m - 1]).value_counts() # 对每个词计算词频, 产生按字频倒序的列表, 作为t[m-1]
t[m - 1] = t[m - 1][t[m - 1] > min_count] # 去掉词频小于min_count的词
tt = t[m - 1][:] # 复制刚才产生的列表
'''
用map的方式，将刚才产生的列表的每个元素，一一用lambda里的方法去计算, 这里
ms in tt.index ms是这个元素的值, 例如'段誉'
aa = ms[:m-1] 前一部分, 例如'段'
bb = tmp[m-1:] 后一部分, 例如'誉'
cc = t[m - 1][tmp] 这个元素的词频
dd = t[m - 2][tmp[:m - 1]] 前一部分对应元素的词频
ee = t[0][tmp[m - 1:]] 后一部分对应元素的词频
'''
ld = lambda ms: tsum * t[m - 1][ms] / t[m - 2 - k][ms[:m - 1 - k]] / t[k][ms[m - 1 - k:]]
for k in range(m - 1):
qq = np.array(list(map(ld, tt.index))) > min_support # 最小支持度筛选。
tt = tt[qq] # pandas.Series可以通过[True, False, ...]这样的序列提取子集合, 不断滤掉未达到最小支持度的词
rt.append(tt.index)
def cal_S(sl): # 信息熵计算函数
return -((sl / sl.sum()).apply(log) * sl / sl.sum()).sum()
for i in range(2, max_sep + 1):
print(u'正在进行%s字词的最大熵筛选(%s)...' % (i, len(rt[i - 2])))
pp = [] # 保存所有的左右邻结果
for j in range(i + 2):
pp = pp + re.findall('(.)%s(.)' % myre[i], s[j:])
pp = pd.DataFrame(pp).set_index(1).sort_index() # 先排序，这个很重要，可以加快检索速度
index = np.sort(np.intersect1d(rt[i - 2], pp.index)) # 作交集
# 下面两句分别是左邻和右邻信息熵筛选
index = index[np.array(list(map(lambda s: cal_S(pd.Series(pp[0][s]).value_counts()), index))) > min_s]
rt[i - 2] = index[np.array(list(map(lambda s: cal_S(pd.Series(pp[2][s]).value_counts()), index))) > min_s]
# 下面都是输出前处理
for i in range(len(rt)):
t[i + 1] = t[i + 1][rt[i]]
t[i + 1].sort_values(ascending=False)
# 保存结果并输出
pd.DataFrame(pd.concat(t[1:])).to_csv('result.txt', header=False)
2B. 基于切分的新词发现
https://spaces.ac.cn/archives/3913
简单地通过计算相邻两字出现的概率，断开概率低于阈值的字而达到分词的效果
import re
import json
from collections import defaultdict #defaultdict是经过封装的dict，它能够让我们设定默认值
from tqdm import tqdm #tqdm是一个非常易用的用来显示进度的库
from math import log
def load_texts(text_file):
with open(text_file, 'r', encoding='utf-8') as articles:
for article in articles:
json_obj = json.loads(article)
if 'content' in json_obj:
yield json_obj['content']
class Find_Words:
def __init__(self, min_count=10, min_pmi=0):
self.min_count = min_count
self.min_pmi = min_pmi
self.chars, self.pairs = defaultdict(int), defaultdict(int)
#如果键不存在，那么就用int函数初始化一个值，int()的默认结果为0
self.total = 0.
# 预切断句子，以免得到太多无意义（不是中文、英文、数字）的字符串
def text_filter(self, texts):
for a in tqdm(texts):
for t in re.split(u'[^\u4e00-\u9fa50-9a-zA-Z]+', a):
#这个正则表达式匹配的是任意非中文、非英文、非数字，因此它的意思就是用任意非中文、非英文、非数字的字符断开句子
if t:
yield t
# 计数函数，计算单字出现频数、相邻两字出现的频数
def count(self, texts):
for text in self.text_filter(texts):
self.chars[text[0]] += 1
for i in range(len(text)-1):
self.chars[text[i+1]] += 1
self.pairs[text[i:i+2]] += 1
self.total += 1
self.chars = {i:j for i,j in self.chars.items() if j >= self.min_count} #最少频数过滤
self.pairs = {i:j for i,j in self.pairs.items() if j >= self.min_count} #最少频数过滤
self.strong_segments = set()
for i,j in self.pairs.items(): #根据互信息找出比较“密切”的邻字
_ = log(self.total*j/(self.chars[i[0]]*self.chars[i[1]]))
if _ >= self.min_pmi:
self.strong_segments.add(i)
# 根据前述结果来找词语
def find_words(self, texts):
self.words = defaultdict(int)
for text in self.text_filter(texts):
s = text[0]
for i in range(len(text)-1):
if text[i:i+2] in self.strong_segments: #如果比较“密切”则不断开
s += text[i+1]
else:
self.words[s] += 1 #否则断开，前述片段作为一个词来统计
s = text[i+1]
self.words = {i:j for i,j in self.words.items() if j >= self.min_count} #最后再次根据频数过滤
fw = Find_Words(16, 1)
fw.count(load_texts('D:/WorkPython/tmp/articles.json'))
fw.find_words(load_texts('D:/WorkPython/tmp/articles.json'))
import pandas as pd
words = pd.Series(fw.words).sort_values(ascending=False)
words.to_csv('output.csv')
3. 字标注法与HMM模型
https://spaces.ac.cn/archives/3922
4. 基于双向LSTM的seq2seq字标注
https://spaces.ac.cn/archives/3924
5. 基于语言模型的无监督分词
https://spaces.ac.cn/archives/3956
使用KenLM作为训练工具，使用预先分好词的语料进行训练，生成klm格式的语言模型后，在python中载入处理分词。
6. 基于全卷积网络的中文分词 https://spaces.ac.cn/archives/4195
7. 用词典完成深度学习分词 https://spaces.ac.cn/archives/4245
8. 改进新词发现算法 https://spaces.ac.cn/archives/6920
专业词汇的无监督挖掘 https://spaces.ac.cn/archives/6540
Keras seq2seq自动生成标题 https://kexue.fm/archives/5861
