2. 程式人生 > >轉：從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器

轉：從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器

阿新 • • 發佈：2018-01-13
lan reverse single trim 地址 note str rip resources

http://blog.csdn.net/guixunlong/article/details/8925990

從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器之一 - 資源篇

首先感謝52nlp的系列博文（http://www.52nlp.cn/），提供了自然語言處理的系列學習文章，讓我學習到了如何實現一個基於隱含馬爾可夫模型HMM的中文分詞器。

在編寫一個中文分詞器前，第一步是需要找到一些基礎的詞典庫等資源，用以訓練模型參數，並進行後續的結果評測，這裏直接轉述52nlp介紹的“中文分詞入門之資源”：

原文地址：http://www.52nlp.cn/%E4%B8%AD%E6%96%87%E5%88%86%E8%AF%8D%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%84%E6%BA%90

這裏我從http://sighan.cs.uchicago.edu/bakeoff2005/下載icwb2-data.zip詞庫做模型訓練與後續評測使用。

作為中文信息處理的“橋頭堡”，中文分詞在國內的關註度似乎遠遠超過了自然語言處理的其他研究領域。在中文分詞中，資源的重要性又不言而喻，最大匹配法等需要一個好的詞表，而基於字標註的中文分詞方法又需要人工加工好的分詞語料庫。所以想研究中文分詞，第一步需要解決的就是資源問題，這裏曾經介紹過“LDC上免費的中文信息處理資源”，其中包括一個有頻率統計的詞表，共計44405條，就可以作為一個不錯的中文分詞詞表使用。而一個好的人工分詞語料庫，需要很大的人力物力投入，所以無論研究還是商用往往需要一定的費用購買，好在SIGHAN Bakeoff為我們提供了一個非商業使用（non-commercial）的免費獲取途徑，以下將介紹SIGHAN Bakeoff及相關的中文分詞入門資源。
　　SIGHAN是國際計算語言學會（ACL）中文語言處理小組的簡稱，其英文全稱為“Special Interest Group for Chinese Language Processing of the Association for Computational Linguistics”，又可以理解為“SIG漢“或“SIG漢“。而Bakeoff則是SIGHAN所主辦的國際中文語言處理競賽，第一屆於2003年在日本劄幌舉行（Bakeoff 2003),第二屆於2005年在韓國濟州島舉行(Bakeoff 2005), 而2006年在悉尼舉行的第三屆（Bakeoff 2006）則在前兩屆的基礎上加入了中文命名實體識別評測。目前SIGHAN Bakeoff已成功舉辦了6屆，其中Bakeoff 2005的數據和結果在其主頁上是完全免費和公開的，但是請註意使用的前提是非商業使用（non-commercial）:

　　The data and results for the 2nd International Chinese Word Segmentation Bakeoff are now available for non-commercial use.

　　在Bakeoff 2005的主頁上，我們可以找到如下一行：“The complete training, testing, and gold-standard data sets, as well as the scoring script, are available for research use”，在這一行下面提供了三個版本的icwb2-data。下載解壓後，通過README就可以很清楚的了解到它包含哪些中文分詞資源，特別需要說明的是這些中文分詞語料庫分別由臺灣中央研究院（Academia Sinica）、香港城市大學（City University of Hong Kong）、北京大學(Peking University)及微軟亞洲研究院（Microsoft Research）提供，其中前二者是繁體中文，後二者是簡體中文,以下按照README簡要介紹icwb2-data:

1) 介紹（Introduction）：
　　本目錄包含了訓練集、測試集及測試集的（黃金）標準切分，同時也包括了一個用於評分的腳本和一個可以作為基線測試的簡單中文分詞器。(This directory contains the training, test, and gold-standard data used in the 2nd International Chinese Word Segmentation Bakeoff. Also included is the script used to score the results submitted by the bakeoff participants and the simple segmenter used to generate the baseline and topline data.)

2) 文件列表（File List）
　　在gold目錄裏包含了測試集標準切分及從訓練集中抽取的詞表（Contains the gold standard segmentation of the test data along with the training data word lists.）
　　在scripts目錄裏包含了評分腳本和簡單中文分詞器（Contains the scoring script and simple segmenter.）
　　在testing目錄裏包含了未切分的測試數據（Contains the unsegmented test data.）
　　在training目錄裏包含了已經切分好的標準訓練數據（Contains the segmented training data.）
　　在doc目錄裏包括了bakeoff的一些指南（Contains the instructions used in the bakeoff.）

