2. 程式人生 > >雙向最大匹配演算法——基於詞典規則的中文分詞(Java實現)

雙向最大匹配演算法——基於詞典規則的中文分詞(Java實現)

阿新 • • 發佈：2020-09-29

目錄

一、中文分詞理論描述

二、演算法描述

      1、正向最大匹配演算法

      2、反向最大匹配演算法

      3、雙劍合璧

三、案例描述

四、JAVA實現完整程式碼

五、組裝UI

六、總結

前言

這篇將使用Java實現基於規則的中文分詞演算法，一箇中文詞典將實現準確率高達85%的分詞結果。使用經典演算法：正向最大匹配和反向最大匹配演算法，然後雙劍合璧，雙向最大匹配。

一、中文分詞理論描述

根據相關資料，中文分詞概念的理論描述，我總結如下：

中文分詞是將一個漢字序列切分成一個一個單獨的詞，將連續的字序列按照一定的規範重新組合成詞序列的過程，把字與字連在一起的漢語句子分成若干個相互獨立、完整、正確的單詞，詞是最小的、能獨立活動的、有意義的語言成分。

中文分詞應用廣泛，是文字挖掘的基礎，在中文文字處理中意義重大，對於輸入的一段中文，成功的進行中文分詞，可以達到電腦自動識別語句含義的效果。目前，常用流行的以及分次效果好的工具庫包括：jieba、HanLP、LTP、FudanNLP等。

我們知道，呼叫工具方便容易，但是如果自己實現寫一個演算法實現，那不是更加有成就感^_^。

接下來將一步步介紹最容易理解，最簡單，效果還很不錯的中文分詞演算法，據說準確率能達到85%！！

二、演算法描述

1、正向最大匹配演算法

所謂正向，就是從文字串左邊正向掃描，取出子串與詞典進行匹配。

演算法我分為兩步來理解：

假設初始化取最大匹配長度為MaxLen，當前位置pos=0，處理結果result=””，每次取詞str，取詞長度len，待處理串segstr。

  1. len=MaxLen，取字串0到len的子串，查詢詞典，若匹配到則賦值str，加到result，在保證pos+len<=segstr.length()情況下，pos=pos+len,向後匹配，直到字串掃描完成，結束演算法。
  2. 若詞典未找到，若len>1,減小匹配長度同時len=MaxLen-1,執行步驟（1），否則，取出剩餘子串,執行步驟（1）。

演算法程式碼如下：

    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);//substring獲取的子串是下標frompos~frompos+llen-1
        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;
            } else {
                result = result + str + "/ ";
                frompos = frompos + 1;
                Len = MaxLen;
            }
            MM(str, Len, frompos);
        }
    }

從演算法程式碼看出，很容易理解，細節部分在於邊界處理。

測試一下，我輸入文字，"我愛自然語言處理，讚賞評論收藏我的文章是我的動力！趕緊關注！"

分詞結果：

2、反向最大匹配演算法

反向，則與正向相反，從文字串末向左進行掃描。

假設初始化取最大匹配長度為MaxLen，當前位置pos為字串尾部，處理結果result=””，每次取詞str，取詞長度len，待處理串segstr。

  1. len=MaxLen，取字串pos-len到pos的子串，查詢詞典，若匹配到則賦值str，加到result，同時pos=pos-len,保證pos-len>=0,向前移動匹配，直到字串掃描完成，結束演算法。
  2. 若詞典未找到，若len>1,減小匹配長度同時len=MaxLen-1,執行步驟（1），否則，取出剩餘子串,執行步驟（1）。

演算法邏輯類似，取相反方向處理。

