2. 程式人生 > >經典的分詞方法實現（JAVA)

經典的分詞方法實現（JAVA)

阿新 • • 發佈：2019-02-16

基於規則的自動分詞演算法

原理

(1) 事先人工建立好分詞詞典和分詞規則庫。
(2) 原理為基於字串匹配進行分詞,這樣就要求有足夠大的詞表為依據。
(3) 通過一定的演算法來實現,如正向最大匹配法、逆向最大匹配法、雙向匹配法等。
(4) 憂缺點:當分詞詞典所收容的詞較少時,顯然覆蓋度就有限,分詞的正確率就低。

正向最大匹配法

演算法描述

設MaxLen表示最大詞長,D為分詞詞典
(1) 從待切分語料中按正向取長度為MaxLen的字串str,令Len=MaxLen;
(2) 把str與D中的詞相匹配;
(3) 若匹配成功,則認為該字串為詞,指向待切分語料的指標向前移Len個漢字(位元組),返回到(1);
(4) 若不成功:如果Len>1,則將Len減2,從待切分語料中取長度為Len的字串str,返回到(2)。否則,得到長度為2的單字詞,指向待切分語料的指標向前移1個漢字,返回(1)。

演算法程式碼

/*
 * 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.
 */
package nlp;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import
 
 java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author quincy1994
 */
public class Nlp {

    private String m_sResult = ""; // 切分後的結果串
    private int m_nPosIndex;  // 指向待切分語料的指標的具體位置
    private int m_MaxLen; // 最大取詞長
 

    private int totalMaxLen; //總最大取詞長
    private Set<String> dictionary; // 分詞字典