3) 編碼（Encoding Issues）
　　文件包括擴展名”.utf8”則其編碼為UTF-8(Files with the extension “.utf8″ are encoded in UTF-8 Unicode.)
　　文件包括擴展名”.txt”則其編碼分別為（Files with the extension “.txt” are encoded as follows）:
　　前綴為as_，代表的是臺灣中央研究院提供，編碼為Big Five (CP950)；
　　前綴為hk_，代表的是香港城市大學提供，編碼為Big Five/HKSCS；
　　前綴為msr_，代表的是微軟亞洲研究院提供，編碼為 EUC-CN (CP936)；
　　前綴為pku_，代表的北京大學提供，編碼為EUC-CN (CP936)；
　　EUC-CN即是GB2312（EUC-CN is often called “GB” or “GB2312″ encoding, though technically GB2312 is a character set, not a character encoding.）

4） 評分（Scoring）
　　評分腳本“score”是用來比較兩個分詞文件的，需要三個參數（The script ‘score’ is used to generate compare two segmentations. The script takes three arguments)：
　　1. 訓練集詞表（The training set word list）
　　2. “黃金”標準分詞文件（The gold standard segmentation）
　　3. 測試集的切分文件（The segmented test file）
　
　　以下利用其自帶的中文分詞工具進行說明。在scripts目錄裏包含一個基於最大匹配法的中文分詞器mwseg.pl，以北京大學提供的人民日報語料庫為例，用法如下：
　　./mwseg.pl ../gold/pku_training_words.txt < ../testing/pku_test.txt > pku_test_seg.txt
　　其中第一個參數需提供一個詞表文件pku_training_word.txt，輸入為pku_test.txt，輸出為pku_test_seg.txt。
　　利用score評分的命令如下：
　　./score ../gold/pku_training_words.txt ../gold/pku_test_gold.txt pku_test_seg.txt > score.txt
　　其中前三個參數已介紹，而score.txt則包含了詳細的評分結果，不僅有總的評分結果，還包括每一句的對比結果。這裏只看最後的總評結果：

…
= SUMMARY:
=== TOTAL INSERTIONS: 9274
=== TOTAL DELETIONS: 1365
=== TOTAL SUBSTITUTIONS: 8377
=== TOTAL NCHANGE: 19016
=== TOTAL TRUE WORD COUNT: 104372
=== TOTAL TEST WORD COUNT: 112281
=== TOTAL TRUE WORDS RECALL: 0.907
=== TOTAL TEST WORDS PRECISION: 0.843
=== F MEASURE: 0.874
=== OOV Rate: 0.058
=== OOV Recall Rate: 0.069
=== IV Recall Rate: 0.958
### pku_test_seg.txt 9274 1365 8377 19016 104372 112281 0.907 0.843 0.874 0.058 0.069 0.958

　　說明這個中文分詞器在北大提供的語料庫上的測試結果是：召回率為90.7%，準確率為84.3%，F值為87.4%等。
　　SIGHAN Bakeoff公開資源的一個重要意義在於這裏提供了一個完全公平的平臺，任何人都可以拿自己研究的中文分詞工具進行測評，並且可以和其公布的比賽結果對比，是驢子是馬也就一目了然了。

下面是我自己實現的中文分詞器在msra的測試集上的分詞效果：

[plain] view plain copy
  1. === SUMMARY:
  2. === TOTAL INSERTIONS: 7303
  3. === TOTAL DELETIONS: 4988
  4. === TOTAL SUBSTITUTIONS: 15988
  5. === TOTAL NCHANGE: 28279
  6. === TOTAL TRUE WORD COUNT: 106873
  7. === TOTAL TEST WORD COUNT: 109188
  8. === TOTAL TRUE WORDS RECALL: 0.804
  9. === TOTAL TEST WORDS PRECISION: 0.787
  10. === F MEASURE: 0.795
  11. === OOV Rate: 0.026
  12. === OOV Recall Rate: 0.402
  13. === IV Recall Rate: 0.815
  14. ### msr_test_result.txt 7303 4988 15988 28279 106873 109188 0.804 0.787 0.795 0.026 0.402 0.815