public void RMM(String str, int len, int frompos) {
        if (frompos < 0)
            return;
        String curstr = "";
        //此處可以設定斷點
        if (frompos - len + 1 >= 0)//句末邊界處理
            curstr = str.substring(frompos - len + 1, frompos + 1);//substring獲取的子串是下標frompos~frompos+llen-1
        else
            curstr = str.substring(0, frompos + 1);//到達句首
 
        if (dict.containsKey(curstr)) {
            RmmResult = curstr + "/ " + RmmResult;
            Len = MaxLen;
            indexpos = frompos - len;
            RMM(str, Len, indexpos);
        } else {
            if (Len > 1) {
                Len = Len - 1;
            } else {
                RmmResult = RmmResult + str + "/ ";
                frompos = frompos - 1;
                Len = MaxLen;
            }
            RMM(str, Len, frompos);
        }
    }

同樣，細節部分在於邊界處理，其他基本相同。

3、雙劍合璧

這裡所說的是正向與反向結合，實現雙向最大匹配。

雙向最大匹配演算法，基於正向、反向最大匹配，對分詞結果進一步處理，比較兩個結果，做的工作就是遵循某些原則和經驗，篩選出兩者中更確切地分詞結果。原則如下：

  • 多數情況下，反向最大匹配效果更好，若分詞結果相同，則返回RMM結果；
  • 遵循切分最少詞原則，更大匹配詞為更好地分詞結果，比較之後返回最少詞的切分結果；
  • 根據切分後詞長度的大小，選擇詞長度大者為最終結果。

具體也需要看開始給定的最大匹配長度為多少。以下程式碼只實現了原則（1）、（2）。

    public String BMM() throws IOException {
        String Mr = MM_Seg();
        String RMr = RMM_Seg();
        if (Mr.equals(RMr)) {
            return "雙向匹配相同，結果為：" + Mr;
        } else {
            List<String> MStr;
            List<String> RStr;
            MStr = Arrays.asList(Mr.trim().split("/"));
            RStr = Arrays.asList(RMr.trim().split("/"));
 
            if (MStr.size() >= RStr.size()) {//多數情況下，反向匹配正確率更高
                return "雙向匹配不同，最佳結果為：" + RMr;
            } else
                return "雙向匹配不同，最佳結果為：" + Mr;
        }
    }

另外，這與使用的詞典大小有關，是否包含常用詞。

三、案例描述

如果上面還不能完全理解，下面的例子可以更好的理解演算法執行過程。

正向最大匹配演算法：

取MaxLen=3，SegStr=”對外經濟技術合作與交流不斷擴大”,maxNum=3,len=3,result=””,pos=0,curstr=””.

第一次，curstr=”對外經”，查詢詞典，未找到，將len-1，得到curstr=”對外”，此時匹配到詞典，將結果加入result=”對外/ ”.pos=pos+len.

第二次，curstr=”經濟技”，查詢詞典，未找到，將len-1，得到curstr=”經濟”，此時匹配到詞典，將結果加入result=”對外/ 經濟/ ”.pos=pos+len.

以此類推...

最後一次，邊界，pos=13，因為只剩下”擴大”兩個字，所以取出全部，查詢詞典並匹配到，將結果加入result=”對外/ 經濟/ 技術/ 合作/ 與/ 交流/ 不斷/ 擴大/ ”.此時pos+1>SegStr.length(),結束演算法。 

反向最大匹配演算法：

取MaxLen=3，SegStr=”對外經濟技術合作與交流不斷擴大”,maxNum=3,len=3,result=””,pos=14,curstr=””.

第一次，curstr=”斷擴大”，查詢詞典，未找到，將len-1，得到curstr=”擴大”，此時匹配到詞典，將結果加入result=”擴大/ ”.pos=pos-len.

第二次，MaxLen=3，curstr=”流不斷”，查詢詞典，未找到，將len-1，得到curstr=”不斷”，此時匹配到詞典，將結果加入result=”不斷/ 擴大/ ”.pos=pos-len.

以此類推...

最後一次，邊界，pos=1，因為只剩下”對外”兩個字，所以取出全部，查詢詞典並匹配到，將結果加入result=”對外/ 經濟/ 技術/ 合作/ 與/ 交流/ 不斷/ 擴大/ ”.此時pos-1<0,結束演算法。

四、JAVA實現完整程式碼

 除了分詞演算法實現，還需要讀入詞典，對詞典進行預處理，具體如下：

