自然语言处理的一些算法研究和实现(NLTK)
2017-06-12 21:34
519 查看
递归
如果要计算n个词有多少种组合方式按照阶乘定义n nn-11
如果要寻找word下位词的大小并且将他们加和
构建一个字母查找树
贪婪算法不确定边界自然语言的分割问题退火算法的非确定性搜索
动态规划
首先用递归的方式编写一下找到任意音节的函数
使用动态规划来实现找到任意音节的函数
NLTK自带装饰符默记
其他的应用
词汇多样性
文体差异性
随机语句生成
词谜问题解决
时间和空间权衡全文检索系统
自然语言处理中算法设计有两大部分:分而治之 和 转化 思想。一个是将大问题简化为小问题,另一个是将问题抽象化,向向已知转化。前者的例子:归并排序;后者的例子:判断相邻元素是否相同(与排序)。
这次总结的自然语言中常用的一些基本算法,算是入个门了。
这里我们讨论一个梵文组合旋律的问题。短音节:S,一个长度;长音节:L,两个长度。所以构建长度为2的方式:{SS,L}。
对于以上两种方法,自下而上的方法在某些时候会浪费资源,因为,子问题不一定是解决主问题的必要条件。
欢迎进一步交流本博文相关内容:
博客园地址 : http://www.cnblogs.com/AsuraDong/
CSDN地址 : http://blog.csdn.net/asuradong
也可以致信进行交流 : xiaochiyijiu@163.com
欢迎转载 , 但请指明出处 : )
如果要计算n个词有多少种组合方式按照阶乘定义n nn-11
如果要寻找word下位词的大小并且将他们加和
构建一个字母查找树
贪婪算法不确定边界自然语言的分割问题退火算法的非确定性搜索
动态规划
首先用递归的方式编写一下找到任意音节的函数
使用动态规划来实现找到任意音节的函数
NLTK自带装饰符默记
其他的应用
词汇多样性
文体差异性
随机语句生成
词谜问题解决
时间和空间权衡全文检索系统
自然语言处理中算法设计有两大部分:分而治之 和 转化 思想。一个是将大问题简化为小问题,另一个是将问题抽象化,向向已知转化。前者的例子:归并排序;后者的例子:判断相邻元素是否相同(与排序)。
这次总结的自然语言中常用的一些基本算法,算是入个门了。
递归
使用递归速度上会受影响,但是便于理解算法深层嵌套对象。而一些函数式编程语言会将尾递归优化为迭代。如果要计算n个词有多少种组合方式?按照阶乘定义:n! = n*(n-1)*…*1
def func(wordlist): length = len(wordlist) if length==1: return 1 else: return func(wordlist[1:])*length
如果要寻找word下位词的大小,并且将他们加和。
from nltk.corpus import wordnet as wn def func(s):#s是WordNet里面的对象 return 1+sum(func(child) for child in s.hyponyms()) dog = wn.synset('dog.n.01') print(func(dog))
构建一个字母查找树
建立一个嵌套的字典结构,每一级的嵌套包含既定前缀的所有单词。而子查找树含有所有可能的后续词。def WordTree(trie,key,value): if key: first , rest = key[0],key[1:] if first not in trie: trie[first] = {} WordTree(trie[first],rest,value) else: trie['value'] = value WordDict = {} WordTree(WordDict,'cat','cat') WordTree(WordDict,'dog','dog') print(WordDict)
贪婪算法:不确定边界自然语言的分割问题(退火算法的非确定性搜索)
爬山法是完完全全的贪心法,每次都鼠目寸光的选择一个当前最优解,因此只能搜索到局部的最优值。模拟退火其实也是一种贪心算法,但是它的搜索过程引入了随机因素。模拟退火算法以一定的概率来接受一个比当前解要差的解,因此有可能会跳出这个局部的最优解,达到全局的最优解。import nltk from random import randint #text = 'doyou' #segs = '01000' def segment(text,segs):#根据segs,返回切割好的词链表 words = [] last = 0 for i in range(len(segs)): if segs[i]=='1':#每当遇见1,说明是词分界 words.append(text[last:i+1]) last = i+1 words.append(text[last:]) return words def evaluate(text,segs): #计算这种词分界的得分。作为分词质量,得分值越小越好(分的越细和更准确之间的平衡) words = segment(text,segs) text_size = len(words) lexicon_size = len(' '.join(list(set(words)))) return text_size + lexicon_size ###################################以下是退火算法的非确定性搜索############################################ def filp(segs,pos):#在pos位置扰动 return segs[:pos]+str(1-int(segs[pos]))+segs[pos+1:] def filp_n(segs,n):#扰动n次 for i in range(n): segs = filp(segs,randint(0,len(segs)-1))#随机位置扰动 return segs def anneal(text,segs,iterations,cooling_rate): temperature = float(len(segs)) while temperature>=0.5: best_segs,best = segs,evaluate(text,segs) for i in range(iterations):#扰动次数 guess = filp_n(segs,int(round(temperature))) score = evaluate(text,guess) if score<best: best ,best_segs = score,guess score,segs = best,best_segs temperature = temperature/cooling_rate #扰动边界,进行降温 print( evaluate(text,segs),segment(text,segs)) print() return segs text = 'doyouseethekittyseethedoggydoyoulikethekittylikethedoggy' seg = '0000000000000001000000000010000000000000000100000000000' anneal(text,seg,5000,1.2)
动态规划
它在自然语言中运用非常广泛。首先他需要一张表,用来将每一次的子结果存放在查找表之中。避免了重复计算子问题!!!这里我们讨论一个梵文组合旋律的问题。短音节:S,一个长度;长音节:L,两个长度。所以构建长度为2的方式:{SS,L}。
首先用递归的方式编写一下找到任意音节的函数
def func1(n): if n==0: return [""] elif n==1: return ["S"] else: s = ["S" + item for item in func1(n-1)] l = ["L" + item for item in func1(n-2)] return s+l print(func1(4))
使用动态规划来实现找到任意音节的函数
之前递归十分占用时间,如果是40个音节,我们需要重复计算632445986次。如果使用动态规划,我们可以把结果存到一个表中,需要时候调用,而不是很坑爹重复计算。def func2(n):#采用自下而上的动态规划 lookup = [[""],["S"]] for i in range(n-1): s = ["S"+ item for item in lookup[i+1]] l = ["L" + item for item in lookup[i]] lookup.append(s+l) return lookup print(func2(4)[4]) print(func2(4))
def func3(n,lookup={0:[""],1:["S"]}):#采用自上而下的动态规划 if n not in lookup: s = ["S" + item for item in func3(n-1)] l = ["L" + item for item in func3(n-2)] lookup = s+l return lookup #必须返回lookup .否则递归的时候会出错 print(func3(4))
对于以上两种方法,自下而上的方法在某些时候会浪费资源,因为,子问题不一定是解决主问题的必要条件。
NLTK自带装饰符:默记
装饰器@memoize会存储每次函数调用时的结果及参数,那么之后的在调用,就不用重复计算。而我们可以只把精力放在上层逻辑,而不是更关注性能和时间(被解决了)
from nltk import memoize @memoize def func4(n): if n==0: return [""] elif n==1: return ["S"] else: s = ["S" + item for item in func4(n-1)] l = ["L" + item for item in func4(n-2)] return s+l print(func4(4))
其他的应用
这里主要介绍一下除了上述两种主要算法外,一些小的使用技巧和相关基础概念。词汇多样性
词汇多样性主要取决于:平均词长(字母个数/每个单词)、平均句长(单词个数/每个句子)和文本中没歌词出现的次数。from nltk.corpus import gutenberg for fileid in gutenberg.fileids(): num_chars = len(gutenberg.raw(fileid)) num_words = len(gutenberg.words(fileid)) num_sents = len(gutenberg.sents(fileid)) num_vocab = len(set(w.lower() for w in gutenberg.words(fileid))) print(int(num_chars/num_words),int(num_words/num_sents),int(num_words/num_vocab),'from',fileid)
文体差异性
文体差异性可以体现在很多方面:动词、情态动词、名词等等。这里我们以情态动词为例,来分析常见情态动词的在不同文本的差别。from nltk.corpus import brown from nltk import FreqDist,ConditionalFreqDist cfd = ConditionalFreqDist(( genere,word) for genere in brown.categories() for word in brown.words(categories=genere)) genres=['news','religion','hobbies'] models = ['can','could','will','may','might','must'] cfd.tabulate(conditions = genres,samples=models)
随机语句生成
从《创世纪》中得到所有的双连词,根据概率分布,来判断哪些词最有可能跟在给定词后面。import nltk def create_sentence(cfd,word,num=15): for i in range(num): print(word,end=" ") word = cfd[word].max()#查找word最有可能的后缀 text= nltk.corpus.genesis.words("english-kjv.txt") bigrams = nltk.bigrams(text) cfd = nltk.ConditionalFreqDist(bigrams) print(create_sentence(cfd,'living'))
词谜问题解决
单词长度>=3,并且一定有r,且只能出现’egivrvonl’中的字母。puzzle_word = nltk.FreqDist('egivrvonl') base_word = 'r' wordlist = nltk.corpus.words.words() result = [w for w in wordlist if len(w)>=3 and base_word in w and nltk.FreqDist(w)<=puzzle_word] #通过FreqDist比较法(比较键对应的value),来完成字母只出现一次的要求!!! print(result)
时间和空间权衡:全文检索系统
除了研究算法,分析内部实现外。构造辅助数据结构,可以显著加快程序执行。import nltk def raw(file): contents = open(file).read() return str(contents) def snippet(doc,term):#查找doc中term的定位 text = ' '*30+raw(doc)+' '*30 pos = text.index(term) return text[pos-30:pos+30] files = nltk.corpus.movie_reviews.abspaths() idx = nltk.Index((w,f) for f in files for w in raw(f).split()) #注意nltk.Index格式 query = 'tem' while query!='quit' and query: query = input('>>> input the word:') if query in idx: for doc in idx[query]: print(snippet(doc,query)) else: print('Not found')
欢迎进一步交流本博文相关内容:
博客园地址 : http://www.cnblogs.com/AsuraDong/
CSDN地址 : http://blog.csdn.net/asuradong
也可以致信进行交流 : xiaochiyijiu@163.com
欢迎转载 , 但请指明出处 : )
相关文章推荐
- NLTK学习笔记(四):自然语言处理的一些算法研究
- 研究算法的一些想法
- 图像分割中阈值的自动选取的研究及其算法实现
- 一些常用算法实现
- CRC编码算法研究与实现
- 经典算法研究系列:五、红黑树算法的实现与剖析
- “共轭变换”图像处理算法在FPGA 上实现的研究
- 经典算法研究系列:九之续、sift算法的编译与实现
- 单节目变码率TS流复用算法的研究及实现
- 一个东大学生实现的一些算法
- 经典算法研究系列:九之续、sift算法的编译与实现
- 图像分割中阈值的自动选取的研究及其算法实现
- 用FPGA实现的RC6算法的研究
- NTLM挑战模式散列认证加密协议过程,算法实现与一些想法
- 在BlackBerry上实现短信防火墙的一些研究(破解的思路)
- 算法设计之一些算法的实现
- 订单自动生成器的算法研究与实现 推荐
- 一些图论相关算法的学习研究和C#版演示程序
- 经典算法研究系列:五、红黑树算法的实现与剖析
- 经典算法研究系列:九之续、sift算法的编译与实现