精华内容
下载资源
问答
  • python 双向最大匹配算法 双向最大匹配算法 双向最大匹配算法
  • 分词是自然语言处理的一个...前向最大匹配算法后向最大匹配算法双向最大匹配算法三种方法思想都很简单,今天我们用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

    本文来自:机器在学习

    展开全文
  • 双向最大匹配算法(含完整代码实现,ui界面)正向最大匹配算法,逆向最大匹配算法 一、理论描述 中文分词(Chinese Word Segmentation) 指的是将一个汉字序列切分成一个一个单独的词。分词就是将连续的字序列按照一定...

    双向最大匹配算法(含完整代码实现,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();
                }
    
            });
        }
    }
    
    
    展开全文
  • 基于词库的双向最大匹配算法 本文介绍了基于词库的双向最大匹配算法。该算法实现简单,分词效果依赖于词库。在词库相当的情况下,分词效果不错。某些情况下甚至强于基于隐马尔科夫模型的智能分词。 【双向最大...

    基于词库的双向最大匹配算法

    本文介绍了基于词库的双向最大匹配算法。该算法实现简单,分词效果依赖于词库。在词库相当的情况下,分词效果不错。某些情况下甚至强于基于隐马尔科夫模型的智能分词。

     

          【双向最大匹配算法】从名字上来看(顾名思义),就是以最大匹配为原则、以双向的切分为方法进行汉子切分。本文所举得所有例子均是在词库足够完整的情况下进行的。

     

    什么叫以最大匹配为原则?

           最大匹配原则就是在词库中找到最长匹配字符串作为一个单词。如“我出生在中华人民共和国”,以最大匹配原则进行分词则分词结果为“我”、“出生”、“在”、“中华人民共和国”,而不是“我”、“出生”、“在”、“中华”、“人民”、“共和国”。

     

    什么是双向切分?

           要说双向切分算法就不得不说下正向切分算法以及逆向切分算法。

     

           先说正向切分算法。正向切分算法其实就是按照人得自然阅读顺序对一句话进行词库切分。即从前往后进行词匹配。如“中国的首都是北京”这句话,可以如下步骤进行切分:

           1:取出词库中以“中”开头的词;

           2:取出词库中以“中国”开头的词;

           3:取出词库中以“中国的”开头的词;

           4:第三步取词为空,所以分出词“中国”。

           5:对接下来的字符串重复1-5步骤,直到字符串扫描完毕。

     

           分词完毕之后结果为:“中国”、“的”、“首都”、“是”、“北京”。

           为简化理解难度我采用了”以**为开头的词“这样的说法,但是在代码中实现时这样的方式运算量较大,速度较慢,为提高取词效率,建议采用多叉树结构,进行词库的存储,下同。

     

           正向切分的缺点是什么?其实只要看对下面这句话的切分就知道了。

           “我出生在河北省会”

           按照正向切分且以最大匹配为原则进行切分,结果为:“我”、“出生”、“在”、“河北省”、“会”。这显然是不对的。其实在汉语中这样的例子有很多,如:“在野生动物园”(在野、生动、物、园)、“技术和服务”(技术、和服、务)等。所以有人提出了逆向切分算法。

     

           逆向切分算法在实现上来说完全就是正向切分算法那一套。只是词库是逆向词库,对于切分语句的切分顺序为从后往前切。还以“我出生在河北省会”为例,切分步骤如下:

           1:找出反向词库中以“会”为开头的词;

           2:找出反向词库以“会省”为开头的词;

           3:找出反向词库以“会省北”为开头的词;

           4:第三步取词为空,所以取词“会省”;

           5:对接下来的字符串重复1-5步骤,直到字符串扫描完毕。

     

           分完词之后的结果为“会省”、“北河”、“在”、“生出”、“我”。对结果以及词进行翻转,则结果为“我”、“出生”、“在”、“河北”、“省会”。

    可以看到逆向的分词结果较正向的分词结果更为准确。但是这个准确并非是分词算法上有了提高,仅仅是因为利用了汉语的习惯而已。既然使用了相同的算法,所以逆向切分的缺点跟正向的相同,如对“长春药店”就有可能分出“长”、“春药店”这样的词。

     

           因为正向切分以及逆向切分的缺点(其实就是一个缺点),人们提出了双向切分算法。双相切分算法就是使用正向切分一次、逆向切分一次。如果两次切分结果一样的话就好说了,随便选一个结果就可以。

    但是如果切分不一样的话使用那一次的切分结果呢?这就涉及到了结果的选取原则问题。老夫以为切分词应该遵守以下原则:

           1:最大匹配原则:上面一直在说这个,老夫认为使用这个原则的原因是词的字数越多,表示的含义越丰富、对于一条语句分出来的词也就越少,相对的,准确性也就会越高。

           2:词库中没有的单字词越少越好。这个原则有点依赖于词库了,至少词库中应该有一些常用的单字成词的字吧,比如:“你”、“我”、“他”、“和”、“的”、“了”等。使用这个原则的原因可以从上面提到的“技术和服务”这个例子看出来:

    正向结果:技术、和服、务

    逆向结果:技术、和、服务

           虽然分出来的结果单字词都是一个,但是,逆向的单字词”和“在词库中存在,所以我们选择返回逆向切分结果。

     

           虽然双向切分算法的分词准确度大大提高了,但是双向切分算法并不是一个智能算法,这是由算法的基因决定的。但是双向最大匹配算法确实可以解决大多数的中文分词问题(依赖于词库)。只要有一个差不多(实在不知道该怎么形容,只好使用差不多这个词了)的词库(这类的词库在网上很容易就能搞到手),使用如此简单的一个算法,却解决了一个如此复杂的问题,这本身也是一个非常美妙的事情。

     

           今就到这,关于智能分词算法,等忙过这段时间在整理吧。

    展开全文
  • java实现双向最大匹配算法

    千次阅读 2018-05-22 16:24:34
    结合正向最大匹配算法和反向最大匹配算法得出的双向最大匹配算法,第一部分是正向,第二部分是反向,然后相比较两种算法,得出最优答案 package Bi_MM; import java.io.BufferedReader; import java.io....

    结合正向最大匹配算法和反向最大匹配算法得出的双向最大匹配算法,第一部分是正向,第二部分是反向,然后相比较两种算法,得出最优答案

    package Bi_MM;
    
    import java.io.BufferedReader;  
    import java.io.FileInputStream;  
    import java.io.IOException;  
    import java.io.InputStreamReader;  
    import java.util.HashSet;  
    import java.util.Set;  
    import java.util.Vector;  
      
      
    public class Bimm {  
        private static Set<String> seg_dict;  
          
        //加载词典  
        public static void Init(){  
            seg_dict = new HashSet<String>();  
            String dicpath = "data/worddic";  
            String line = null;  
              
            BufferedReader br;  
            try{  
                br = new BufferedReader( new InputStreamReader( new FileInputStream(dicpath)));   
                while((line = br.readLine()) != null){  
                    line = line.trim();  
                    if(line.isEmpty())  
                        continue;     
                    seg_dict.add(line);  
                }  
                br.close();  
            }catch(IOException e){  
                e.printStackTrace();  
            }  
              
        }  
        /** 
         * 前向算法分词 
         * @param seg_dict 分词词典 
         * @param phrase 待分词句子 
         * @return 前向分词结果 
         */  
        private static Vector<String> FMM2( String  phrase){  
            int maxlen = 16;  
            Vector<String> fmm_list = new Vector<String>();  
            int len_phrase = phrase.length();  
            int i=0,j=0;  
              
            while(i < len_phrase){  
                int end = i+maxlen;  
                if(end >= len_phrase)  
                    end = len_phrase;  
                String phrase_sub = phrase.substring(i, end);  
                for(j = phrase_sub.length(); j >=0; j--){  
                    if(j == 1)  
                        break;  
                    String key =  phrase_sub.substring(0, j);  
                    if(seg_dict.contains(key)){  
                        fmm_list.add(key);  
                        i +=key.length() -1;  
                        break;  
                    }  
                }  
                if(j == 1)  
                    fmm_list.add(""+phrase_sub.charAt(0));  
                i+=1;  
            }  
            return fmm_list;  
        }  
          
        /** 
         * 后向算法分词 
         * @param seg_dict 分词词典 
         * @param phrase 待分词句子 
         * @return 后向分词结果 
         */  
        private static Vector<String> BMM2( String  phrase){  
            int maxlen = 16;  
            Vector<String> bmm_list = new Vector<String>();  
            int len_phrase = phrase.length();  
            int i=len_phrase,j=0;  
              
            while(i > 0){  
                int start = i - maxlen;  
                if(start < 0)  
                    start = 0;  
                String phrase_sub = phrase.substring(start, i);  
                for(j = 0; j < phrase_sub.length(); j++){  
                    if(j == phrase_sub.length()-1)  
                        break;  
                    String key =  phrase_sub.substring(j);  
                    if(seg_dict.contains(key)){  
                        bmm_list.insertElementAt(key, 0);  
                        i -=key.length() -1;  
                        break;  
                    }  
                }  
                if(j == phrase_sub.length() -1)  
                    bmm_list.insertElementAt(""+phrase_sub.charAt(j), 0);  
                i -= 1;  
            }  
            return bmm_list;  
        }  
              
        /** 
         * 该方法结合正向匹配和逆向匹配的结果,得到分词的最终结果 
         * @param FMM2 正向匹配的分词结果 
         * @param BMM2 逆向匹配的分词结果 
         * @param return 分词的最终结果 
         */  
        public static Vector<String> segment( String phrase){  
            Vector<String> fmm_list = FMM2(phrase);  
            Vector<String> bmm_list = BMM2(phrase);  
            //如果正反向分词结果词数不同,则取分词数量较少的那个  
            if(fmm_list.size() != bmm_list.size()){  
                if(fmm_list.size() > bmm_list.size())  
                    return bmm_list;  
                else return fmm_list;  
            }  
            //如果分词结果词数相同  
            else{  
                //如果正反向的分词结果相同,就说明没有歧义,可返回任意一个  
                int i ,FSingle = 0, BSingle = 0;  
                boolean isSame = true;  
                for(i = 0; i < fmm_list.size();  i++){  
                    if(!fmm_list.get(i).equals(bmm_list.get(i)))  
                        isSame = false;  
                    if(fmm_list.get(i).length() ==1)  
                        FSingle +=1;  
                    if(bmm_list.get(i).length() ==1)  
                        BSingle +=1;  
                }  
                if(isSame)  
                    return fmm_list;  
                else{  
                    //分词结果不同,返回其中单字较少的那个  
                    if(BSingle > FSingle)  
                        return fmm_list;  
                    else return bmm_list;  
                }  
            }  
        }  
        public static void main(String [] args){  
            String test = "举办大型群众性活动应当符合哪些条件?";  
            Bimm.Init();  
            System.out.println(Bimm.segment(test));  
        }  
    }
    
    

    (1)、如果您在阅读博客时遇到问题或者不理解的地方,可以联系我,互相交流、互相进步;
    (2)、本人业余时间可以承接毕业设计和各种小项目,如系统构建、成立网站、数据挖掘、机器学习、深度学习等。有需要的加QQ:1143948594,备注“csdn项目”。

    展开全文
  • /usr/bin/python#encoding=gbkimport sysdictMaxLength = 5dctDict = {}encoding='gbk''''初始化字典、初始化最大词长'''def initDct(dct):global dctDictglobal dictMaxLengthdctobj = open(dct)for line in dctobj...
  • 双向最大匹配算法(Bi-directction Matching method)是将最大匹配法得到的分词结果和逆向最大匹配法得到的结果通过双向最大匹配算法的规则进行筛选而得到。 #-*- coding:utf-8 -*- ''' @project: exuding-nlp-all @...
  • 下面我们看看基于词典的逆向最大匹配算法的实现,实验表明,对于汉语来说,逆向最大匹配算法比(正向)最大匹配算法更有效,如下代码所示:publicstaticListsegReverse(Stringtext){Stackresul...
  • 完成正向、逆向和双向最大匹配算法import java.io.*;import java.util.*;/*** 正向最大匹配* 逆向最大匹配* 双向最大匹配*/public class TwoMaxMatch {private static final int MAX_LENGTH = 5;public static void ...
  • 使用正向和反向最大匹配算法对给定句子进行分词,对得到的结果进行比较,从而决定正确的分词方法。算法描述正向最大匹配算法先设定扫描的窗口大小maxLen(最好是字典最长的单词长度),从左向右取待切分汉语句的maxLen...
  • 往期回顾道路交通信息常用检测技术介绍——第三篇:射频检测器道路交通信息常用检测技术介绍——第二篇:环形线圈检测器道路交通信息常用检测技术介绍——第一篇:地磁检测...今天讲一种常用的自然语言处理算法——...
  • 完成正向、逆向和双向最大匹配算法 import java.io.*; import java.util.*; /** * 正向最大匹配 * 逆向最大匹配 * 双向最大匹配 */ public class TwoMaxMatch { private static final int MAX_LENGTH = 5; ...
  • 双向最大匹配算法 """ #导入正向最大匹配算法和逆向最大匹配算法 import FMM import BMM #词典元素存储变量 dict_words = [] #初始化函数,载入词典 def init(): with open("dict/dict.txt","r",encoding="utf-8...
  • 使用python实现正向、逆向和双向最大匹配算法 正向最大匹配 class leftMax(object): def __init__(self,dict_path): self.dictionary = set() #定义字典 self.maximum = 0 #最大匹配长度 with open(dict_path,...
  • 龙源期刊网http://www.qikan.com.cn警务应用中基于双向最大匹配法的中文分词算法实现作者:陶伟来源:《电子技术与软件工程》2016年第04期摘要中文分词是信息提取、信息检索、机器翻译、文本分类、自动文摘、自然...
  • 前向最大匹配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=...
  • {"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,"count":4}]},"card":[{"des":"阿里技术人对外发布原创技术内容的最大平台;社区覆盖了云计算、大数据、人工智能、...
  • 这篇将使用Java实现基于规则的中文分词算法,一个中文词典将实现准确率高达85%的分词结果。使用经典算法:正向最大匹配和反向最大匹配算法,然后双剑合璧,双向最大匹配
  • 算法流程:假设词典中最长的单词为 5 个(MAX_LENGTH),那么最大匹配的起始子串字数也为 5 个(1)扫描字典,测试读入的子串是否在字典中(2)如果存在,则从输入中删除掉该子串,重新按照规则取子串,重复(1)(3)如果不...
  • 本文主要对词干提取及词形还原以及最大匹配算法进行了介绍和代码示例,Python实现,下面我们一起看看具体内容。自然语言处理中一个很重要的操作就是所谓的stemming和lemmatization,二者非常类似。它们是词形规范化...
  • 对于以下示例,下面的所有边可以是最大匹配:{1:2,2:1}或{1:3,3:1}或{1:4,4:1}import networkx as nximport matplotlib.pyplot as pltG = nx.MultiDiGraph()edges = [(1,3), (1,4), (1,2)]nx.is_bipartite(G...
  • 本篇介绍基于词典匹配的中文分词算法。1. 使用效果1.1 输入输入待分词的句子或文章,如:黑夜给了我黑色的眼睛,我却用它寻找光明。1.2 输出返回分词结果:黑夜/给/了/我/黑色/的/眼睛/,/我/却/用/它/寻找/光明/。2...
  • 最大匹配算法分为正向最大匹配算法和逆向最大匹配算法和双向最大匹配算法。 正向最大匹配算法 正向最大匹配算法,就是从左往右去扫描,然后寻找词的最大匹配。 首先需要规定一个词可能的最大长度,每次扫描的时候...
  • 使用经典算法:正向最大匹配和反向最大匹配算法,然后双剑合璧,双向最大匹配。一、中文分词理论描述根据相关资料,中文分词概念的理论描述,我总结如下:中文分词是将一个汉字序列切分成一个一个单独的词,将连续的...
  • 请你求出二分图的最大匹配数。二分图的匹配:给定一个二分图G,在G的一个子图M中,M的边集{E}中的任意两条边都不依附于同一个顶点,则称M是一个匹配。二分图的最大匹配:所有匹配中包含边数最多的一组匹配被称为二分...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 274
精华内容 109
关键字:

双向最大匹配算法