分詞效果如下，個人感覺對於一個花三小時實現的程序來說，效果還不錯 技術分享圖片

[plain] view plain copy
    1. 而/大量/“/看/圖學/計算機/”/教材/的/出現/，/和/蔡誌忠/的/漫畫/諸子/相映/成趣/，/掀起/了/一股/成人/“/看/圖識/字/”/的/出版潮/，/到/後/來竟/說/不清/是/誰/影響/了/誰/。/
    2. words.length=38 timecost:0
    3. 在/日常/生活/中/，/像/“/軟件/”/、/“/硬件/”/、/“/死/循環/”/一類/的/新詞/充實/了/我們/的/語言庫/。/
    4. words.length=74 timecost:0
    5. 而/計算/機造/詞/功能/的/運用/，/形成/了/一種/被/稱為/“/語詞/傳染/”/的/新/現象/：/如果/有人/在/電腦/裏/造出/了/一個/錯誤/的/詞/，/所有/使用/該/電腦/的/人/都/會出/現同/一/錯誤/，/而且/防不/勝防/。/
    6. words.length=35 timecost:0
    7. 至於/計算機/的/使用/對/學生/書法/、/筆順/、/發音/的/影響/，/更/是/教育/學家/關心/的/話題/。/
    8. words.length=56 timecost:0
    9. 再往/遠些/看/，/隨著/漢字識別/和/語音識別技術/的/發展/，/中文/計算/機用/戶/將/跨越/語言/差異/的/鴻溝/，/在/錄入/上/走向/中西/文求/同/的/道路/。/
    10. words.length=35 timecost:0
    11. 而/計算機/翻譯/系統/與/現代/漢語/分析/相輔/相成/，/正/推動/著/人工/智能/科學/的/前進/…/…/
    12. words.length=68 timecost:0
    13. 每/跨過/一道/障礙/，/人們/都會/發現/一片/新/的/開闊/地/，/每/經過/一次/劇烈/的/碰撞/，/都/將/激起/一團/耀眼/的/火花/，/這/就/是/嶄新/的/計算機/技術/和/古老/的/中華/文化/的/對話/。/

分詞效果如下，個人感覺對於一個花三小時實現的程序來說，效果還不錯 技術分享圖片

http://blog.csdn.net/guixunlong/article/details/8926167

從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器之二 - 模型訓練與使用

我們使用/icwb2-data.rar/training/msr_training.utf8 用以訓練模型，這個詞庫裏包含已分詞匯約2000000個。

使用經典的字符標註模型，首先需要確定標註集，在前面的介紹中，我們使用的是{B,E}的二元集合，研究表明基於四類標簽的字符標註模型明顯優於兩類標簽，原因是兩類標簽過於簡單而損失了部分信息。四類標簽的集合是 {B,E,M,S}，其含義如下：
B：一個詞的開始
E：一個詞的結束
M：一個詞的中間
S：單字成詞
舉例：你S現B在E應B該E去S幼B兒M園E了S

用四類標簽為msr_training.utf8做好標記後，就可以開始用統計的方法構建一個HMM。我們打算構建一個2-gram(bigram)語言模型，也即一個1階HMM，每個字符的標簽分類只受前一個字符分類的影響。現在，我們需要求得HMM的狀態轉移矩陣 A 以及混合矩陣 B。其中：
Aij = P(Cj|Ci) = P(Ci,Cj) / P(Ci) = Count(Ci,Cj) / Count(Ci)
Bij = P(Oj|Ci) = P(Oj,Ci) / P(Ci) = Count(Oj,Ci) / Count(Ci)
公式中C = {B,E,M,S}，O = {字符集合}，Count代表頻率。在計算Bij時，由於數據的稀疏性，很多字符未出現在訓練集中，這導致概率為0的結果出現在B中，為了修補這個問題，我們采用加1的數據平滑技術，即：
Bij = P(Oj|Ci) = (Count(Oj,Ci) + 1)/ Count(Ci)
這並不是一種最好的處理技術，因為這有可能低估或高估真實概率，更加科學的方法是使用復雜一點的Good—Turing技術，這項技術的的原始版本是圖靈當年和他的助手Good在破解德國密碼機時發明的。