    public Nlp(int maxLen){
        this.m_MaxLen = maxLen;
        this.m_nPosIndex = 0;
        this.totalMaxLen = maxLen;
        try {
            this.dictionary = this.loadFile();
        } catch (IOException ex) {
            Logger.getLogger(Nlp.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public Nlp(){
        this.m_MaxLen = 3;
        this.totalMaxLen = 3;
        this.m_nPosIndex = 0;
        try {
            this.dictionary = this.loadFile();
        } catch (IOException ex) {
            Logger.getLogger(Nlp.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public Set<String> loadFile() throws FileNotFoundException, IOException{
        //讀取字典
        Set<String> dictionary = new HashSet<String>();
        String filename = "dict.txt";
        BufferedReader br = new BufferedReader(new FileReader(filename));
        String tmp;
        while( ( tmp = br.readLine() )!=null){
            String[] token = tmp.split(",");
            String word = token[0];
            dictionary.add(word);
        }
        return dictionary;
    }
    public String MMSegment(String source){
         int len = totalMaxLen;
         int frompos = 0;
         MM(source, len, frompos);
         return m_sResult;
     }
    public String getSubString(String source, int m_nPosIndex, int len){
        int endIndex = m_nPosIndex + len;
        int length = source.length();

        //需要判斷是否超出句子邊界
        while(endIndex > length){
            endIndex -= 1;
        }
        String sub = source.substring(m_nPosIndex, endIndex);
        return sub;
    }
    public void MM(String source, int len , int frompos){

        //遞迴匹配
         if (m_nPosIndex >= source.length()) return;
        String sub = getSubString(source, m_nPosIndex,len);
        if(dictionary.contains(sub)){
            //匹配
            m_sResult += sub + "/ ";
            m_nPosIndex = m_nPosIndex + m_MaxLen;
            m_MaxLen = totalMaxLen;
            MM(source, m_MaxLen, m_nPosIndex);
        }
        else{
            //不匹配
            if(m_MaxLen > 1){
                m_MaxLen = m_MaxLen - 1;
                MM(source, m_MaxLen, m_nPosIndex);
            }
            else{
                m_sResult += sub+ "/ ";
                m_nPosIndex  += 1;
                m_MaxLen = totalMaxLen;
                MM(source, m_MaxLen, m_nPosIndex);
            }
    }
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Nlp nlp = new Nlp();
        String source = "今天天氣不錯！";
        String result = nlp.MMSegment(source);
        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.
 */
package nlp;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author quincy1994
 */
public class RMM {
    private String m_sResult = "";         //切分後的結果串
    private int m_nPosIndex;                //遊標指標
    private int m_MaxLen;                    //最大取詞長
    private int totalMaxlen;                //總最大取詞長
    private Set<String> dictionary;      //分詞字典

    public RMM(int maxLen){
        this.m_MaxLen = maxLen;
        this.totalMaxlen = maxLen;
        try {
            this.dictionary = loadFile();
        } catch (IOException ex) {
            Logger.getLogger(RMM.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public RMM(){
        this.m_MaxLen = 3;
        this.totalMaxlen = 3;
        try {
            this.dictionary = loadFile();
        } catch (IOException ex) {
            Logger.getLogger(RMM.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public Set<String> loadFile() throws IOException{

        //讀取字典
        Set<String> dictionary = new HashSet<String>();
        String filename = "dict.txt";
        BufferedReader br = new BufferedReader(new FileReader(filename));
        String tmp;
        while((tmp=br.readLine())!= null){
            String[] token = tmp.split(",");
            String word = token[0];
            dictionary.add(word);
        }
        return dictionary;
    }
    public String RMMSegment(String source){
        int len= totalMaxlen;
        this.m_nPosIndex = source.length();
        int frompos = this.m_nPosIndex;
        rmm(source, m_MaxLen, m_nPosIndex);

        //將結果按順序輸出
        String[] token = m_sResult.split("/");
        String result = "";
        for(int i = token.length-1; i > 0 ; i--){
            result += token[i] + "/ ";
        }
        return result;
    }
    public String getSubString(String source, int m_nPosIndex, int len){

        int startIndex = m_nPosIndex - len;
        //判斷越界條件
        while(startIndex < 0){
            startIndex += 1;
        }
        String sub = source.substring(startIndex, m_nPosIndex);
        return sub;
    }

    public void rmm(String source, int len, int frompos){
         if(m_nPosIndex < 0)  return;
         String sub = getSubString(source, m_nPosIndex, len);
         if(dictionary.contains(sub)){
             //匹配成功
             m_sResult += "/" + sub ;
             m_nPosIndex = m_nPosIndex - m_MaxLen;
             m_MaxLen = totalMaxlen;
             rmm(source, m_MaxLen, m_nPosIndex);
         }
         else{
             //不匹配
             if(m_MaxLen > 1){
                 m_MaxLen = m_MaxLen - 1;
                 rmm(source, m_MaxLen, m_nPosIndex);
             }
             else{
                 m_sResult += "/" + sub ;
                 m_nPosIndex -= 1;
                 m_MaxLen = totalMaxlen;
                 rmm(source, m_MaxLen, m_nPosIndex);
            }
        }
    }
    public static void main(String[] args) {
        // TODO code application logic here
        RMM myRMM = new RMM();
        String source = "記錄最佳前候選詞列表";
        String result = myRMM.RMMSegment(source);
        System.out.println(result);
    } 
}

基於統計的中文分詞演算法

基本思想

選擇概率最大的分詞路徑作為最優結果
利用動態規劃演算法來實現,即最優路徑中的第i個詞w i 的累計概率等於它的左相鄰詞w i-1 的累積概率乘以w i 自身的概率

具體演算法

(1)對一個待分詞的字串S,按照從左到右的順序取出全部候選詞w 1 ,w 2 ,…,w i ,w n ;
(2)計算每個候選詞的概率值P(w i ),記錄每個候選詞的全部左鄰詞;
(3)計算每個候選詞的累計概率,累計概率最大的候選詞為最佳左鄰詞;
如果當前詞w n 是字串的尾詞,且累計概率P’(w n )最大,則w n 是S的終點詞;
(4)從w n 開始,按照從右到左順序,依次將每個詞的最佳左鄰詞輸出,即S的分詞結果.

字典樹

又稱單詞查詢樹，Trie樹，是一種樹形結構，是一種雜湊樹的變種。典型應用是用於統計，排序和儲存大量的字串（但不僅限於字串），所以經常被搜尋引擎系統用於文字詞頻統計。它的優點是：利用字串的公共字首來減少查詢時間，最大限度地減少無謂的字串比較，查詢效率比雜湊樹高。

字典樹的程式碼實現

/*
 * 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.
 */
package nlp;

import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author quincy1994
 */
public class TireNode {
    private String character;           //　單個漢字
    private int frequency = -1;       //     詞頻, -1來區別某條路徑上的字串是否是一個片語
    private double antilog = -1;    //      對數化的詞頻
    private Map<String, TireNode> children;  //下一個節點

    public String getCharacter(){
        return character;
    }

    public void setCharacter(String character){
        this.character = character;
    }

    public int getFrequency(){
        return frequency;
    }

    public void setFrequency(int frequency){
        this.frequency = frequency;
    }

    public double getAntilog(){
        return antilog;
    }

    public void setAntilog(double antilog){
        this.antilog = antilog;
    }

    public void addChild(TireNode node){
        if (children == null){
            children = new HashMap<String, TireNode>();
        }
        if (!children.containsKey(node.getCharacter())){
            children.put(node.getCharacter(), node);
        }
    }

    public TireNode getChild(String ch){
        if (children == null || ! children.containsKey(ch)){
            return null;
        }
        return children.get(ch);
    }

    public void removeChildren(String ch){
        if (children == null || !children.containsKey(ch)){
            return;
        }
        children.remove(ch);
    }
}

演算法實現

/*
 * 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.
 */
package nlp;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author quincy1994
 */
public class ChnSeq {

    private TireNode tire = null;

    public List<String> loadFile() throws FileNotFoundException, IOException {
        //讀取字典
        List<String> lines = new ArrayList<String>();
        String filename = "wordFre.txt";
        BufferedReader br = new BufferedReader(new FileReader(filename));
        String tmp;
        while ((tmp = br.readLine()) != null) {
            lines.add(tmp);
        }
        br.close();
        return lines;
    }

    public void init() throws IOException {
        List<String> lines = loadFile();
        tire = new TireNode();

        for (String line : lines) {
            String[] tokens = line.split(",");
            String word = tokens[0];
            int freq = Integer.parseInt(tokens[1]);
            double antilog =  Math.log(1+0.01/Double.parseDouble(tokens[2].replace("%", ""))) ;
            //構建詞典樹
            TireNode root = tire;
            for (int i = 0; i < word.length(); i++) {
                String c = "" + word.charAt(i);
                TireNode node = root.getChild(c);
                if (node == null) {
                    node = new TireNode();
                    node.setCharacter(c);
                    root.addChild(node);
                }
                root = node;
            }
            root.setFrequency(freq);    //為每個詞設立詞頻
            root.setAntilog(antilog);   //為每個詞設立逆文件頻率
        }

    }

    public TireNode getTire() {
        return tire;
    }

    public TireNode getNodeByWord(String word) {
        TireNode node = tire;
        for (int i = 0; i < word.length(); i++) {
            String ch = word.charAt(i) + "";
            if (node == null) {
                break;
            } else {
                node = node.getChild(ch);
            }
        }
        return node;
    }

    private class Segment {

        public String word;     //詞
        public String endChar; //結束詞
        public String lastChar; //字首詞
        public double cost;

        public final static String START_SIGN = "<< STARTING >>";
        public final static String END_SIGN = "<< ENDING >>";
    }

    //尋找候選詞
    public List<Segment> preSegment(String sentence) {
        List<Segment> segs = new ArrayList<Segment>();

        //設定句子的開始標誌
        Segment terminal = new Segment();
        terminal.word = Segment.START_SIGN;
        terminal.endChar = Segment.START_SIGN;
        terminal.lastChar = null;
        segs.add(terminal);

        for (int i = 0; i < sentence.length(); i++) {
            for (int j = i + 1; j <= sentence.length(); j++) {
                String word = sentence.substring(i, j);
                TireNode tnode = this.getNodeByWord(word);
                if (tnode == null) {
                    break;
                }
                if (tnode.getFrequency() <= 0) {
                    continue;
                }

                Segment seg = new Segment();
                seg.word = word;
                seg.endChar = word.substring(word.length() - 1, word.length());
                if (i == 0) {
                    seg.lastChar = Segment.START_SIGN;
                } else {
                    seg.lastChar = sentence.substring(i - 1, i);
                }
                seg.cost = tnode.getAntilog();
                System.out.println(word + " " + seg.cost +" " + tnode.getFrequency());
                segs.add(seg);
            }
        }

        //設定句子的結束標誌
        terminal = new Segment();
        terminal.word = Segment.END_SIGN;
        terminal.endChar = Segment.END_SIGN;
        terminal.lastChar = sentence.substring(sentence.length() - 1, sentence.length());
        segs.add(terminal);

        return segs;
    }

    public String dynamicSegment(List<Segment> segs) {

        //基於動態規劃的概率統計分詞
        final double INFINITE = 9999999;

        if (segs == null || segs.size() == 0) {
            System.out.println("找不到候選詞");
            return null;
        }

        int n = segs.size();    //候選詞的個數

        //單個詞
        double[][] costs = new double[n][n];
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n; j++) {
                String endChar = segs.get(i).endChar;
                if (j == i && endChar.equals(segs.get(j).word)) {
                    costs[i][j] = segs.get(j).cost;    //候選詞j的概率
                    continue;
                }
                costs[i][j] = INFINITE;
            }
        }

        //尋找前一個候選詞
        for (int i = 0; i < n - 1; i++) {
            String endChar = segs.get(i).endChar;
            for (int j = i + 1; j < n; j++) {
                String lastChar = segs.get(j).lastChar;
                if (lastChar != null && lastChar.equals(endChar) &&( j- i < 4)) {       //ｊ字首詞不為空，同時ｊ的字首詞等於ｉ的字尾詞,且j和i之間的間隔不超過4個候選詞
                    costs[i][j] = segs.get(j).cost;    //候選詞j的概率
                }
            }
        }

        int sp = 0;   //開始點
        int fp = n - 1;    //結束點

        double[] dist = new double[n];         // 記錄累計概率, n為候選詞的個數
        List<List<Integer>> sPaths = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            dist[i] = costs[sp][i];    //ｉ的累計概率的初始值為索引sp到索引ｉ的詞的概率
            if (sp != i) {
                list.add(i);   //記錄候選詞的索引位置
            }
            if (dist[i] < INFINITE) {
                List<Integer> spa = new ArrayList<Integer>();     //如果索引sp到索引ｉ構成一個詞，則開啟一條劃分路徑
                sPaths.add(spa);
            } else {
                sPaths.add(null);
            }
        }
        while (!list.isEmpty()) {

            //選切分點
            Integer minIdx = list.get(0);
            list.remove(minIdx);

            //判斷minIdx是否為開頭的候選詞
            if(dist[minIdx] == INFINITE){
                continue;
            }

            //動態規劃
            for (int i = minIdx+1; i < n; i++) {
                if (dist[i] > dist[minIdx] + costs[minIdx][i]) {
                    dist[i] = dist[minIdx] + costs[minIdx][i];
                    List<Integer> tmp = new ArrayList<Integer>(sPaths.get(minIdx));
                    tmp.add(minIdx);
                    sPaths.set(i, tmp);  //記錄最佳前候選詞列表
                }
            }
        }
        String result = "";
        for (int i = 0; i < sPaths.get(fp).size(); i++) {
            result += segs.get(sPaths.get(fp).get(i)).word + "/ ";
        }
        return result;
    }

    public String segment(String sentences) {
        return dynamicSegment(preSegment(sentences));
    }

    public static void main(String[] args) throws ClassNotFoundException, IOException {
        ChnSeq cs = new ChnSeq();
        cs.init();
        String sentence = "在這一年中，改革開放和現代化建設繼續向前邁進。經濟保持了“高增長、低通脹”的良好發展態勢。農業生產再次獲得好的收成，企業改革繼續深化，人民生活進一步改善。對外經濟技術合作與交流不斷擴大。";
        String segs = cs.segment(sentence);
        System.out.println(segs);
    }
}

相關推薦

經典的分詞方法實現（JAVA)

基於規則的自動分詞演算法 原理 (1) 事先人工建立好分詞詞典和分詞規則庫。 (2) 原理為基於字串匹配進行分詞,這樣就要求有足夠大的詞表為依據。 (3) 通過一定的演算法來實現,如正向最大匹配法、逆向最大匹配法、雙向匹配法等。 (4) 憂缺點:當分詞

jieba分詞/jieba-analysis（java版）

日本 word amp b- exception 鏈接 arp not unit 簡介 支持分詞模式Search模式，用於對用戶查詢詞分詞Index模式，用於對索引文檔分詞特性支持多種分詞模式全角統一轉成半角用戶詞典功能conf 目錄有整理的搜狗細胞詞庫因為性能原因，最新的

Java中的native方法實現（Java混用C/C++）

前言 native關鍵字說明其修飾的方法是一個原生態方法，方法對應的實現不是在當前檔案，而是在用其他語言（如C和C++）實現的檔案中。Java語言本身不能對作業系統底層進行訪問和操作，但是可以通過JNI介面呼叫其他語言來實現對底層的訪問。 JNI是Java本

jieba分詞的應用（java）

在上一篇說的猜你喜歡功能中，又加了新的需求，需要對關鍵詞進行分詞，擴大推薦文章的範圍，這樣能夠拓展使用者的喜歡範圍，這時候我就想到可以用jieba分詞對中文進行分詞，同樣的需要去官網下載原始碼，這樣方便自己對原始碼的修改以達到自己的目的。這裡，我需要判斷切分出來

java分頁的實現（後臺工具類和前臺jsp頁面）

cal else static pre cti per servle reac tint 1、首先，新建一個類Page.java 1 public class Page implements Serializable { 2 private static fi

SSM框架下分頁的實現（封裝page.java和List<?>）

添加 interface jsp頁面 har show 初始化 ring array dex 之前寫過一篇博客 java分頁的實現（後臺工具類和前臺jsp頁面），介紹了分頁的原理。 今天整合了Spring和SpringMVC和MyBatis，做了增刪改查和分頁，之前的邏輯

Lucene筆記20-Lucene的分詞-實現自定義同義詞分詞器-實現分詞器（良好設計方案）

一、目前存在的問題 在getSameWords()方法中，我們使用map臨時存放了兩個鍵值對用來測試，實際開發中，往往需要很多的這種鍵值對來處理，比如從某個同義詞詞典裡面獲取值之類的，所以說，我們需要一個類，根據key提供近義詞。 為了能更好的適應應用場景，我們先定義一個介面，其中定義一

淺談分詞演算法（4）基於字的分詞方法（CRF）

目錄 前言 目錄 條件隨機場（conditional random field CRF） 核心點 線性鏈條件隨機場 簡化形式 CRF分詞 CRF VS HMM 程式碼實現 訓練程式碼 實驗結果 參考文獻

python自然語言處理（NLP）1------中文分詞1，基於規則的中文分詞方法

python中文分詞方法之基於規則的中文分詞 目錄 常見中文分詞方法 推薦中文分詞工具 參考連結 一、四種常見的中文分詞方法： 基於規則的中文分詞 基於統計的中文分詞 深度學習中文分詞 混合分詞方法 基於規則的中

SSM框架下分頁的實現（封裝page.java和List）

1 <%@page import="com.bwlu.common.Page"%> 2 <%@ page language="java" contentType="text/html; charset=UTF-8" 3 pageEncoding="UTF-8"%>

【原創】中文分詞系統 ICTCLAS2015 的JAVA封裝和多執行緒執行（附程式碼）

　　本文針對的問題是 ICTCLAS2015 的多執行緒分詞，為了實現多執行緒做了簡單的JAVA封裝。如果有需要可以自行進一步封裝其它介面。 　　首先ICTCLAS2015的傳送門（http://ictclas.nlpir.org/），其對中文分詞做的比較透徹，而且有一定的可調式性。但是應用到實際開發中的話

經典演算法總結——揹包問題（java實現）【已完結】

問題描述： 一個揹包的總容量為V,現在有N類物品,第i類物品的重量為weight[i],價值為value[i] 那麼往該揹包裡裝東西,怎樣裝才能使得最終包內物品的總價值最大。這裡裝物品主要由三種裝法： 1、0-1揹包：每類物品最多隻能裝一次 2、多重揹包

django 分頁效果實現（djangorestframework內建以及django內建方法）

restframework的分頁需要再setting 中新增一個 REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': (

自然語言處理基礎（1）--基本分詞方法

         基本的分詞方法包括最大匹配法、最大概率法（最短加權路徑法）、最少分詞法、基於HMM的分詞法、基於互現資訊的分詞方法、基於字元標註的方法和基於例項的漢語分詞方法等。       1.最大匹配法         最大匹配法需要一個詞表，分詞的過程中用文字的候選

中文分詞系統NLPIR（2015版）的Java介面使用學習

前言：         這幾天資料探勘的大作業又用到分詞了，首先想到的肯定是中科院的分詞系統NLPIR，但是之前用的事2013版的，2015版的有了新的變化。增加了函式和效率自是不必說，由於我是用的j

springboot+redis實現熱詞搜尋推薦（Java）

import cc.datebook.common.JsonResult; import cc.datebook.entity.BookInfo; import cc.datebook.enums.ResultCode; import cc.datebo

資料庫分詞查詢的優缺點以及英文和中文各自的分詞方法（一）

1.為什麼需要資料庫分詞查詢  假設有一個數據庫表，表中有一個title欄位 table1 假如有300萬的資料 id為主鍵，title也設定了索引 id title 1 這是計算機，

工廠方法模式（Java與Kotlin版）

http www pattern static 難度 microsoft 運行時 sta 父類 前文推送 設計模式 簡單工廠模式（Java與Kotlin版） Kotlin基礎知識 Kotlin入門第一課：從對比Java開始 Kotlin入門第二課：集合

棧的數組和鏈表實現（Java實現）

javascrip search 分享圖片 sys blog inter () 結果 length 我以前用JavaScript寫過棧和隊列，這裏初學Java，於是想來實現棧，基於數組和鏈表。 下面上代碼： 1 import java.io.*; 2 //用接口來

淺談分詞算法（1）分詞中的基本問題

最短 hub 好的 說明 可能 漢語 等等 http ring [TOC] 前言 分詞或說切詞是自然語言處理中一個經典且基礎的問題，在平時的工作中也反復的接觸到分詞問題，用到了不同的模型，不同的方法應用在各個領域中，所以想對分詞問題做一個系統的梳理。大多數分詞問題主要是針對