精华内容
下载资源
问答
  • SIFT双向匹配算法

    2012-04-18 10:01:47
    SIFT双向匹配算法,有双向匹配的源程序,在运用SIFT算法单向匹配的基础上加入反向匹配
  • 图像匹配是计算机视觉中许多领域的基础, 特征提取则是图像匹配的基础, 其中不变量...分析了基于S I F t特征的图像匹配算法, 提出了双向匹配算法, 提高了图像匹配的准确率。实 验结果表明所提出的方法是有效的。
  • #正向向最大匹配法 def MM(text): #读取词典 dictionary = [] dic_path = r'F:\大三下\自然语言处理\chapter-4\dic.utf8' # 在windows上使用open打开utf-8编码的txt文件时开头会有一个多余的字符 # 它叫BOM,是...

    分词词典:
    在这里插入图片描述

    import os
    #正向向最大匹配法
    def MM(text):
        #读取词典
        dictionary = []
        dic_path = r'F:\大三下\自然语言处理\chapter-4\dic.utf8'
    # 在windows上使用open打开utf-8编码的txt文件时开头会有一个多余的字符
    # 它叫BOM,是用来声明编码等信息的,但python会把它当作文本解析
    # 解决办法:open的encoding参数
    # for line in open(, encoding='utf_8_sig' ): 
        for line in open(dic_path,'r',encoding='utf_8_sig'):
            line = line.strip()
            if not line:
                continue
            dictionary.append(line)
        dictionary = list(set(dictionary))
        #获取词典最大长度
        max_length = 0
        word_length = []
        for word in dictionary:
            word_length.append(len(word))
        max_length = max(word_length)    
        #切分文本
        cut_list = []
        text_length = len(text)  
        while text != '':
            if text_length < max_length:
                max_length = text_length
            new_word = text[: max_length] # 以最长分词词典的词组长度最先匹配
            
            while new_word not in dictionary:
                new_word = new_word[: len(new_word)-1] # 不匹配时长度减一
                if len(new_word) == 1 :
                    break
            cut_list.append(new_word)  # 向列表中加入划分文本单词或词组
            text = text[len(new_word):] # 匹配时切除已匹配词
        return cut_list
    
    MM("北京市民办高中")
    

    分词结果:
    在这里插入图片描述

    import os
    #逆向最大匹配法
    def RMM(text):
        #读取词典
        dictionary = []
        dic_path = r'F:\大三下\自然语言处理\chapter-4\dic.utf8'
    # 在windows上使用open打开utf-8编码的txt文件时开头会有一个多余的字符
    # 它叫BOM,是用来声明编码等信息的,但python会把它当作文本解析
    # 解决办法:open的encoding参数
    # for line in open(, encoding='utf_8_sig' ): 
    
        for line in open(dic_path,'r',encoding='utf_8_sig'):
            line = line.strip()
            if not line:
                continue
            dictionary.append(line)
        dictionary = list(set(dictionary))
        #获取词典最大长度
        max_length = 0
        word_length = []
        for word in dictionary:
            word_length.append(len(word))
        max_length = max(word_length)    
        #切分文本
        cut_list = []
        text_length = len(text)
        while text_length > 0:
            j = 0
            for i in range(max_length, 0, -1):
                if text_length - i < 0:
                    continue
                # 从右到左依次配对分词表
                new_word = text[text_length - i:text_length]
                if new_word in dictionary:
                    cut_list.append(new_word)  # 挑拣出文本中在分词表相同的词
                    text_length -= i
                    j += 1
                    break  
            if j == 0:
                text_length -= 1
                cut_list.append(new_word)  # 添加单字未匹配字符
        cut_list.reverse()  # 将列表中元素倒序排列
        return cut_list
    
    RMM('北京市的民办高中')
    

    分词结果:
    在这里插入图片描述
    调用以上函数实现双向匹配:

    def BMM(text):
        print("MM: ", MM("北京市民办高中"))
        print("RMM: ", RMM("北京市民办高中"))
        while len(MM(text)) <= len(RMM(text)) :
              print(MM("北京市民办高中"))
        print('BMM:', RMM(text))
    
    BMM("北京市民办高中")
    

    分词结果:
    在这里插入图片描述

    展开全文
  • 本次实验内容是基于词典的双向匹配算法的中文分词算法的实现。使用正向和反向最大匹配算法对给定句子进行分词,对得到的结果进行比较,从而决定正确的分词方法。算法描述正向最大匹配算法先设定扫描的窗口大小maxLen...

    本次实验内容是基于词典的双向匹配算法的中文分词算法的实现。使用正向和反向最大匹配算法对给定句子进行分词,对得到的结果进行比较,从而决定正确的分词方法。

    算法描述

    正向最大匹配算法

    先设定扫描的窗口大小maxLen(最好是字典最长的单词长度),从左向右取待切分汉语句的maxLen个字符作为匹配字段。查找词典并进行匹配。若匹配成功,则将这个匹配字段作为一个词切分出来,并将窗口向右移动这个单词的长度。若匹配不成功,则将这个匹配字段的最后一个字去掉,剩下的字符串作为新的匹配字段,进行再次匹配,重复以上过程,直到切分出所有词为止。

    反向最大匹配算法

    该算法是正向的逆向算法,区别是窗口是从后向左扫描,若匹配不成功,则去掉第一个字符,重复上述的匹配步骤。

    双向最大匹配算法

    双向最大匹配法是将正向最大匹配法得到的分词结果和逆向最大匹配法的到的结果进行比较,从而决定正确的分词方法。定义的匹配规则如下:

    如果正反向匹配算法得到的结果相同,我们则认为分词正确,返回任意一个结果即可。

    如果正反向匹配算法得到的结果不同,则考虑单字词、非字典词、总词数数量的数量,三者的数量越少,认为分词的效果越好。我们设定一个惩罚分数(score_fmm / score_bmm = 0),例如:正向匹配中单字词数量多于反向匹配,则正向匹配的分值score_fmm += 1。其他两个条件相同。可以根据实际的分词效果调整惩罚分数的大小,但由于没有正确分词的数据,因此惩罚分数都设为1。最后比较惩罚分数,返回较小的匹配结果。

    详例描述

    以“对外经济技术合作与交流不断扩大。”为例,详细描述算法如下:

    窗口大小设为4,句子长度为16,分词列表words = []。

    首先是正向匹配。sub_str = ‘对外经济’与词典进行匹配,匹配失败,窗口大小减一。

    sub_str = ‘对外经’与词典进行匹配,匹配失败,窗口大小减一。

    sub_str = ‘对外’与词典进行匹配,匹配成功,窗口大小恢复为4,向右移动之前匹配词的长度,此时sub_str = ‘经济技术’,将其添加至列表words中。重复上述步骤。

    当匹配到最后一个词时,算法停止。

    正向匹配结果如下:[‘对外’, ‘经济’, ‘技术’, ‘合作’, ‘与’, ‘交流’, ‘不断’, ‘扩大’, ‘。’]

    反向匹配如法炮制,结果如下:[‘对外’, ‘经济’, ‘技术’, ‘合作’, ‘与’, ‘交流’, ‘不断’, ‘扩大’, ‘。’]

    正向与反向匹配结果相同,返回任意一个。

    代码:

    加载字典

    def read_dict(path):

    words_dict = []

    with open(path, 'r') as r:

    line = r.readlines()

    # print(line)

    for i in line:

    word = i.split(',')

    words_dict.append(word[0])

    return words_dict

    window_size = 4

    正向匹配算法

    def fmm(source, words_dict):

    len_source = len(source) # 原句长度

    index = 0

    words = [] # 分词后句子每个词的列表

    while index < len_source: # 如果下标未超过句子长度

    match = False

    for i in range(window_size, 0, -1):

    sub_str = source[index: index+i]

    if sub_str in words_dict:

    match = True

    words.append(sub_str)

    index += i

    break

    if not match:

    words.append(source[index])

    index += 1

    return words

    反向匹配算法

    def bmm(source, word_dict):

    len_source = len(source) # 原句长度

    index = len_source

    words = [] # 分词后句子每个词的列表

    while index > 0:

    match = False

    for i in range(window_size, 0, -1):

    sub_str = source[index-i: index]

    if sub_str in words_dict:

    match = True

    words.append(sub_str)

    index -= i

    break

    if not match:

    words.append(source[index-1])

    index -= 1

    words.reverse() # 得到的列表倒序

    return words

    双向匹配算法

    def bi_mm(source, word_dict):

    forward = fmm(source, words_dict)

    backward = bmm(source, words_dict)

    # 正反向分词结果

    print("FMM: ", forward)

    print("BMM: ", backward)

    # 单字词个数

    f_single_word = 0

    b_single_word = 0

    # 总词数

    tot_fmm = len(forward)

    tot_bmm = len(backward)

    # 非字典词数

    oov_fmm = 0

    oov_bmm = 0

    # 罚分,罚分值越低越好

    score_fmm = 0

    score_bmm = 0

    # 如果正向和反向结果一样,返回任意一个

    if forward == backward:

    return backward

    # print(backward)

    else: # 分词结果不同,返回单字数、非字典词、总词数少的那一个

    for each in forward:

    if len(each) == 1:

    f_single_word += 1

    for each in backward:

    if len(each) == 1:

    b_single_word += 1

    for each in forward:

    if each not in words_dict:

    oov_fmm += 1

    for each in backward:

    if each not in backward:

    oov_bmm += 1

    # 可以根据实际情况调整惩罚分值

    # 这里都罚分都为1分

    # 非字典词越少越好

    if oov_fmm > oov_bmm:

    score_bmm += 1

    elif oov_fmm < oov_bmm:

    score_fmm += 1

    # 总词数越少越好

    if tot_fmm > tot_bmm:

    score_bmm += 1

    elif tot_fmm < tot_bmm:

    score_fmm += 1

    # 单字词越少越好

    if f_single_word > b_single_word:

    score_bmm += 1

    elif f_single_word < b_single_word:

    score_fmm += 1

    # 返回罚分少的那个

    if score_fmm < score_bmm:

    return forward

    else:

    return backward

    主函数,测试了分词的时间,包括加载词典的时间

    if __name__ == '__main__':

    start = time.time()

    words_dict = read_dict('chineseDic.txt')

    # print(bmm("我正在上自然语言处理课。", words_dict))

    # print("result: ", result)

    print("BiMM: ", bi_mm("对外经济技术合作与交流不断扩大。", words_dict))

    end = time.time()

    print("running time: " + str(end - start) + "s")

    展开全文
  • 本文实现双向匹配算法,具体算法描述如下: 正向最大匹配算法描述: 设MaxLen表示最大词长,D为分词词典 (1) 从待切分语料中按正向取长度为MaxLen的字串str,令 Len=MaxLen; (2) 把str与D中的词从左往右相

    双向最大匹配算法(含完整代码实现,ui界面)正向最大匹配算法,逆向最大匹配算法

    一、理论描述

    中文分词(Chinese Word Segmentation) 指的是将一个汉字序列切分成一个一个单独的词。分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。

    二、算法描述

    本文实现双向匹配算法,具体算法描述如下:

    正向最大匹配算法描述:

    设MaxLen表示最大词长,D为分词词典

    (1) 从待切分语料中按正向取长度为MaxLen的字串str,令

    Len=MaxLen;

    (2) 把str与D中的词从左往右相匹配;

    (3) 若匹配成功,则认为该字串为词,指向待切分语料的指

    针向前移Len个汉字,返回到(1);

    (4) 若不成功:如果Len>1,则将Len减1,从待切分语料中

    取长度为Len的字串str,返回到(2)。否则,得到长度为

    2的单字词,指向待切分语料的指针向前移1个汉字,

    返回(1)。

    反向最大匹配**算法描述:

    设MaxLen表示最大词长,D为分词词典

    (1) 从待切分语料中按正向取长度为MaxLen的字串str,令

    Len=MaxLen;

    (2) 把str与D中的词从右往左相匹配;

    (3) 若匹配成功,则认为该字串为词,指向待切分语料的指

    针向后移Len个汉字,返回到(1);

    (4) 若不成功:如果Len>1,则将Len减1,从待切分语料中

    取长度为Len的字串str,返回到(2)。否则,得到长度为

    2的单字词,指向待切分语料的指针向后移1个汉字,

    返回(1)。

    三、详例描述

    正向:

    S1=“计算语言学课程是三个课时” ,设定最大词长MaxLen = 5 ,S2= " "

    字典中含有三个词:[计算语言学]、[课程]、[课时]

    (1)S2="";S1不为空,从S1左边取出候选子串W=“计算语言学”;
    (2)查词表,“计算语言学”在词表中,将W加入到S2中,S2=“计算语言学/ ”, 并将W从S1中去掉,此时S1=“课程是三个课时”;
    (3)S1不为空,于是从S1左边取出候选子串W=“课程是三个”;
    (4)查词表,W不在词表中,将W最右边一个字去掉,得到W=“课程是三”;
    (5)查词表,W不在词表中,将W最右边一个字去掉,得到W=“课程是”;
    (6)查词表,W不在词表中,将W最右边一个字去掉,得到W=“课程”
    (7)查词表,W在词表中,将W加入到S2中,S2=“计算语言学/ 课程/ ”,并 将W从S1中去掉,此时S1=“是三个课时”;

    (8)S1不为空,于是从S1左边取出候选子串W=“是三个课时”;
    (9)查词表,W不在词表中,将W最右边一个字去掉,得到W=“是三个课”;
    (10)查词表,W不在词表中,将W最右边一个字去掉,得到W=“是三个”;
    (11)查词表,W不在词表中,将W最右边一个字去掉,得到W=“是三”
    (12)查词表,W不在词表中,将W最右边一个字去掉,得到W=“是”,这时 W是单字,将W加入到S2中,S2=“计算语言学/ 课程/ 是/ ”,并将 W从S1中去掉,此时S1=“三个课时”;
    (13)S1不为空,从S1左边取出候选子串W=“三个课时”;
    (14)查词表,W不在词表中,将W最右边一个字去掉,得到W=“三个课”;
    (15)查词表,W不在词表中,将W最右边一个字去掉,得到W=“三个”;
    (16)查词表,W不在词表中,将W最右边一个字去掉,得到W=“三”,这时 W是单字,将W加入到S2中,S2=“计算语言学/ 课程/ 是/ 三/ ”,并 将W从S1中去掉,此时S1=“个课时”;

    (17)S1不为空,从S1左边取出候选子串W=“个课时”;
    (18)查词表,W不在词表中,将W最右边一个字去掉,得到W=“个课”;
    (19)查词表,W不在词表中,将W最右边一个字去掉,得到W=“个”, 这时W是单字,将W加入到S2中,S2=“计算语言学/ 课程/ 是/ 三/ 个/ “,并将W从S1中去掉,此时S1=“课时”;
    (20)S1不为空,从S1左边取出候选子串W=“课时”;
    (21)查词表,W在词表中,将W加入到S2中,S2=“计算语言学/ 课程/ 是/ 三/ 个/ 课时/ “,并将W从S1中去掉,此时S1=””。
    (22)S1为空,输出S2作为分词结果,分词过程结束。

    逆向:

    待分词句子: sentence[]={“计算语言学课程有意思”}

    词表: dict[]={“计算”, “计算语言学”, “课程”, “有”, “意思”}

    首先我们定义一个最大分割长度5,从右往左开始分割:

    (1)首先取出来的候选词W是 “课程有意思”。

    (2) 查词表,W不在词表中,将W最左边的第一个字去掉,得到W“程有意思”;

    (3) 查词表,W也不在词表中,将W最左边的第一个字去掉,得到W“有意思”;

    (4) 查词表,W也不在词表中,将W最左边的第一个字再去掉,得到W“意思”;

    (5) 查词表,W在词表中,就将W从整个句子中拆分出来,此时原句子为“计算语言学课程有”

    (6)根据分割长度5,截取句子内容,得到候选句W是“言学课程有”;

    (7) 查词表,W不在词表中,将W最左边的第一个字去掉,得到W“言学课程有”;

    (8) 查词表,W也不在词表中,将W最左边的第一个字去掉,得到W“学课程有”;

    (9) 依次类推,直到W为“有”一个词的时候,这时候将W从整个句子中拆分出来,此时句子为“计算语言学课程”

    (10)根据分割长度5,截取句子内容,得到候选句W是“算语言学课程”;

    (11)查词表,W不在词表中,将W最左边的第一个字去掉,得到W“语言学课程”;

    (12) 依次类推,直到W为“课程”的时候,这时候将W从整个句子中拆分出来,此时句子为“计算语言学”

    (13)根据分割长度5,截取句子内容,得到候选句W是“计算语言学”;

    (14) 查词表,W在词表,分割结束

    四、软件演示

    正向匹配:

    img

    逆向匹配:

    img

    正向匹配和逆向匹配的结果是一样的。而多次测试后,时间上总体来说是正向匹配算法比较长。逆向匹配算法时间稍少几毫秒。但也会出现逆向匹配算法时间较长的情况。两者的时间复杂度是一样的。

    正向分词匹配代码

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    
    
    public class seg {
        
        String result;
        String segstring;
        int MaxLen;
        int Len;
        int indexpos;
        Map <String,String> dict; //<"石柱",n>
        
        public seg(String inputstr, int maxlen)
        {
            segstring=inputstr;
            MaxLen=maxlen;
            Len=MaxLen;
            indexpos=0;
            result="";
            dict=new HashMap<String,String>();
            
        }
        
        public void ReadDic() throws FileNotFoundException, IOException
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("chineseDic.txt"),"GBK"));
            String line = null; 
            while((line = br.readLine())!=null)
            {
                String[] words=line.trim().split(",");//"石柱",n,  words=["石柱","n"]
                String word=words[0];
                String cx=words[1]; 
                dict.put(word, cx);
            } 
            br.close();
        }
        
        public String MM_Seg() throws IOException
        {//正向最大匹配算法
            ReadDic();//读入字典
            segstring=segstring.replaceAll(" ", "");
            MM(segstring,MaxLen,0);//正向最大分词 
            return result;
        }
        
        public void MM(String str,int len,int frompos)
        {
            if(frompos+1>str.length())
                return;
            String curstr="";
    
            int llen=str.length()-(frompos);
            if(llen<=len)
                curstr=str.substring(frompos,frompos+llen);
            else
                curstr=str.substring(frompos,frompos+len);
                
            if(dict.containsKey(curstr))
            {
                result=result+curstr+"/ ";
                Len=MaxLen;
                indexpos=frompos+len;
                MM(str,Len,indexpos);
            }
            else
            {
                if(Len>1)
                {
                    Len=Len-1;
                    MM(str,Len,frompos);
                }
                else
                {
                    result=result+str+"/ ";
                    frompos=frompos+1;
                    Len=MaxLen;
                    MM(str,Len,frompos);
                }
            }
        }
        
        
        public String getResult()
        {
            return result;
        }
                
        public static void main(String[] args) throws IOException, Exception
        {
            seg s=new seg("一把青菜勤奋勤政勤勤俭节约奇鸟怪物节",3);
            String result=s.MM_Seg();
            System.out.println(result);
            
        }
                
        
    }
    

    逆向

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     *
     * @author shelly
     */
    public class RMM {
    
        String result;
        String segstring;
        int MaxLen;
        int Len;
        int indexpos;
        Map <String,String> dict; //<"石柱",n>
    
        public RMM(String inputstr, int maxlen)
        {
            segstring=inputstr;
            MaxLen=maxlen;
            Len=MaxLen;
            indexpos=0;
            result="";
            dict=new HashMap<String,String>();
    
        }
    
        public void ReadDic() throws FileNotFoundException, IOException
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("chineseDic.txt"),"GBK"));
            String line = null;
            while((line = br.readLine())!=null)
            {
                String[] words=line.trim().split(",");//"石柱",n,  words=["石柱","n"]
                String word=words[0];
                String cx=words[1];
                dict.put(word, cx);
            }
            br.close();
        }
    
        public String RMM_Seg() throws IOException
        {//反向最大匹配算法
            ReadDic();//读入字典
    //        segstring=segstring.trim();
            segstring=segstring.replaceAll(" ", "");
            MM(segstring,MaxLen,segstring.length()-1);//反向最大分词
            return result;
        }
    
        public void MM(String str,int len,int frompos)
        {
            if(frompos<0)
                return;
            String curstr="";
    
            int llen=frompos+1-len;
            if(llen>=0)
                curstr=str.substring(frompos-len+1,frompos+1);
            else
                curstr=str.substring(0,frompos+1);
    
            if(dict.containsKey(curstr))
            {
                result=curstr+"/ "+result;
                Len=MaxLen;
                indexpos=frompos-len;
                MM(str,Len,indexpos);
            }
            else
            {
                if(Len>1)
                {
                    Len=Len-1;
                    MM(str,Len,frompos);
                }
                else
                {
                    result=result+str+"/ ";
                    frompos=frompos-1;
                    Len=MaxLen;
                    MM(str,Len,frompos);
                }
            }
        }
    
    
        public String getResult()
        {
            return result;
        }
    
        public static void main(String[] args) throws IOException, Exception
        {
            RMM rm=new RMM("一你是的             是打多        分艾菲奥德赛",3);
            String result=rm.RMM_Seg();
            System.out.println(result);
    
        }
    
    
    }
    

    UI界面代码

    
    
    import javafx.application.Application;
    import javafx.geometry.Insets;
    import javafx.geometry.Pos;
    import javafx.scene.Scene;
    import javafx.scene.control.Button;
    import javafx.scene.control.TextArea;
    import javafx.scene.control.TextField;
    import javafx.scene.layout.BorderPane;
    import javafx.scene.layout.HBox;
    import javafx.scene.layout.VBox;
    import javafx.stage.Stage;
    
    import java.io.IOException;
    
    public class ui extends Application {
    
        private Button zheng=new Button("正向匹配");
        private Button ni=new Button("逆向匹配");
        private TextField time = new TextField();
        private TextField time1 = new TextField();
        private TextArea tffen = new TextArea();
        private TextArea tfconsult = new TextArea();
        private TextArea tfconsultni = new TextArea();
        public static void main(String[] args) {
            launch(args);
        }
    
    
        @Override
        public void start(Stage primaryStage) {
            tffen.setWrapText(true);
            tfconsult.setWrapText(true);
            tfconsultni.setWrapText(true);
            BorderPane mainpane = new BorderPane();
            HBox hBox = new HBox();
            hBox.setSpacing(30);
            hBox.setAlignment(Pos.CENTER);
            hBox.getChildren().addAll(zheng,time);
            HBox hBox1 = new HBox();
            hBox1.setSpacing(30);
            hBox1.setAlignment(Pos.CENTER);
            hBox1.getChildren().addAll(ni,time1);
            VBox vBox = new VBox();
            vBox.setSpacing(5);
            vBox.setPadding(new Insets(10,20,10,20));
            vBox.getChildren().addAll(tffen,hBox,tfconsult,hBox1,tfconsultni);
            mainpane.setCenter(vBox);
            Scene scene = new Scene(mainpane,500,500);
            primaryStage.setScene(scene);
            primaryStage.show();
    
            zheng.setOnAction(event -> {
                tfconsult.clear();
                time.clear();
                String msg = tffen.getText();
                seg se = new seg(msg,4);
                try {
                    long startTime = System.currentTimeMillis();
                    String re = se.MM_Seg();
                    long endTime = System.currentTimeMillis();
                    time.appendText(String.valueOf(endTime-startTime)+"ms");
                    tfconsult.appendText(re);
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            });
            ni.setOnAction(event -> {
                tfconsultni.clear();
                time1.clear();
                String msg = tffen.getText();
                RMM rm = new RMM(msg,4);
                try {
                    long startTime = System.currentTimeMillis();
                    String re = rm.RMM_Seg();
                    long endTime = System.currentTimeMillis();
                    time1.appendText(String.valueOf(endTime-startTime)+"ms");
                    tfconsultni.appendText(re);
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            });
        }
    }
    
    
    展开全文
  • 分词是自然语言处理的一个...前向最大匹配算法后向最大匹配算法双向最大匹配算法三种方法思想都很简单,今天我们用python实现前向最大匹配算法。前向最大匹配算法,顾名思义,就是从待分词句子的左边向右边搜索,...

    分词是自然语言处理的一个基本工作,中文分词和英文不同,字词之间没有空格,可以将中文分词方法简单归纳为:基于词表的分词方法

    基于统计的分词方法

    基于序列标记的分词方法

    其中,基于词表的分词方法最为简单,根据起始匹配位置不同可以分为:前向最大匹配算法

    后向最大匹配算法

    双向最大匹配算法

    三种方法思想都很简单,今天我们用python实现前向最大匹配算法。

    前向最大匹配算法,顾名思义,就是从待分词句子的左边向右边搜索,寻找词的最大匹配。我们需要规定一个词的最大长度,每次扫描的时候寻找当前开始的这个长度的词来和字典中的词匹配,如果没有找到,就缩短长度继续寻找,直到找到字典中的词或者成为单字。

    下面是我的代码。word_dict = [             ]

    test_str = (text):

    text:

    (text) == :

    text

    text word_dict:

    text

    :

    small = (text) -         text = text[:small]

    getSeg(text)

    ():

    test_strword_dict

    test_str = test_str.strip()

    max_len = ((word) word word_dict)

    result_str = []      result_len =     (test_str)

    test_str:

    tmp_str = test_str[:max_len]

    seg_str = getSeg(tmp_str)

    seg_len = (seg_str)

    result_len = result_len + seg_len

    seg_str.strip():

    result_str.append(seg_str)

    test_str = test_str[seg_len:]

    (result_str)

    __name__ == :

    main()

    看一下分词的结果吧!

    3541465c8eedb428bc27f5f7b46d9c3f.png

    本文来自:机器在学习

    展开全文
  • python 双向最大匹配算法 双向最大匹配算法 双向最大匹配算法
  • 主要介绍了Java实现的双向匹配分词算法,结合完整实例形式详细分析了双向匹配分词算法的原理与java实现技巧,需要的朋友可以参考下
  • else: index += i if not sub.encode(encoding) == " ": result += sub.encode(encoding) + " " break return result.strip() ''' 逆向最大匹配算法 ''' def reverseMaximunMathching(sent): global dctDict global...
  • 下面我们看看基于词典的逆向最大匹配算法的实现,实验表明,对于汉语来说,逆向最大匹配算法比(正向)最大匹配算法更有效,如下代码所示:publicstaticListsegReverse(Stringtext){Stackresul...
  • 本次实验内容是基于词典的双向匹配算法的中文分词算法的实现。使用正向和反向最大匹配算法对给定句子进行分词,对得到的结果进行比较,从而决定正确的分词方法。算法描述正向最大匹配算法先设定扫描的窗口大小maxLen...
  • 本次实验内容是基于词典的双向匹配算法的中文分词算法的实现。使用正向和反向最大匹配算法对给定句子进行分词,对得到的结果进行比较,从而决定正确的分词方法。 算法描述 正向最大匹配算法 先设定扫描的窗口大小...
  • 基于词库的双向最大匹配算法 本文介绍了基于词库的双向最大匹配算法。该算法实现简单,分词效果依赖于词库。在词库相当的情况下,分词效果不错。某些情况下甚至强于基于隐马尔科夫模型的智能分词。 【双向最大...
  • java实现双向最大匹配算法

    千次阅读 2018-05-22 16:24:34
    结合正向最大匹配算法和反向最大匹配算法得出的双向最大匹配算法,第一部分是正向,第二部分是反向,然后相比较两种算法,得出最优答案 package Bi_MM; import java.io.BufferedReader; import java.io....
  • 算法是基于分词词典实现,从字符串左侧进行分割匹配,如果词典存在则返回分割出来的词语并将该词从之前的字符串中切除,循环进行切割直到字符串大小为0。
  • 往期回顾道路交通信息常用检测技术介绍——第三篇:射频检测器道路交通信息常用检测技术介绍——第二篇:环形线圈检测器道路交通信息常用检测技术介绍——第一篇:地磁检测...今天讲一种常用的自然语言处理算法——...
  • {"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,"count":4}]},"card":[{"des":"阿里技术人对外发布原创技术内容的最大平台;社区覆盖了云计算、大数据、人工智能、...
  • 龙源期刊网http://www.qikan.com.cn警务应用中基于双向最大匹配法的中文分词算法实现作者:陶伟来源:《电子技术与软件工程》2016年第04期摘要中文分词是信息提取、信息检索、机器翻译、文本分类、自动文摘、自然...
  • 双向最大匹配算法(Bi-directction Matching method)是将最大匹配法得到的分词结果和逆向最大匹配法得到的结果通过双向最大匹配算法的规则进行筛选而得到。 #-*- coding:utf-8 -*- ''' @project: exuding-nlp-all @...
  • 前向最大匹配def fmmseg(sen,max,strs):'''sen: 待切分句子max: 最大切分长度strs: 词典列表'''maxs=maxreturnlist=[]while len(sen)>0:while max>0:if(max==1):returnlist.append(sen[:1])sen=sen[1:]max=...
  • 最大匹配算法研究

    2020-10-18 18:00:03
    最大匹配算法是中文分词中最常用的方法,但其有着过分依赖于词典的弊端。对最大匹配算法进行了深入探讨与研究,使用n-gram...最后通过双向匹配算法与n-gram相结合的实验验证了该方案的可行性,并对该方案进行了总结。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 512
精华内容 204
关键字:

双向匹配算法