我完成的分詞器暫時沒有用這個技術，只是簡單的為沒出現的詞賦一個很小的值來實現簡單的情況模擬，後續會嘗試使用Good-Turing技術，試下效果怎麽樣。

求得的PI跟矩陣A如下：

[java] view plain copy
  1. private static double[] PI = new double[] {0.529918835192331, 0.0, 0.0, 0.470081164807669}; //B, M, E, S
  2. private static double[][] A = new double[][] {
  3. {0.0, 0.17142595344427136, 0.8285740465557286, 0.0}, //B
  4. {0.0, 0.49616531193870117, 0.5038346880612988, 0.0}, //M
  5. {0.4741680643477776, 0.0, 0.0, 0.5258319356522224}, //E
  6. {0.5927662448712697, 0.0, 0.0, 0.4072328569272888} //S
  7. };

相關訓練代碼：

[java] view plain copy
  1. public static void buildPiAndMatrixA() {
  2. /**
  3. * count matrix:
  4. * ALL B M E S
  5. * B * * * * *
  6. * M * * * * *
  7. * E * * * * *
  8. * S * * * * *
  9. *
  10. * NOTE:
  11. * count[2][0] is the total number of complex words
  12. * count[3][0] is the total number of single words
  13. */
  14. long[][] count = new long[4][5];
  16. try {
  17. BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("icwb2-data/training/msr_training.utf8"),"UTF-8"));
  18. String line = null;
  19. String last = null;
  20. while ((line = br.readLine()) != null) {
  21. String[] words = line.split(" ");
  22. for (int i=0; i<words.length; i++) {
  23. String word = words[i].trim();
  24. int length = word.length();
  25. if (length < 1)
  26. continue;
  27. if (length == 1) {
  28. count[3][0]++;
  29. if (last != null) {
  30. if (last.length() == 1)
  31. count[3][4]++;
  32. else
  33. count[2][4]++;
  34. }
  35. } else {
  36. count[2][0]++;
  37. count[0][0]++;
  38. if (length > 2) {
  39. count[1][0] += length-2;
  40. count[0][2]++;
  41. if (length-2 > 1) {
  42. count[1][2] += length-3;
  43. }
  44. count[1][3]++;
  45. } else {
  46. count[0][3]++;
  47. }
  49. if (last != null) {
  50. if (last.length() == 1) {
  51. count[3][1]++;
  52. } else {
  53. count[2][1]++;
  54. }
  55. }
  56. }
  57. last = word;
  58. }
  59. //System.out.println("Finish " + words.length + " words ...");
  60. }
  61. } catch (FileNotFoundException e) {
  62. e.printStackTrace();
  63. } catch (UnsupportedEncodingException e) {
  64. e.printStackTrace();
  65. } catch (IOException e) {
  66. e.printStackTrace();
  67. }
  69. for (int i=0; i<count.length; i++)
  70. System.out.println(Arrays.toString(count[i]));
  71. System.out.println(" ===== So Pi array is: ===== ");
  72. double[] pi = new double[4];
  73. long allWordCount = count[2][0] + count[3][0];
  74. pi[0] = (double)count[2][0] / allWordCount;
  75. pi[3] = (double)count[3][0] / allWordCount;
  76. System.out.println(Arrays.toString(pi));
  77. System.out.println(" ===== And A matrix is: ===== ");
  78. double[][] A = new double[4][4];
  79. for (int i=0; i<A.length; i++)
  80. for (int j=0; j<A[i].length; j++)
  81. A[i][j] = (double)count[i][j+1]/ count[i][0];
  82. for (int i=0; i<A.length; i++)
  83. System.out.println(Arrays.toString(A[i]));
  84. }

矩陣中出現的概率為0的元素表明B-B, B-S, M-B, M-S, E-M, E-E, S-M, S-E這8種組合是不可能出現的。這是合乎邏輯的。

矩陣B內容比較大，格式如下：

[plain] view plain copy
  1. 1.0 3.174041419653506E-6 0.0016687522763828306 1.0633038755839245E-4 4.7610621294802586E-6
  2. 1.0 2.313791818894887E-6 5.738203710859319E-4 4.8589628196792625E-5 2.313791818894887E-6
  3. 1.0 7.935103549133765E-7 0.005299062150111528 6.348082839307012E-6 7.935103549133765E-7
  4. 1.0 1.7881026800082968E-6 0.005061224635763484 4.470256700020742E-6 8.940513400041484E-7