package ex1;
 
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
 
public class seg {
 
    String result;
    String RmmResult;
    String segstring;
    int MaxLen;
    int Len;
    int indexpos;
    Map<String, String> dict; 
 
    public seg(String inputstr, int maxlen) {//建構函式
        segstring = inputstr;
        MaxLen = maxlen;
        Len = MaxLen;
        indexpos = 0;
        result = "";
        RmmResult = "";
        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(",");//詞典包含詞性標註，需要將詞與標註分開，放入列表
            String word = words[0];
            String cx = words[1];
            dict.put(word, cx);
        }
        br.close();
    }
 
    public String MM_Seg() throws IOException {//正向最大匹配演算法
        try {
            ReadDic();//讀入字典
            MM(segstring, MaxLen, 0);//正向最大分詞
            return result;
        } catch (IOException e) {
            return "Read Error!";
        }
    }
 
    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);//substring獲取的子串是下標frompos~frompos+llen-1
        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;
            } else {
                result = result + str + "/ ";
                frompos = frompos + 1;
                Len = MaxLen;
            }
            MM(str, Len, frompos);
        }
    }
 
    public String RMM_Seg() throws IOException {//正向最大匹配演算法
        try {
            ReadDic();//讀入字典
            RMM(segstring, MaxLen, segstring.length() - 1);//正向最大分詞
            return RmmResult;
        } catch (IOException e) {
            return "Read Error!";
        }
    }
 
    public void RMM(String str, int len, int frompos) {
        if (frompos < 0)
            return;
        String curstr = "";
        //此處可以設定斷點
        if (frompos - len + 1 >= 0)//句末邊界處理
            curstr = str.substring(frompos - len + 1, frompos + 1);//substring獲取的子串是下標frompos~frompos+llen-1
        else
            curstr = str.substring(0, frompos + 1);//到達句首
 
        if (dict.containsKey(curstr)) {
            RmmResult = curstr + "/ " + RmmResult;
            Len = MaxLen;
            indexpos = frompos - len;
            RMM(str, Len, indexpos);
        } else {
            if (Len > 1) {
                Len = Len - 1;
            } else {
                RmmResult = RmmResult + str + "/ ";
                frompos = frompos - 1;
                Len = MaxLen;
            }
            RMM(str, Len, frompos);
        }
    }
 
    public String BMM() throws IOException {
        String Mr = MM_Seg();
        String RMr = RMM_Seg();
        if (Mr.equals(RMr)) {
            return "雙向匹配相同，結果為：" + Mr;
        } else {
            List<String> MStr;
            List<String> RStr;
            MStr = Arrays.asList(Mr.trim().split("/"));
            RStr = Arrays.asList(RMr.trim().split("/"));
 
            if (MStr.size() >= RStr.size()) {//多數情況下，反向匹配正確率更高
                return "雙向匹配不同，最佳結果為：" + RMr;
            } else
                return "雙向匹配不同，最佳結果為：" + Mr;
        }
    }
 
    public String getResult() {
        return result;
    }
 
    public static void main(String[] args) throws IOException, Exception {
        seg s = new seg("我愛自然語言處理，讚賞評論收藏我的文章是我的動力！趕緊關注！", 3);
//        String result = s.MM_Seg();
        String result = s.RMM_Seg();
        System.out.println(result);
 
    }
}
View Code

五、組裝UI

我是用的開發軟體為是IDEA，一個方便之處可以拖動元件組裝UI介面。也可以自行寫JavaFX實現簡單佈局。

這是簡單頁面的設計：

UI介面可以有更好的使用者體驗，通過UI介面的元素呼叫方法，減少每次測試執行演算法指令碼的繁瑣。

實驗演示：

每次可以觀察不同最大匹配長度分詞後的結果。

"年中"詞語解析：

在詞典中，是這樣的，可以發現滿足最大匹配。

雙向最大匹配演算法，結果提示：

六、總結