矩陣B訓練代碼：

[java] view plain copy
  1. public static void buildMatrixB(String charMapFile, String charMapCharset, String matrixBFileName) {
  2. /**
  3. * Chinese Character count => 5167
  4. *
  5. * count matrix:
  6. * ALL C1 C2 C3 CN C5168
  7. * B * * * * * 1/ALL+5168
  8. * M * * * * * 1/ALL+5168
  9. * E * * * * * 1/ALL+5168
  10. * S * * * * * 1/ALL+5168
  11. *
  12. * NOTE:
  13. * count[0][0] is the total number of begin count
  14. * count[0][0] is the total number of middle count
  15. * count[2][0] is the total number of end count
  16. * count[3][0] is the total number of single cound
  17. *
  18. * B row -> 4
  19. * B col -> 5169
  20. */
  21. long[][] matrixBCount = new long[4][5169];
  22. for (int row = 0; row < matrixBCount.length; row++) {
  23. Arrays.fill(matrixBCount[row], 1);
  24. matrixBCount[row][0] = 5168;
  25. }
  27. Map<Character, Integer> dict = new HashMap<Character, Integer>();
  28. Utils.readDict(charMapFile, charMapCharset, dict, null);
  30. try {
  31. BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("icwb2-data/training/msr_training.utf8"),"UTF-8"));
  32. String line = null;
  33. while ((line = br.readLine()) != null) {
  34. String[] words = line.split(" ");
  35. for (int i=0; i<words.length; i++) {
  36. String word = words[i].trim();
  37. if (word.length() < 1)
  38. continue;
  40. if (word.length() == 1) {
  41. int index = dict.get(word.charAt(0));
  42. matrixBCount[3][0]++;
  43. matrixBCount[3][index]++;
  44. } else {
  45. for (int j=0; j<word.length(); j++) {
  46. int index = dict.get(word.charAt(j));
  47. if (j == 0) {
  48. matrixBCount[0][0]++;
  49. matrixBCount[0][index]++;
  50. } else if (j == word.length()-1) {
  51. matrixBCount[2][0]++;
  52. matrixBCount[2][index]++;
  53. } else {
  54. matrixBCount[1][0]++;
  55. matrixBCount[1][index]++;
  56. }
  57. }
  58. }
  60. }
  61. }
  62. } catch (FileNotFoundException e) {
  63. e.printStackTrace();
  64. } catch (UnsupportedEncodingException e) {
  65. e.printStackTrace();
  66. } catch (IOException e) {
  67. e.printStackTrace();
  68. }
  70. System.out.println(" ===== matrixBCount ===== ");
  71. for (int i=0; i<matrixBCount.length; i++)
  72. System.out.println(Arrays.toString(matrixBCount[i]));
  74. System.out.println(" ========= B matrix =========");
  75. double[][] B = new double[matrixBCount.length][matrixBCount[0].length];
  76. for (int row = 0; row < B.length; row++) {
  77. for (int col = 0; col < B[row].length; col++) {
  78. B[row][col] = (double) matrixBCount[row][col] / matrixBCount[row][0];
  79. if (col < 50) {
  80. System.out.print(B[row][col] + " ");
  81. }
  82. }
  83. System.out.println("");
  84. }
  86. try {
  87. PrintWriter bOut = new PrintWriter(new File(matrixBFileName));
  88. for (int row = 0; row < B.length; row++) {
  89. for (int col = 0; col < B[row].length; col++) {
  90. bOut.print(B[row][col] + " ");
  91. }
  92. bOut.println("");
  93. bOut.flush();
  94. }
  95. bOut.close();
  96. System.out.println("Finish write B to file " + matrixBFileName);
  97. } catch (FileNotFoundException e) {
  98. e.printStackTrace();
  99. }
  100. }

有了矩陣PI，A跟B，我們就可以寫入一個觀察序列，用隱含馬爾可夫模型跟Viterbi算法獲得一個隱藏序列（分詞結果）了。如果你對隱含馬爾可夫模型還有什麽疑問，請參考52nlp的博文：

http://www.52nlp.cn/hmm-learn-best-practices-one-introduction

以下是我用Java自己實現的Viterbi算法，有一點需要註意的是，Java的double能表示最小的值約為1E-350，如果一個文本串很長，例如大於200個字符，算得的結果值很有可能會小於double的最小值，而由於精度問題變為0，這樣最終的計算結果就失去意義了。當然，如果能保證輸入串的長度比較短，可以不care這個，但為了程序的健壯性，我這裏在計算某一列的結果值小於1E-250時，將停止使用double而改用Java提供的高精度類BigDecimal，雖然計算速度會比double慢很多（尤其隨著串越來越長），但總比變為0，結果失去意義要強一些。但即便是這樣，這個函數也期望輸入串不長於200，否則就有可能在1S內得不到最終計算結果。

[java] view plain copy
  1. public static String Viterbi(double[] PI, double[][] A, double[][] B, int[] sentences) {
  2. StringBuilder ret = new StringBuilder();
  3. double[][] matrix = new double[PI.length][sentences.length];
  4. int[][] past = new int[PI.length][sentences.length];
  6. int supplementStartColumn = -1;
  7. BigDecimal[][] supplement = null; //new BigDecimal[][];
  9. for (int row=0; row<matrix.length; row++)
  10. matrix[row][0] = PI[row] * B[row][sentences[0]];
  12. for (int col=1; col<sentences.length; col++) {
  13. if (supplementStartColumn > -1) { //Use supplement BigDecimal matrix
  14. for (int row=0; row<matrix.length; row++) {
  15. BigDecimal max = new BigDecimal(0d);
  16. int last = -1;
  17. for (int r=0; r<matrix.length; r++) {
  18. BigDecimal value = supplement[r][col-1-supplementStartColumn].multiply(new BigDecimal(A[r][row])).multiply(new BigDecimal(B[row][sentences[col]]));
  19. if (value.compareTo(max) > 0) {
  20. max = value;
  21. last = r;
  22. }
  23. }
  24. supplement[row][col-supplementStartColumn] = max;
  25. past[row][col] = last;
  26. }
  27. } else {
  28. boolean switchSupplement = false;
  29. for (int row=0; row<matrix.length; row++) {
  30. double max = 0;
  31. int last = -1;
  32. for (int r=0; r<matrix.length; r++) {
  33. double value = matrix[r][col-1] * A[r][row] * B[row][sentences[col]];
  34. if (value > max) {
  35. max = value;
  36. last = r;
  37. }
  38. }
  39. matrix[row][col] = max;
  40. past[row][col] = last;
  41. if (max < 1E-250)
  42. switchSupplement = true;
  43. }
  45. //Really small data, should switch to supplement BigDecimal matrix now, or we will loose accuracy soon
  46. if (switchSupplement) {
  47. supplementStartColumn = col;
  48. supplement = new BigDecimal[PI.length][sentences.length - supplementStartColumn];
  49. for (int row=0; row<matrix.length; row++) {
  50. supplement[row][col - supplementStartColumn] = new BigDecimal(matrix[row][col]);
  51. }
  52. }
  53. }
  54. }
  56. int index = -1;
  57. if (supplementStartColumn > -1) {
  58. BigDecimal max = new BigDecimal(0d);
  59. int column = supplement[0].length-1;
  60. for (int row=0; row<supplement.length; row++) {
  61. if (supplement[row][column].compareTo(max) > 0) {
  62. max = supplement[row][column];
  63. index = row;
  64. }
  65. }
  66. } else {
  67. double max = 0;
  68. for (int row=0; row<matrix.length; row++)
  69. if (matrix[row][sentences.length-1] > max) {
  70. max = matrix[row][sentences.length-1];
  71. index = row;
  72. }
  73. }
  75. /*for (int i=0; i<matrix.length; i++)
  76. System.out.println(Arrays.toString(matrix[i]));*/
  78. ret.append(getDesc(index));
  79. for (int col=sentences.length-1; col>=1; col--) {
  80. index = past[index][col];
  81. ret.append(getDesc(index));
  82. }
  84. return ret.reverse().toString();
  85. }

測試一下，對如下串進行分詞：