這篇介紹了使用Java實現基於規則的中文分詞演算法，使用經典演算法：正向最大匹配和反向最大匹配演算法，然後雙劍合璧，雙向最大匹配。最後設計簡單UI介面，實現稍微高效的中文分詞處理，結果返回。

  1. 雙向最大匹配演算法原則，希望句子最長詞保留完整、最短詞數量最少、單字詞問題，目前只解決了句子切分最少詞問題。
  2. 正向反向匹配演算法可以進一步優化結構，提高執行效率，目前平均耗時20ms。
  3. UI介面增加輸入輸出提示語，方便使用者使用，在正確的區域輸入內容。
  4. 將最大匹配長度設定為可輸入，實現每次可以觀察不同MaxLen得到的切分結果。

  5. 雙向最大匹配按鈕點選之後，返回結果同時返回MM和RMM結果是否一樣的提示，方便檢視。

我的部落格園：https://www.cnblogs.com/chenzhenhong/p/13748042.html

我的CSDN部落格： https://blog.csdn.net/Charzous/article/details/108817914

 

 

版權宣告：本文為博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處連結和本宣告。

 

本文連結：https://blog.csdn.net/Charzous/article/details/108817914

 

相關推薦

雙向最大匹配演算法——基於詞典規則的中文分詞(Java實現)

目錄 一、中文分詞理論描述 二、演算法描述       1、正向最大匹配演算法       2、反向最大匹配演算法       3、雙劍合璧 三、案例描述 四、JAVA實現完整程式碼 五、組

用最大熵模型進行字標註中文分詞（Python實現）

        同前面的那篇文章一樣（參見：最大熵模型進行中文分詞），本文運用字標註法進行中文分詞，分別使用4-tag和6-tag對語料進行字標註，觀察分詞效果。前面的文章中使用了模型工具包中自帶的一個樣例進行4-tag中文分詞，但由於其選取的特徵是針對英文詞性標註開發

基於詞典的正向最大匹配演算法（最長詞優先匹配）