[java] view plain copy
  1. String str2 = "這並不是一種最好的處理技術，因為這有可能低估或高估真實概率，更加科學的方法是使用復雜一點的Good—Turing技術，這項技術的原始版本是圖靈當年和他的助手Good在破解德國密碼機時發明的。";

結果為：

[java] view plain copy
    1. Switch to BigDecimal at length = 79
    2. words.length=95 timecost:63
    3. 這/並/不是/一種/最好/的/處理/技術/，/因為/這有/可能/低估/或/高估/真實/概率/，/更加/科學/的/方法/是/使用/復雜/一點/的/Good—Turing技術/，/這項/技術/的/原始/版本/是/圖靈/當年/和/他/的/助手/Good/在/破解/德國/密碼/機時/發明/的/。/
    4. timeCost: 63

轉：從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器

相關推薦

轉：從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器

lan reverse single trim 地址 note str rip resources http://blog.csdn.net/guixunlong/article/details/8925990 從頭開始編寫基於隱含馬爾可夫模型HMM的中文分詞器之一 - 資

動態規劃之隱含馬爾可夫模型(HMM)和維特比演算法(Viterbi Algorithm)

動態規劃之(HMM)和(Viterbi Algorithm) 1. 實際問題 HMM－韋小寶的骰子 • 兩種骰子，開始以2/5的概率出千。 – 正常A：以1/6的概率出現每個點 – 不正常B： 5,6出現概率為3/10,其它為1/10 • 出千的

隱含馬爾科夫模型HMM

作者：Yang Eninala 連結：https://www.zhihu.com/question/20962240/answer/33438846 來源：知乎 著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。   隱馬爾可夫（HMM）好講，簡單易懂不好

統計學習方法_隱馬爾可夫模型HMM實現

這裡用到的資料集是三角波，使用長度20的序列訓練100次，生成長度為100的序列。HMM的初始化非常重要，這裡採用隨機初始化。 #!/usr/bin/env python3 # -*- coding: utf-8 -*- import csv import random

【演算法】 隱馬爾可夫模型 HMM

隱馬爾可夫模型 （Hidden Markov Model，HMM） 以下來源於_作者 ：skyme 地址：http://www.cnblogs.com/skyme/p/4651331.html 隱馬爾可夫模型（Hidden Markov Model，HMM）是統計模型，它用來描述一

隱馬爾可夫模型HMM（二）概率計算問題

摘自 1.李航的《統計學習方法》 2.http://www.cnblogs.com/pinard/p/6955871.html   一、概率計算問題 上一篇介紹了概率計算問題是給定了λ（A，B，π），計算一個觀測序列O出現的概率，即求P（O|λ）。 用三種方法，直接計演算法，前向演算法，

【中文分詞】隱馬爾可夫模型HMM

Nianwen Xue在《Chinese Word Segmentation as Character Tagging》中將中文分詞視作為序列標註問題（sequence tagging problem），由此引入監督學習演算法來解決分詞問題。 1. HMM 首先，我們將簡要地介紹HMM（主要參考了李航老師的《

隱馬爾可夫模型HMM---《統計學習方法》第十章

標註問題 標註問題的輸入是一個觀測序列，輸出是一個標記序列或狀態序列。標註問題的目的在於學習一個模型，使它能夠對觀測序列給出標記序列作為預測。 標註常用的統計學習方法有：隱馬爾可夫模型，條件隨機場。 舉例：給定一個由單片語成的句子，對這個句子中的每一個單詞

HMM（隱馬爾科夫）用於中文分詞

隱馬爾可夫模型（Hidden Markov Model，HMM）是用來描述一個含有隱含未知引數的馬爾可夫過程。 本文閱讀了2篇blog，理解其中的意思，附上自己的程式碼，共同學習。 一、理解隱馬爾科夫  1.1 舉例理解 來源：< http

隱馬爾可夫模型(HMM)

宣告：          1，本篇為個人對《2012.李航.統計學習方法.pdf》的學習總結，不得用作商用，歡迎轉載，但請註明出處（即：本帖地址）。          2，由於本人在學習初始時有很多數學知識都已忘記，所以為了弄懂其中的內容查閱了很多資料，所以裡面應該會有引用

詳解隱馬爾可夫模型(HMM)中的維特比演算法

筆記轉載於GitHub專案：https://github.com/NLP-LOVE/Introduction-NLP 4. 隱馬爾可夫模型與序列標註 第3章的n元語法模型從詞語接續的流暢度出發，為全切分詞網中的二元接續打分，進而利用維特比演算法求解似然概率最大的路徑。這種詞語級別的模型無法應對 OOV(Out

機器學習筆記（一）：關於隱含馬爾科夫模型

這篇文章是我在看完吳軍老師的數學之美一書中關於隱馬爾科夫模型之後所寫，旨在記錄一下自己對隱馬爾科夫模型的認識， 隱馬爾科夫模型我在很早之前就有所接觸，在學習語音識別的時候，會涉及到隱馬爾科夫模型，當時是完全不懂，現在雖然還是一知半解，因為沒有再次去使用，接下來的主攻方向是機器視覺，對隱馬爾可

ml課程：概率圖模型—貝葉斯網路、隱馬爾可夫模型相關（含程式碼實現）

以下是我的學習筆記，以及總結，如有錯誤之處請不吝賜教。 本文主要介紹機器學習中的一個分支——概率圖模型、相關基礎概念以及樸素貝葉斯、隱馬爾可夫演算法，最後還有相關程式碼案例。 說到機器學習的起源，可以分為以下幾個派別： 連線主義：又稱為仿生學派(bionicsism)或生理學派

隱含馬爾科夫模型的訓練

在這裡我們仍然使用非常簡單的天氣模型來做說明。 在這個馬爾可夫模型中，存在三個狀態，Sunny， Rainy， Cloudy，同時圖片上標的是各個狀態間的轉移概率（如果不明白什麼是轉移概率，那建議先去學習什麼是馬爾可夫再來看HMM）。 現在我們要說明什麼是 HMM。

隱馬爾可夫模型學習筆記（一）：前後向演算法介紹與推導

學習隱馬爾可夫模型（HMM），主要就是學習三個問題：概率計算問題，學習問題和預測問題。概率計算問題主要是講前向演算法和後向演算法，這兩個演算法可以說是隱馬爾可夫的重中之重，接下來會依次介紹以下內容。 隱馬爾可夫模型介紹 模型的假設 直接計演算法，前向演算法，後向演

課外知識：隱馬爾可夫模型

最近忙於公司事物沒能即使更新文章。今天查閱資料發現一篇講解“隱馬爾可夫模型”的小貼，感覺不錯，特此轉載，與大家分享。歡迎想學人工智慧入門的同學查閱。高階人工智慧老鳥可以無視。 原作者：Yang Eninala 來源：知乎 著作權歸作者所有。商業轉載請聯絡作者獲得授權，非

基於監督學習的隱馬爾科夫模型(HMM)實現中文分詞

因為語料是分好詞來訓練的，所以程式碼寫起來還算簡單，HMM的引數pi，A，B訓練只是做一個簡單的統計工作 反倒是寫維特比演算法時出了一些問題，因為之前都是紙上談兵，真正寫這個演算法才發現之前有的地方沒有搞明白！！ 維特比的演算法大致如下： 注：下面[]中代表下標

隱馬爾科夫模型HMM（二）前向後向算法評估觀察序列概率

流程 來看 遞推 limits its 可能 基本 通過 如何 　　　　隱馬爾科夫模型HMM（一）HMM模型 　　　　隱馬爾科夫模型HMM（二）前向後向算法評估觀察序列概率 　　　　隱馬爾科夫模型HMM（三）鮑姆-韋爾奇算法求解HMM參數（TODO） 　　　　隱馬爾科夫模型

隱馬爾可夫模型（三）

image 之前 下標 如何 最大路 mage 局部最優 .com 紅色 預測算法 還記得隱馬爾可夫模型的三個問題嗎？本篇介紹第三個問題：預測問題，即給定模型參數和觀測序列，求最有可能的狀態序列，有如下兩種算法。 近似算法 在每個時刻t選出當前最有可能的狀態 it，從而得到

隱馬爾可夫模型（一）

回溯 一是 描述 數學 函數 觀測 tran 隱藏 之間 隱馬爾可夫模型 　　隱馬爾可夫模型（Hidden Markov Model，HMM）是一種統計模型，廣泛應用在語音識別，詞性自動標註，音字轉換，概率文法等各個自然語言處理等應用領域。經過長期發展，尤其