public Set<String> matchChinese(String text, Set<String> dictionary, int maxLength) { //text：待匹配文字 dictiona：詞典

逆向最大匹配演算法之python實現

1.執行環境 python 3.6.4 2.思路 大致思路與正向相同，可參考我的上一篇部落格。 3.程式碼實現 import codecs #獲得分詞字典，儲存為字典形式 f1 = codecs.open('./corpus/WordList.txt', 'r', encodi

正向最大匹配演算法實現之python實現

1.python 版本：python 3.6.4 2.思路： s1.匯入分詞詞典，儲存為字典形式dic,匯入停用詞詞典stop_words，儲存為字典形式,需要分詞的文字檔案cutTest.txt,儲存為字串chars s2.遍歷分詞詞典，找出最長的詞，長度為max_chars s3

中文分詞實現——雙向最大匹配

關於中文分詞的一些基本介紹，可以看這篇部落格《中文分詞方法總結》。這裡就不再進行詳細介紹了。 雙向最大匹配方法 雙向最大匹配方法是一種基於詞典的分詞方法。基於詞典的分詞方法是按照一定策略將待分析的漢字串與一個“大機器詞典”中的詞條進行匹配，若在詞典中找到某個字串，則匹配成功

用正向和逆向最大匹配演算法進行中文分詞（續）

一、結果分析：         1.程式執行結果，如下圖所示：         2.總體分析。         （1）正向和逆向匹配都正確的句子數目為 1731，佔句子總數的39.0%         （2）正向最大匹配完全正確的句子數目為 1917，佔句子總數的43

中文分詞的逆向最大匹配演算法(2016年)

逆向最大匹配演算法，中文分詞機械化分詞中最基本的演算法，也是入門級別的演算法。但是，在機械化分詞方面的效果，表現卻很好。尤其是在大文字的時候，一次取較多詞語進行匹配，因為大文字匹配成詞的概率遠遠高於小文字，所以會有很好的表現。下面的程式碼，來自IK分詞的一部分原始碼包，201

分詞演算法:正向最大匹配演算法

正向最大匹配演算法 正向最大匹配演算法(FMM)是一種基於詞典的分詞方法，同樣的基於詞典的方法還有逆向最大匹配法(RMM)，ngram法.FMM故名思意，左向右掃描尋找詞的最大匹配，是一種貪心的思想。

中文分詞之正向最大匹配演算法

中文分詞目前可以分為“規則分詞”，“統計分詞”，“混合分詞（規則+統計）”這三個主要流派。這次介紹下基於規則的分詞，其是一種機械的分詞方法，主要通過維護詞典，在切分語句時，將語句的每個字串與詞表中的詞逐一進行匹配，找到則切分，否則不予切分。 正向最大匹配演算法

【演算法記事本#NLP-1】最大匹配演算法分詞

> **本文地址**： # \#NLP-1 最大匹配演算法（MM） **最大匹配演算法**（Maximum Matching）被用於對一個**文段**進行**詞語劃分**（Word Segmentation）。 > ## 注意 > 這是**詞元化（Tokenization）演算法** > 此方法*

基於python的中文分詞庫：jieba

簡介 分詞共分三種模式： 精確模式： 試圖將句子最精確的切開 全模式：掃描出句子中所有可能的詞語，速度快 搜尋引擎模式：在精確模式的基礎上，對長詞再次切分適合用於搜尋引擎分詞 例子： import jieba string = '結巴這個分詞工具真的特別的

學習筆記:從0開始學習大資料-29. solr增加ik中文分詞器並匯入doc，pdf文件全文檢索

環境 centos7,solr7.5.0 1. 新建core 從  solr-7.5.0/example/files/conf 作為配置檔案模板，建立core，名為mycore 2.下載分詞器 從https://search.maven.org/search?q=g:com

基於HMM的中文分詞

模型介紹 第一次聽說HMM模型是從李開復的博文論文中聽說的： 李開復1988年的博士論文發表了第一個基於隱馬爾科夫模型（HMM）的語音識別系統Sphinx，被《商業週刊》評為1988年美國最重要的科技發明。 出處請見KaifuLeeHMM 乍一聽似乎很玄

【Natural Language Processing】基於CRF++的中文分詞

一、任務簡介         中文分詞是中文資訊處理領域中的最重要的任務，它對於智慧資訊處理技術具有重要的意義,當前的各種漢語分詞技術都可以取得不錯的結果。 本任務做的是繁體中文分詞，將訓練語料的30%作為驗證集，70%作為訓練集，按通常的 P/R/F 三個指標進行評測，最

[Python] 基於 jieba 的中文分詞總結

[TOC] ## 模組安裝 ``` pip install jieba ``` jieba分詞器支援4種分詞模式: 1. 精確模式該模式會試圖將句子最精確地切分開，適合在文字分析時使用。 2. 全模式該模式會將句子中所有可以成詞的詞語都掃描出來，速度也非常快，缺點是不能解決歧義問題，有歧義的詞語也會被掃描出來

HDU2389：Rain on your Parade（二分圖最大匹配+HK演算法）

Rain on your Parade Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 655350/165535 K (Java/Others)Total Submission(s): 5755&nbs

二分圖最大匹配 匈牙利演算法的簡單理解

(本文圖片及被*標註內容來自CSDN部落格：pi9nc) 基本概念—二分圖 二分圖：是圖論中的一種特殊模型。若能將無向圖G=(V,E)的頂點V劃分為兩個交集為空的頂點集，並且任意邊的兩個端點都分屬於兩個集合，則稱圖G為一個為二分圖。 匹配：一個匹配即一個包含若干條邊的集合，且其中任

匈牙利演算法 最大匹配 模板

#include <bits/stdc++.h> using namespace std; const int MAXN = 1005; int n, m, e; int match[MA

二分圖最大匹配之Hopcroft-Karp演算法 詳解

Hopcroft-Karp演算法 原連結 該演算法由John.E.Hopcroft和Richard M.Karp於1973提出，故稱Hopcroft-Karp演算法。 原理 為了降低時間複雜度，可以在增廣匹配集合M時，每次尋找多條增廣路徑。這樣就可以進一步降低時間複雜度