转自：http://yangshangchuan.iteye.com/blog/2056537（有代码可下载）

word分词器、ansj分词器、mmseg4j分词器、ik-analyzer分词器分词效果评估

博客分类：

  • 人工智能
word分词word分词器word分词组件word分词库中文分词开源中文分词Java中文分词 

word分词是一个Java实现的中文分词组件，提供了多种基于词典的分词算法，并利用ngram模型来消除歧义。 能准确识别英文、数字，以及日期、时间等数量词，能识别人名、地名、组织机构名等未登录词。 同时提供了Lucene、Solr、ElasticSearch插件。

word分词器分词效果评估主要评估下面7种分词算法：

正向最大匹配算法：MaximumMatching
逆向最大匹配算法：ReverseMaximumMatching
正向最小匹配算法：MinimumMatching
逆向最小匹配算法：ReverseMinimumMatching
双向最大匹配算法：BidirectionalMaximumMatching
双向最小匹配算法：BidirectionalMinimumMatching
双向最大最小匹配算法：BidirectionalMaximumMinimumMatching

所有的双向算法都使用ngram来消歧，分词效果评估分别评估bigram和trigram。

评估采用的测试文本有253 3709行，共2837 4490个字符，标准文本和测试文本一行行对应，标准文本中的词以空格分隔，评估标准为严格一致，评估核心代码如下：

Java代码  
  1. /**
  2. * 分词效果评估
  3. * @param resultText 实际分词结果文件路径
  4. * @param standardText 标准分词结果文件路径
  5. * @return 评估结果
  6. */
  7. public static EvaluationResult evaluation(String resultText, String standardText) {
  8. int perfectLineCount=0;
  9. int wrongLineCount=0;
  10. int perfectCharCount=0;
  11. int wrongCharCount=0;
  12. try(BufferedReader resultReader = new BufferedReader(new InputStreamReader(new FileInputStream(resultText),"utf-8"));
  13. BufferedReader standardReader = new BufferedReader(new InputStreamReader(new FileInputStream(standardText),"utf-8"))){
  14. String result;
  15. while( (result = resultReader.readLine()) != null ){
  16. result = result.trim();
  17. String standard = standardReader.readLine().trim();
  18. if(result.equals("")){
  19. continue;
  20. }
  21. if(result.equals(standard)){
  22. //分词结果和标准一模一样
  23. perfectLineCount++;
  24. perfectCharCount+=standard.replaceAll("\\s+", "").length();
  25. }else{
  26. //分词结果和标准不一样
  27. wrongLineCount++;
  28. wrongCharCount+=standard.replaceAll("\\s+", "").length();
  29. }
  30. }
  31. } catch (IOException ex) {
  32. LOGGER.error("分词效果评估失败：", ex);
  33. }
  34. int totalLineCount = perfectLineCount+wrongLineCount;
  35. int totalCharCount = perfectCharCount+wrongCharCount;
  36. EvaluationResult er = new EvaluationResult();
  37. er.setPerfectCharCount(perfectCharCount);
  38. er.setPerfectLineCount(perfectLineCount);
  39. er.setTotalCharCount(totalCharCount);
  40. er.setTotalLineCount(totalLineCount);
  41. er.setWrongCharCount(wrongCharCount);
  42. er.setWrongLineCount(wrongLineCount);
  43. return er;
  44. }
Java代码  
  1. /**
  2. * 中文分词效果评估结果
  3. * @author 杨尚川
  4. */
  5. public class EvaluationResult implements Comparable{
  6. private int totalLineCount;
  7. private int perfectLineCount;
  8. private int wrongLineCount;
  9. private int totalCharCount;
  10. private int perfectCharCount;
  11. private int wrongCharCount;
  12. public float getLinePerfectRate(){
  13. return perfectLineCount/(float)totalLineCount*100;
  14. }
  15. public float getLineWrongRate(){
  16. return wrongLineCount/(float)totalLineCount*100;
  17. }
  18. public float getCharPerfectRate(){
  19. return perfectCharCount/(float)totalCharCount*100;
  20. }
  21. public float getCharWrongRate(){
  22. return wrongCharCount/(float)totalCharCount*100;
  23. }
  24. public int getTotalLineCount() {
  25. return totalLineCount;
  26. }
  27. public void setTotalLineCount(int totalLineCount) {
  28. this.totalLineCount = totalLineCount;
  29. }
  30. public int getPerfectLineCount() {
  31. return perfectLineCount;
  32. }
  33. public void setPerfectLineCount(int perfectLineCount) {
  34. this.perfectLineCount = perfectLineCount;
  35. }
  36. public int getWrongLineCount() {
  37. return wrongLineCount;
  38. }
  39. public void setWrongLineCount(int wrongLineCount) {
  40. this.wrongLineCount = wrongLineCount;
  41. }
  42. public int getTotalCharCount() {
  43. return totalCharCount;
  44. }
  45. public void setTotalCharCount(int totalCharCount) {
  46. this.totalCharCount = totalCharCount;
  47. }
  48. public int getPerfectCharCount() {
  49. return perfectCharCount;
  50. }
  51. public void setPerfectCharCount(int perfectCharCount) {
  52. this.perfectCharCount = perfectCharCount;
  53. }
  54. public int getWrongCharCount() {
  55. return wrongCharCount;
  56. }
  57. public void setWrongCharCount(int wrongCharCount) {
  58. this.wrongCharCount = wrongCharCount;
  59. }
  60. @Override
  61. public String toString(){
  62. return segmentationAlgorithm.name()+"（"+segmentationAlgorithm.getDes()+"）："
  63. +"\n"
  64. +"分词速度："+segSpeed+" 字符/毫秒"
  65. +"\n"
  66. +"行数完美率："+getLinePerfectRate()+"%"
  67. +"  行数错误率："+getLineWrongRate()+"%"
  68. +"  总的行数："+totalLineCount
  69. +"  完美行数："+perfectLineCount
  70. +"  错误行数："+wrongLineCount
  71. +"\n"
  72. +"字数完美率："+getCharPerfectRate()+"%"
  73. +" 字数错误率："+getCharWrongRate()+"%"
  74. +" 总的字数："+totalCharCount
  75. +" 完美字数："+perfectCharCount
  76. +" 错误字数："+wrongCharCount;
  77. }
  78. @Override
  79. public int compareTo(Object o) {
  80. EvaluationResult other = (EvaluationResult)o;
  81. if(other.getLinePerfectRate() - getLinePerfectRate() > 0){
  82. return 1;
  83. }
  84. if(other.getLinePerfectRate() - getLinePerfectRate() < 0){
  85. return -1;
  86. }
  87. return 0;
  88. }
  89. }

word分词使用trigram评估结果：

Java代码  
  1. BidirectionalMaximumMinimumMatching（双向最大最小匹配算法）：
  2. 分词速度：265.62566 字符/毫秒
  3. 行数完美率：55.352688%  行数错误率：44.647312%  总的行数：2533709  完美行数：1402476  错误行数：1131233
  4. 字数完美率：46.23227% 字数错误率：53.76773% 总的字数：28374490 完美字数：13118171 错误字数：15256319
  5. BidirectionalMaximumMatching（双向最大匹配算法）：
  6. 分词速度：335.62155 字符/毫秒
  7. 行数完美率：50.16934%  行数错误率：49.83066%  总的行数：2533709  完美行数：1271145  错误行数：1262564
  8. 字数完美率：40.692997% 字数错误率：59.307003% 总的字数：28374490 完美字数：11546430 错误字数：16828060
  9. ReverseMaximumMatching（逆向最大匹配算法）：
  10. 分词速度：686.71045 字符/毫秒
  11. 行数完美率：46.723125%  行数错误率：53.27688%  总的行数：2533709  完美行数：1183828  错误行数：1349881
  12. 字数完美率：36.67598% 字数错误率：63.32402% 总的字数：28374490 完美字数：10406622 错误字数：17967868
  13. MaximumMatching（正向最大匹配算法）：
  14. 分词速度：733.9535 字符/毫秒
  15. 行数完美率：46.661713%  行数错误率：53.338287%  总的行数：2533709  完美行数：1182272  错误行数：1351437
  16. 字数完美率：36.72861% 字数错误率：63.271393% 总的字数：28374490 完美字数：10421556 错误字数：17952934
  17. BidirectionalMinimumMatching（双向最小匹配算法）：
  18. 分词速度：432.87375 字符/毫秒
  19. 行数完美率：45.863907%  行数错误率：54.136093%  总的行数：2533709  完美行数：1162058  错误行数：1371651
  20. 字数完美率：35.942123% 字数错误率：64.05788% 总的字数：28374490 完美字数：10198395 错误字数：18176095
  21. ReverseMinimumMatching（逆向最小匹配算法）：
  22. 分词速度：1033.58636 字符/毫秒
  23. 行数完美率：41.776066%  行数错误率：58.223934%  总的行数：2533709  完美行数：1058484  错误行数：1475225
  24. 字数完美率：31.678978% 字数错误率：68.32102% 总的字数：28374490 完美字数：8988748 错误字数：19385742
  25. MinimumMatching（正向最小匹配算法）：
  26. 分词速度：1175.4431 字符/毫秒
  27. 行数完美率：36.853836%  行数错误率：63.146164%  总的行数：2533709  完美行数：933769  错误行数：1599940
  28. 字数完美率：26.859812% 字数错误率：73.14019% 总的字数：28374490 完美字数：7621334 错误字数：20753156

word分词使用bigram评估结果：

Java代码  
  1. BidirectionalMaximumMinimumMatching（双向最大最小匹配算法）：
  2. 分词速度：233.49121 字符/毫秒
  3. 行数完美率：55.31531%  行数错误率：44.68469%  总的行数：2533709  完美行数：1401529  错误行数：1132180
  4. 字数完美率：45.834396% 字数错误率：54.165604% 总的字数：28374490 完美字数：13005277 错误字数：15369213
  5. BidirectionalMaximumMatching（双向最大匹配算法）：
  6. 分词速度：303.59401 字符/毫秒
  7. 行数完美率：52.007233%  行数错误率：47.992767%  总的行数：2533709  完美行数：1317712  错误行数：1215997
  8. 字数完美率：42.424194% 字数错误率：57.575806% 总的字数：28374490 完美字数：12037649 错误字数：16336841
  9. BidirectionalMinimumMatching（双向最小匹配算法）：
  10. 分词速度：349.67215 字符/毫秒
  11. 行数完美率：46.766422%  行数错误率：53.23358%  总的行数：2533709  完美行数：1184925  错误行数：1348784
  12. 字数完美率：36.52718% 字数错误率：63.47282% 总的字数：28374490 完美字数：10364401 错误字数：18010089
  13. ReverseMaximumMatching（逆向最大匹配算法）：
  14. 分词速度：598.04272 字符/毫秒
  15. 行数完美率：46.723125%  行数错误率：53.27688%  总的行数：2533709  完美行数：1183828  错误行数：1349881
  16. 字数完美率：36.67598% 字数错误率：63.32402% 总的字数：28374490 完美字数：10406622 错误字数：17967868
  17. MaximumMatching（正向最大匹配算法）：
  18. 分词速度：676.7993 字符/毫秒
  19. 行数完美率：46.661713%  行数错误率：53.338287%  总的行数：2533709  完美行数：1182272  错误行数：1351437
  20. 字数完美率：36.72861% 字数错误率：63.271393% 总的字数：28374490 完美字数：10421556 错误字数：17952934
  21. ReverseMinimumMatching（逆向最小匹配算法）：
  22. 分词速度：806.9586 字符/毫秒
  23. 行数完美率：41.776066%  行数错误率：58.223934%  总的行数：2533709  完美行数：1058484  错误行数：1475225
  24. 字数完美率：31.678978% 字数错误率：68.32102% 总的字数：28374490 完美字数：8988748 错误字数：19385742
  25. MinimumMatching（正向最小匹配算法）：
  26. 分词速度：1020.9208 字符/毫秒
  27. 行数完美率：36.853836%  行数错误率：63.146164%  总的行数：2533709  完美行数：933769  错误行数：1599940
  28. 字数完美率：26.859812% 字数错误率：73.14019% 总的字数：28374490 完美字数：7621334 错误字数：20753156

Ansj0.9的评估结果如下：

Java代码  
  1. Ansj ToAnalysis 精准分词：
  2. 分词速度：495.9188 字符/毫秒
  3. 行数完美率：58.609295%  行数错误率：41.390705%  总的行数：2533709  完美行数：1484989  错误行数：1048720
  4. 字数完美率：50.97614%   字数错误率：49.023857%  总的字数：28374490 完美字数：14464220 错误字数：13910270
  5. Ansj NlpAnalysis NLP分词：
  6. 分词速度：350.7527 字符/毫秒
  7. 行数完美率：58.60353%  行数错误率：41.396465%  总的行数：2533709  完美行数：1484843  错误行数：1048866
  8. 字数完美率：50.75546%  字数错误率：49.244545%  总的字数：28374490 完美字数：14401602 错误字数：13972888
  9. Ansj BaseAnalysis 基本分词：
  10. 分词速度：532.65424 字符/毫秒
  11. 行数完美率：54.028584%  行数错误率：45.97142%  总的行数：2533709  完美行数：1368927  错误行数：1164782
  12. 字数完美率：46.84512%   字数错误率：53.15488%  总的字数：28374490 完美字数：13292064 错误字数：15082426
  13. Ansj IndexAnalysis 面向索引的分词：
  14. 分词速度：564.6103 字符/毫秒
  15. 行数完美率：53.510803%  行数错误率：46.489197%  总的行数：2533709  完美行数：1355808  错误行数：1177901
  16. 字数完美率：46.355087%  字数错误率：53.644913%  总的字数：28374490 完美字数：13153019 错误字数：15221471

Ansj1.4的评估结果如下：

Java代码  
  1. Ansj ToAnalysis 精准分词：
  2. 分词速度：581.7306 字符/毫秒
  3. 行数完美率：58.60302%  行数错误率：41.39698%  总的行数：2533709  完美行数：1484830  错误行数：1048879
  4. 字数完美率：50.968987% 字数错误率：49.031013% 总的字数：28374490 完美字数：14462190 错误字数：13912300
  5. Ansj NlpAnalysis NLP分词：
  6. 分词速度：138.81165 字符/毫秒
  7. 行数完美率：58.1515%  行数错误率：41.8485%  总的行数：2533687  完美行数：1473377  错误行数：1060310
  8. 字数完美率：49.806484% 字数错误率：50.19352% 总的字数：28374398 完美字数：14132290 错误字数：14242108
  9. Ansj BaseAnalysis 基本分词：
  10. 分词速度：627.68475 字符/毫秒
  11. 行数完美率：55.3174%  行数错误率：44.6826%  总的行数：2533709  完美行数：1401582  错误行数：1132127
  12. 字数完美率：48.177986% 字数错误率：51.822014% 总的字数：28374490 完美字数：13670258 错误字数：14704232
  13. Ansj IndexAnalysis 面向索引的分词：
  14. 分词速度：715.55176 字符/毫秒
  15. 行数完美率：50.89444%  行数错误率：49.10556%  总的行数：2533709  完美行数：1289517  错误行数：1244192
  16. 字数完美率：42.965115% 字数错误率：57.034885% 总的字数：28374490 完美字数：12191132 错误字数：16183358

Ansj分词评估程序如下：

Java代码  
  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.io.OutputStreamWriter;
  8. import java.nio.file.Files;
  9. import java.nio.file.Paths;
  10. import java.util.ArrayList;
  11. import java.util.Collections;
  12. import java.util.List;
  13. import org.ansj.domain.Term;
  14. import org.ansj.splitWord.analysis.BaseAnalysis;
  15. import org.ansj.splitWord.analysis.IndexAnalysis;
  16. import org.ansj.splitWord.analysis.NlpAnalysis;
  17. import org.ansj.splitWord.analysis.ToAnalysis;
  18. /**
  19. * Ansj分词器分词效果评估
  20. * @author 杨尚川
  21. */
  22. public class AnsjEvaluation {
  23. public static void main(String[] args) throws Exception{
  24. // 测试文件 d:/test-text.txt 和 标准分词结果文件 d:/standard-text.txt 的下载地址：
  25. // http://pan.baidu.com/s/1hqihzjY
  26. List<EvaluationResult> list = new ArrayList<>();
  27. // 对文本进行分词
  28. float rate = seg("d:/test-text.txt", "d:/result-text-BaseAnalysis.txt", "BaseAnalysis");
  29. // 对分词结果进行评估
  30. EvaluationResult result = evaluation("d:/result-text-BaseAnalysis.txt", "d:/standard-text.txt");
  31. result.setAnalyzer("Ansj BaseAnalysis 基本分词");
  32. result.setSegSpeed(rate);
  33. list.add(result);
  34. // 对文本进行分词
  35. rate = seg("d:/test-text.txt", "d:/result-text-ToAnalysis.txt", "ToAnalysis");
  36. // 对分词结果进行评估
  37. result = evaluation("d:/result-text-ToAnalysis.txt", "d:/standard-text.txt");
  38. result.setAnalyzer("Ansj ToAnalysis 精准分词");
  39. result.setSegSpeed(rate);
  40. list.add(result);
  41. // 对文本进行分词
  42. rate = seg("d:/test-text.txt", "d:/result-text-NlpAnalysis.txt", "NlpAnalysis");
  43. // 对分词结果进行评估
  44. result = evaluation("d:/result-text-NlpAnalysis.txt", "d:/standard-text.txt");
  45. result.setAnalyzer("Ansj NlpAnalysis NLP分词");
  46. result.setSegSpeed(rate);
  47. list.add(result);
  48. // 对文本进行分词
  49. rate = seg("d:/test-text.txt", "d:/result-text-IndexAnalysis.txt", "IndexAnalysis");
  50. // 对分词结果进行评估
  51. result = evaluation("d:/result-text-IndexAnalysis.txt", "d:/standard-text.txt");
  52. result.setAnalyzer("Ansj IndexAnalysis 面向索引的分词");
  53. result.setSegSpeed(rate);
  54. list.add(result);
  55. //输出评估结果
  56. Collections.sort(list);
  57. System.out.println("");
  58. for(EvaluationResult r : list){
  59. System.out.println(r+"\n");
  60. }
  61. }
  62. private static float seg(final String input, final String output, final String type) throws Exception{
  63. float rate = 0;
  64. try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(input),"utf-8"));
  65. BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output),"utf-8"))){
  66. long size = Files.size(Paths.get(input));
  67. System.out.println("size:"+size);
  68. System.out.println("文件大小："+(float)size/1024/1024+" MB");
  69. int textLength=0;
  70. int progress=0;
  71. long start = System.currentTimeMillis();
  72. String line = null;
  73. while((line = reader.readLine()) != null){
  74. if("".equals(line.trim())){
  75. writer.write("\n");
  76. continue;
  77. }
  78. textLength += line.length();
  79. switch(type){
  80. case "BaseAnalysis":
  81. for(Term term : BaseAnalysis.parse(line)){
  82. writer.write(term.getName()+" ");
  83. }
  84. break;
  85. case "ToAnalysis":
  86. for(Term term : ToAnalysis.parse(line)){
  87. writer.write(term.getName()+" ");
  88. }
  89. break;
  90. case "NlpAnalysis":
  91. try{
  92. for(Term term : NlpAnalysis.parse(line)){
  93. writer.write(term.getName()+" ");
  94. }
  95. }catch(Exception e){}
  96. break;
  97. case "IndexAnalysis":
  98. for(Term term : IndexAnalysis.parse(line)){
  99. writer.write(term.getName()+" ");
  100. }
  101. break;
  102. }
  103. writer.write("\n");
  104. progress += line.length();
  105. if( progress > 500000){
  106. progress = 0;
  107. System.out.println("分词进度："+(int)(textLength*2.99/size*100)+"%");
  108. }
  109. }
  110. long cost = System.currentTimeMillis() - start;
  111. rate = textLength/(float)cost;
  112. System.out.println("字符数目："+textLength);
  113. System.out.println("分词耗时："+cost+" 毫秒");
  114. System.out.println("分词速度："+rate+" 字符/毫秒");
  115. }
  116. return rate;
  117. }
  118. /**
  119. * 分词效果评估
  120. * @param resultText 实际分词结果文件路径
  121. * @param standardText 标准分词结果文件路径
  122. * @return 评估结果
  123. */
  124. private static EvaluationResult evaluation(String resultText, String standardText) {
  125. int perfectLineCount=0;
  126. int wrongLineCount=0;
  127. int perfectCharCount=0;
  128. int wrongCharCount=0;
  129. try(BufferedReader resultReader = new BufferedReader(new InputStreamReader(new FileInputStream(resultText),"utf-8"));
  130. BufferedReader standardReader = new BufferedReader(new InputStreamReader(new FileInputStream(standardText),"utf-8"))){
  131. String result;
  132. while( (result = resultReader.readLine()) != null ){
  133. result = result.trim();
  134. String standard = standardReader.readLine().trim();
  135. if(result.equals("")){
  136. continue;
  137. }
  138. if(result.equals(standard)){
  139. //分词结果和标准一模一样
  140. perfectLineCount++;
  141. perfectCharCount+=standard.replaceAll("\\s+", "").length();
  142. }else{
  143. //分词结果和标准不一样
  144. wrongLineCount++;
  145. wrongCharCount+=standard.replaceAll("\\s+", "").length();
  146. }
  147. }
  148. } catch (IOException ex) {
  149. System.err.println("分词效果评估失败：" + ex.getMessage());
  150. }
  151. int totalLineCount = perfectLineCount+wrongLineCount;
  152. int totalCharCount = perfectCharCount+wrongCharCount;
  153. EvaluationResult er = new EvaluationResult();
  154. er.setPerfectCharCount(perfectCharCount);
  155. er.setPerfectLineCount(perfectLineCount);
  156. er.setTotalCharCount(totalCharCount);
  157. er.setTotalLineCount(totalLineCount);
  158. er.setWrongCharCount(wrongCharCount);
  159. er.setWrongLineCount(wrongLineCount);
  160. return er;
  161. }
  162. /**
  163. * 分词结果
  164. */
  165. private static class EvaluationResult implements Comparable{
  166. private String analyzer;
  167. private float segSpeed;
  168. private int totalLineCount;
  169. private int perfectLineCount;
  170. private int wrongLineCount;
  171. private int totalCharCount;
  172. private int perfectCharCount;
  173. private int wrongCharCount;
  174. public String getAnalyzer() {
  175. return analyzer;
  176. }
  177. public void setAnalyzer(String analyzer) {
  178. this.analyzer = analyzer;
  179. }
  180. public float getSegSpeed() {
  181. return segSpeed;
  182. }
  183. public void setSegSpeed(float segSpeed) {
  184. this.segSpeed = segSpeed;
  185. }
  186. public float getLinePerfectRate(){
  187. return perfectLineCount/(float)totalLineCount*100;
  188. }
  189. public float getLineWrongRate(){
  190. return wrongLineCount/(float)totalLineCount*100;
  191. }
  192. public float getCharPerfectRate(){
  193. return perfectCharCount/(float)totalCharCount*100;
  194. }
  195. public float getCharWrongRate(){
  196. return wrongCharCount/(float)totalCharCount*100;
  197. }
  198. public int getTotalLineCount() {
  199. return totalLineCount;
  200. }
  201. public void setTotalLineCount(int totalLineCount) {
  202. this.totalLineCount = totalLineCount;
  203. }
  204. public int getPerfectLineCount() {
  205. return perfectLineCount;
  206. }
  207. public void setPerfectLineCount(int perfectLineCount) {
  208. this.perfectLineCount = perfectLineCount;
  209. }
  210. public int getWrongLineCount() {
  211. return wrongLineCount;
  212. }
  213. public void setWrongLineCount(int wrongLineCount) {
  214. this.wrongLineCount = wrongLineCount;
  215. }
  216. public int getTotalCharCount() {
  217. return totalCharCount;
  218. }
  219. public void setTotalCharCount(int totalCharCount) {
  220. this.totalCharCount = totalCharCount;
  221. }
  222. public int getPerfectCharCount() {
  223. return perfectCharCount;
  224. }
  225. public void setPerfectCharCount(int perfectCharCount) {
  226. this.perfectCharCount = perfectCharCount;
  227. }
  228. public int getWrongCharCount() {
  229. return wrongCharCount;
  230. }
  231. public void setWrongCharCount(int wrongCharCount) {
  232. this.wrongCharCount = wrongCharCount;
  233. }
  234. @Override
  235. public String toString(){
  236. return analyzer+"："
  237. +"\n"
  238. +"分词速度："+segSpeed+" 字符/毫秒"
  239. +"\n"
  240. +"行数完美率："+getLinePerfectRate()+"%"
  241. +"  行数错误率："+getLineWrongRate()+"%"
  242. +"  总的行数："+totalLineCount
  243. +"  完美行数："+perfectLineCount
  244. +"  错误行数："+wrongLineCount
  245. +"\n"
  246. +"字数完美率："+getCharPerfectRate()+"%"
  247. +" 字数错误率："+getCharWrongRate()+"%"
  248. +" 总的字数："+totalCharCount
  249. +" 完美字数："+perfectCharCount
  250. +" 错误字数："+wrongCharCount;
  251. }
  252. @Override
  253. public int compareTo(Object o) {
  254. EvaluationResult other = (EvaluationResult)o;
  255. if(other.getLinePerfectRate() - getLinePerfectRate() > 0){
  256. return 1;
  257. }
  258. if(other.getLinePerfectRate() - getLinePerfectRate() < 0){
  259. return -1;
  260. }
  261. return 0;
  262. }
  263. }
  264. }

MMSeg4j1.9.1的评估结果如下：

Java代码  
  1. MMSeg4j ComplexSeg：
  2. 分词速度：794.24805 字符/毫秒
  3. 行数完美率：38.817604%  行数错误率：61.182396%  总的行数：2533688  完美行数：983517  错误行数：1550171
  4. 字数完美率：29.604435% 字数错误率：70.39557% 总的字数：28374428 完美字数：8400089 错误字数：19974339
  5. MMSeg4j SimpleSeg：
  6. 分词速度：1026.1058 字符/毫秒
  7. 行数完美率：37.570095%  行数错误率：62.429905%  总的行数：2533688  完美行数：951909  错误行数：1581779
  8. 字数完美率：28.455273% 字数错误率：71.54473% 总的字数：28374428 完美字数：8074021 错误字数：20300407
  9. MMSeg4j MaxWordSeg：
  10. 分词速度：813.0676 字符/毫秒
  11. 行数完美率：34.27573%  行数错误率：65.72427%  总的行数：2533688  完美行数：868440  错误行数：1665248
  12. 字数完美率：25.20896% 字数错误率：74.79104% 总的字数：28374428 完美字数：7152898 错误字数：21221530

MMSeg4j1.9.1分词评估程序如下：

Java代码  
  1. import com.chenlb.mmseg4j.ComplexSeg;
  2. import com.chenlb.mmseg4j.Dictionary;
  3. import com.chenlb.mmseg4j.MMSeg;
  4. import com.chenlb.mmseg4j.MaxWordSeg;
  5. import com.chenlb.mmseg4j.Seg;
  6. import com.chenlb.mmseg4j.SimpleSeg;
  7. import com.chenlb.mmseg4j.Word;
  8. import java.io.BufferedReader;
  9. import java.io.BufferedWriter;
  10. import java.io.FileInputStream;
  11. import java.io.FileOutputStream;
  12. import java.io.IOException;
  13. import java.io.InputStreamReader;
  14. import java.io.OutputStreamWriter;
  15. import java.io.StringReader;
  16. import java.nio.file.Files;
  17. import java.nio.file.Paths;
  18. import java.util.ArrayList;
  19. import java.util.Collections;
  20. import java.util.List;
  21. /**
  22. * MMSeg4j分词器分词效果评估
  23. * @author 杨尚川
  24. */
  25. public class MMSeg4jEvaluation {
  26. public static void main(String[] args) throws Exception{
  27. // 测试文件 d:/test-text.txt 和 标准分词结果文件 d:/standard-text.txt 的下载地址：
  28. // http://pan.baidu.com/s/1hqihzjY
  29. List<EvaluationResult> list = new ArrayList<>();
  30. Dictionary dic = Dictionary.getInstance();
  31. // 对文本进行分词
  32. float rate = seg("d:/test-text.txt", "d:/result-text-ComplexSeg.txt", new ComplexSeg(dic));
  33. // 对分词结果进行评估
  34. EvaluationResult result = evaluation("d:/result-text-ComplexSeg.txt", "d:/standard-text.txt");
  35. result.setAnalyzer("MMSeg4j ComplexSeg");
  36. result.setSegSpeed(rate);
  37. list.add(result);
  38. // 对文本进行分词
  39. rate = seg("d:/test-text.txt", "d:/result-text-SimpleSeg.txt", new SimpleSeg(dic));
  40. // 对分词结果进行评估
  41. result = evaluation("d:/result-text-SimpleSeg.txt", "d:/standard-text.txt");
  42. result.setAnalyzer("MMSeg4j SimpleSeg");
  43. result.setSegSpeed(rate);
  44. list.add(result);
  45. // 对文本进行分词
  46. rate = seg("d:/test-text.txt", "d:/result-text-MaxWordSeg.txt", new MaxWordSeg(dic));
  47. // 对分词结果进行评估
  48. result = evaluation("d:/result-text-MaxWordSeg.txt", "d:/standard-text.txt");
  49. result.setAnalyzer("MMSeg4j MaxWordSeg");
  50. result.setSegSpeed(rate);
  51. list.add(result);
  52. //输出评估结果
  53. Collections.sort(list);
  54. System.out.println("");
  55. for(EvaluationResult r : list){
  56. System.out.println(r+"\n");
  57. }
  58. }
  59. private static float seg(final String input, final String output, final Seg seg) throws Exception{
  60. float rate = 0;
  61. try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(input),"utf-8"));
  62. BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output),"utf-8"))){
  63. long size = Files.size(Paths.get(input));
  64. System.out.println("size:"+size);
  65. System.out.println("文件大小："+(float)size/1024/1024+" MB");
  66. int textLength=0;
  67. int progress=0;
  68. long start = System.currentTimeMillis();
  69. String line = null;
  70. while((line = reader.readLine()) != null){
  71. if("".equals(line.trim())){
  72. writer.write("\n");
  73. continue;
  74. }
  75. textLength += line.length();
  76. writer.write(seg(line, seg));
  77. writer.write("\n");
  78. progress += line.length();
  79. if( progress > 500000){
  80. progress = 0;
  81. System.out.println("分词进度："+(int)(textLength*2.99/size*100)+"%");
  82. }
  83. }
  84. long cost = System.currentTimeMillis() - start;
  85. rate = textLength/(float)cost;
  86. System.out.println("字符数目："+textLength);
  87. System.out.println("分词耗时："+cost+" 毫秒");
  88. System.out.println("分词速度："+rate+" 字符/毫秒");
  89. }
  90. return rate;
  91. }
  92. private static String seg(String text, Seg seg) throws IOException {
  93. StringBuilder result = new StringBuilder();
  94. MMSeg mmSeg = new MMSeg(new StringReader(text), seg);
  95. Word word = null;
  96. while((word=mmSeg.next())!=null) {
  97. result.append(word.getString()).append(" ");
  98. }
  99. return result.toString().trim();
  100. }
  101. /**
  102. * 分词效果评估
  103. * @param resultText 实际分词结果文件路径
  104. * @param standardText 标准分词结果文件路径
  105. * @return 评估结果
  106. */
  107. private static EvaluationResult evaluation(String resultText, String standardText) {
  108. int perfectLineCount=0;
  109. int wrongLineCount=0;
  110. int perfectCharCount=0;
  111. int wrongCharCount=0;
  112. try(BufferedReader resultReader = new BufferedReader(new InputStreamReader(new FileInputStream(resultText),"utf-8"));
  113. BufferedReader standardReader = new BufferedReader(new InputStreamReader(new FileInputStream(standardText),"utf-8"))){
  114. String result;
  115. while( (result = resultReader.readLine()) != null ){
  116. result = result.trim();
  117. String standard = standardReader.readLine().trim();
  118. if(result.equals("")){
  119. continue;
  120. }
  121. if(result.equals(standard)){
  122. //分词结果和标准一模一样
  123. perfectLineCount++;
  124. perfectCharCount+=standard.replaceAll("\\s+", "").length();
  125. }else{
  126. //分词结果和标准不一样
  127. wrongLineCount++;
  128. wrongCharCount+=standard.replaceAll("\\s+", "").length();
  129. }
  130. }
  131. } catch (IOException ex) {
  132. System.err.println("分词效果评估失败：" + ex.getMessage());
  133. }
  134. int totalLineCount = perfectLineCount+wrongLineCount;
  135. int totalCharCount = perfectCharCount+wrongCharCount;
  136. EvaluationResult er = new EvaluationResult();
  137. er.setPerfectCharCount(perfectCharCount);
  138. er.setPerfectLineCount(perfectLineCount);
  139. er.setTotalCharCount(totalCharCount);
  140. er.setTotalLineCount(totalLineCount);
  141. er.setWrongCharCount(wrongCharCount);
  142. er.setWrongLineCount(wrongLineCount);
  143. return er;
  144. }
  145. /**
  146. * 分词结果
  147. */
  148. private static class EvaluationResult implements Comparable{
  149. private String analyzer;
  150. private float segSpeed;
  151. private int totalLineCount;
  152. private int perfectLineCount;
  153. private int wrongLineCount;
  154. private int totalCharCount;
  155. private int perfectCharCount;
  156. private int wrongCharCount;
  157. public String getAnalyzer() {
  158. return analyzer;
  159. }
  160. public void setAnalyzer(String analyzer) {
  161. this.analyzer = analyzer;
  162. }
  163. public float getSegSpeed() {
  164. return segSpeed;
  165. }
  166. public void setSegSpeed(float segSpeed) {
  167. this.segSpeed = segSpeed;
  168. }
  169. public float getLinePerfectRate(){
  170. return perfectLineCount/(float)totalLineCount*100;
  171. }
  172. public float getLineWrongRate(){
  173. return wrongLineCount/(float)totalLineCount*100;
  174. }
  175. public float getCharPerfectRate(){
  176. return perfectCharCount/(float)totalCharCount*100;
  177. }
  178. public float getCharWrongRate(){
  179. return wrongCharCount/(float)totalCharCount*100;
  180. }
  181. public int getTotalLineCount() {
  182. return totalLineCount;
  183. }
  184. public void setTotalLineCount(int totalLineCount) {
  185. this.totalLineCount = totalLineCount;
  186. }
  187. public int getPerfectLineCount() {
  188. return perfectLineCount;
  189. }
  190. public void setPerfectLineCount(int perfectLineCount) {
  191. this.perfectLineCount = perfectLineCount;
  192. }
  193. public int getWrongLineCount() {
  194. return wrongLineCount;
  195. }
  196. public void setWrongLineCount(int wrongLineCount) {
  197. this.wrongLineCount = wrongLineCount;
  198. }
  199. public int getTotalCharCount() {
  200. return totalCharCount;
  201. }
  202. public void setTotalCharCount(int totalCharCount) {
  203. this.totalCharCount = totalCharCount;
  204. }
  205. public int getPerfectCharCount() {
  206. return perfectCharCount;
  207. }
  208. public void setPerfectCharCount(int perfectCharCount) {
  209. this.perfectCharCount = perfectCharCount;
  210. }
  211. public int getWrongCharCount() {
  212. return wrongCharCount;
  213. }
  214. public void setWrongCharCount(int wrongCharCount) {
  215. this.wrongCharCount = wrongCharCount;
  216. }
  217. @Override
  218. public String toString(){
  219. return analyzer+"："
  220. +"\n"
  221. +"分词速度："+segSpeed+" 字符/毫秒"
  222. +"\n"
  223. +"行数完美率："+getLinePerfectRate()+"%"
  224. +"  行数错误率："+getLineWrongRate()+"%"
  225. +"  总的行数："+totalLineCount
  226. +"  完美行数："+perfectLineCount
  227. +"  错误行数："+wrongLineCount
  228. +"\n"
  229. +"字数完美率："+getCharPerfectRate()+"%"
  230. +" 字数错误率："+getCharWrongRate()+"%"
  231. +" 总的字数："+totalCharCount
  232. +" 完美字数："+perfectCharCount
  233. +" 错误字数："+wrongCharCount;
  234. }
  235. @Override
  236. public int compareTo(Object o) {
  237. EvaluationResult other = (EvaluationResult)o;
  238. if(other.getLinePerfectRate() - getLinePerfectRate() > 0){
  239. return 1;
  240. }
  241. if(other.getLinePerfectRate() - getLinePerfectRate() < 0){
  242. return -1;
  243. }
  244. return 0;
  245. }
  246. }
  247. }

ik-analyzer2012_u6的评估结果如下：

Java代码  
  1. IKAnalyzer 智能切分：
  2. 分词速度：178.3516 字符/毫秒
  3. 行数完美率：37.55943%  行数错误率：62.440567%  总的行数：2533686  完美行数：951638  错误行数：1582048
  4. 字数完美率：27.978464% 字数错误率：72.02154% 总的字数：28374416 完美字数：7938726 错误字数：20435690
  5. IKAnalyzer 细粒度切分：
  6. 分词速度：182.97859 字符/毫秒
  7. 行数完美率：18.872742%  行数错误率：81.12726%  总的行数：2533686  完美行数：478176  错误行数：2055510
  8. 字数完美率：10.936535% 字数错误率：89.06347% 总的字数：28374416 完美字数：3103178 错误字数：25271238

ik-analyzer2012_u6分词评估程序如下：

Java代码  
  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.io.OutputStreamWriter;
  8. import java.io.StringReader;
  9. import java.nio.file.Files;
  10. import java.nio.file.Paths;
  11. import java.util.ArrayList;
  12. import java.util.Collections;
  13. import java.util.List;
  14. import org.wltea.analyzer.core.IKSegmenter;
  15. import org.wltea.analyzer.core.Lexeme;
  16. /**
  17. * IKAnalyzer分词器分词效果评估
  18. * @author 杨尚川
  19. */
  20. public class IKAnalyzerEvaluation {
  21. public static void main(String[] args) throws Exception{
  22. // 测试文件 d:/test-text.txt 和 标准分词结果文件 d:/standard-text.txt 的下载地址：
  23. // http://pan.baidu.com/s/1hqihzjY
  24. List<EvaluationResult> list = new ArrayList<>();
  25. // 对文本进行分词
  26. float rate = seg("d:/test-text.txt", "d:/result-text-ComplexSeg.txt", true);
  27. // 对分词结果进行评估
  28. EvaluationResult result = evaluation("d:/result-text-ComplexSeg.txt", "d:/standard-text.txt");
  29. result.setAnalyzer("IKAnalyzer 智能切分");
  30. result.setSegSpeed(rate);
  31. list.add(result);
  32. // 对文本进行分词
  33. rate = seg("d:/test-text.txt", "d:/result-text-SimpleSeg.txt", false);
  34. // 对分词结果进行评估
  35. result = evaluation("d:/result-text-SimpleSeg.txt", "d:/standard-text.txt");
  36. result.setAnalyzer("IKAnalyzer 细粒度切分");
  37. result.setSegSpeed(rate);
  38. list.add(result);
  39. //输出评估结果
  40. Collections.sort(list);
  41. System.out.println("");
  42. for(EvaluationResult r : list){
  43. System.out.println(r+"\n");
  44. }
  45. }
  46. private static float seg(final String input, final String output, final boolean useSmart) throws Exception{
  47. float rate = 0;
  48. try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(input),"utf-8"));
  49. BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output),"utf-8"))){
  50. long size = Files.size(Paths.get(input));
  51. System.out.println("size:"+size);
  52. System.out.println("文件大小："+(float)size/1024/1024+" MB");
  53. int textLength=0;
  54. int progress=0;
  55. long start = System.currentTimeMillis();
  56. String line = null;
  57. while((line = reader.readLine()) != null){
  58. if("".equals(line.trim())){
  59. writer.write("\n");
  60. continue;
  61. }
  62. textLength += line.length();
  63. writer.write(seg(line, useSmart));
  64. writer.write("\n");
  65. progress += line.length();
  66. if( progress > 500000){
  67. progress = 0;
  68. System.out.println("分词进度："+(int)(textLength*2.99/size*100)+"%");
  69. }
  70. }
  71. long cost = System.currentTimeMillis() - start;
  72. rate = textLength/(float)cost;
  73. System.out.println("字符数目："+textLength);
  74. System.out.println("分词耗时："+cost+" 毫秒");
  75. System.out.println("分词速度："+rate+" 字符/毫秒");
  76. }
  77. return rate;
  78. }
  79. private static String seg(String text, boolean useSmart) throws IOException {
  80. StringBuilder result = new StringBuilder();
  81. IKSegmenter ik = new IKSegmenter(new StringReader(text), useSmart);
  82. Lexeme word = null;
  83. while((word=ik.next())!=null) {
  84. result.append(word.getLexemeText()).append(" ");
  85. }
  86. return result.toString().trim();
  87. }
  88. /**
  89. * 分词效果评估
  90. * @param resultText 实际分词结果文件路径
  91. * @param standardText 标准分词结果文件路径
  92. * @return 评估结果
  93. */
  94. private static EvaluationResult evaluation(String resultText, String standardText) {
  95. int perfectLineCount=0;
  96. int wrongLineCount=0;
  97. int perfectCharCount=0;
  98. int wrongCharCount=0;
  99. try(BufferedReader resultReader = new BufferedReader(new InputStreamReader(new FileInputStream(resultText),"utf-8"));
  100. BufferedReader standardReader = new BufferedReader(new InputStreamReader(new FileInputStream(standardText),"utf-8"))){
  101. String result;
  102. while( (result = resultReader.readLine()) != null ){
  103. result = result.trim();
  104. String standard = standardReader.readLine().trim();
  105. if(result.equals("")){
  106. continue;
  107. }
  108. if(result.equals(standard)){
  109. //分词结果和标准一模一样
  110. perfectLineCount++;
  111. perfectCharCount+=standard.replaceAll("\\s+", "").length();
  112. }else{
  113. //分词结果和标准不一样
  114. wrongLineCount++;
  115. wrongCharCount+=standard.replaceAll("\\s+", "").length();
  116. }
  117. }
  118. } catch (IOException ex) {
  119. System.err.println("分词效果评估失败：" + ex.getMessage());
  120. }
  121. int totalLineCount = perfectLineCount+wrongLineCount;
  122. int totalCharCount = perfectCharCount+wrongCharCount;
  123. EvaluationResult er = new EvaluationResult();
  124. er.setPerfectCharCount(perfectCharCount);
  125. er.setPerfectLineCount(perfectLineCount);
  126. er.setTotalCharCount(totalCharCount);
  127. er.setTotalLineCount(totalLineCount);
  128. er.setWrongCharCount(wrongCharCount);
  129. er.setWrongLineCount(wrongLineCount);
  130. return er;
  131. }
  132. /**
  133. * 分词结果
  134. */
  135. private static class EvaluationResult implements Comparable{
  136. private String analyzer;
  137. private float segSpeed;
  138. private int totalLineCount;
  139. private int perfectLineCount;
  140. private int wrongLineCount;
  141. private int totalCharCount;
  142. private int perfectCharCount;
  143. private int wrongCharCount;
  144. public String getAnalyzer() {
  145. return analyzer;
  146. }
  147. public void setAnalyzer(String analyzer) {
  148. this.analyzer = analyzer;
  149. }
  150. public float getSegSpeed() {
  151. return segSpeed;
  152. }
  153. public void setSegSpeed(float segSpeed) {
  154. this.segSpeed = segSpeed;
  155. }
  156. public float getLinePerfectRate(){
  157. return perfectLineCount/(float)totalLineCount*100;
  158. }
  159. public float getLineWrongRate(){
  160. return wrongLineCount/(float)totalLineCount*100;
  161. }
  162. public float getCharPerfectRate(){
  163. return perfectCharCount/(float)totalCharCount*100;
  164. }
  165. public float getCharWrongRate(){
  166. return wrongCharCount/(float)totalCharCount*100;
  167. }
  168. public int getTotalLineCount() {
  169. return totalLineCount;
  170. }
  171. public void setTotalLineCount(int totalLineCount) {
  172. this.totalLineCount = totalLineCount;
  173. }
  174. public int getPerfectLineCount() {
  175. return perfectLineCount;
  176. }
  177. public void setPerfectLineCount(int perfectLineCount) {
  178. this.perfectLineCount = perfectLineCount;
  179. }
  180. public int getWrongLineCount() {
  181. return wrongLineCount;
  182. }
  183. public void setWrongLineCount(int wrongLineCount) {
  184. this.wrongLineCount = wrongLineCount;
  185. }
  186. public int getTotalCharCount() {
  187. return totalCharCount;
  188. }
  189. public void setTotalCharCount(int totalCharCount) {
  190. this.totalCharCount = totalCharCount;
  191. }
  192. public int getPerfectCharCount() {
  193. return perfectCharCount;
  194. }
  195. public void setPerfectCharCount(int perfectCharCount) {
  196. this.perfectCharCount = perfectCharCount;
  197. }
  198. public int getWrongCharCount() {
  199. return wrongCharCount;
  200. }
  201. public void setWrongCharCount(int wrongCharCount) {
  202. this.wrongCharCount = wrongCharCount;
  203. }
  204. @Override
  205. public String toString(){
  206. return analyzer+"："
  207. +"\n"
  208. +"分词速度："+segSpeed+" 字符/毫秒"
  209. +"\n"
  210. +"行数完美率："+getLinePerfectRate()+"%"
  211. +"  行数错误率："+getLineWrongRate()+"%"
  212. +"  总的行数："+totalLineCount
  213. +"  完美行数："+perfectLineCount
  214. +"  错误行数："+wrongLineCount
  215. +"\n"
  216. +"字数完美率："+getCharPerfectRate()+"%"
  217. +" 字数错误率："+getCharWrongRate()+"%"
  218. +" 总的字数："+totalCharCount
  219. +" 完美字数："+perfectCharCount
  220. +" 错误字数："+wrongCharCount;
  221. }
  222. @Override
  223. public int compareTo(Object o) {
  224. EvaluationResult other = (EvaluationResult)o;
  225. if(other.getLinePerfectRate() - getLinePerfectRate() > 0){
  226. return 1;
  227. }
  228. if(other.getLinePerfectRate() - getLinePerfectRate() < 0){
  229. return -1;
  230. }
  231. return 0;
  232. }
  233. }
  234. }

ansj、mmseg4j和ik-analyzer的评估程序可在附件中下载，word分词只需运行项目根目录下的evaluation.bat脚本即可。

参考资料：

1、word分词器分词效果评估测试数据集和标准数据集

2、word分词器评估程序

3、word分词器主页

4、ansj分词器主页

5、mmseg4j分词器主页

6、ik-analyzer分词器主页

word分词器、ansj分词器、mmseg4j分词器、ik-analyzer分词器分词效果评估（转）相关推荐

  1. java Analyzer_Java实现使用IK Analyzer实现中文分词

    lucene-core-3.6.0.jar 什么都不用改 示例代码如下(使用IK Analyzer): [java] view plaincopy package com.haha.test; imp ...

  2. word分词器、ansj分词器、mmseg4j分词器、ik-analyzer分词器分词效果评估

    2019独角兽企业重金招聘Python工程师标准>>> word分词是一个Java实现的中文分词组件,提供了多种基于词典的分词算法,并利用ngram模型来消除歧义. 能准确识别英文. ...

  3. Java 开源中文分词器Ansj 学习教程

    Java有11大开源中文分词器,分别是word分词器,Ansj分词器,Stanford分词器,FudanNLP分词器,Jieba分词器,Jcseg分词器,MMSeg4j分词器,IKAnalyzer分词 ...

  4. JAVA开源中文分词器Ansj(依赖注入+调用方式+停词器)

    Java有11大开源中文分词器,分别是word分词器,Ansj分词器,Stanford分词器,FudanNLP分词器,Jieba分词器,Jcseg分词器,MMSeg4j分词器,IKAnalyzer分词 ...

  5. 如何在基于Lucene的中文分词器中添加自定义词典（如Paoding、mmseg4j、IK Analyzer）...

    如何在基于Lucene的中文分词器中添加自定义词典(如Paoding.mmseg4j.IK Analyzer) 2013-07-08 21:54:29|  分类: 计算机 |字号 订阅 1. 使用Pa ...

  6. 开源 Java 中文分词器 Ansj 作者孙健专访

    Ansj 是一个开源的 Java 中文分词工具,基于中科院的 ictclas 中文分词算法,比其他常用的开源分词工具(如mmseg4j)的分词准确率更高. 在线演示: http://ansj.sdap ...

  7. 公司开源的java分词,Java开源项目cws_evaluation：中文分词器分词效果评估

    通过对前文<word分词器.ansj分词器.mmseg4j分词器.ik-analyzer分词器分词效果评估>中写的评估程序进行重构改进,形成了一个新的Java开源项目cws_evaluat ...

  8. Elasticsearch Analyzer 内置分词器

    Elasticsearch Analyzer 内置分词器 篇主要介绍一下 Elasticsearch中 Analyzer 分词器的构成 和一些Es中内置的分词器 以及如何使用它们 前置知识 es 提供 ...

  9. 采访IK Analyzer 中文分词器开源项目作者林良益（十三）

    转自: http://www.iteye.com/magazines/43-ik-analyzer 众所周知,全文搜索几乎已经成为每个网站的必须提供的基本功能之一,用Lucene构造一个"索 ...

最新文章

  1. 向量时钟算法简介——本质类似MVCC
  2. Android locksettings/gatekeeper代码导读
  3. 深入理解 Java 泛型擦除机制
  4. tf.contrib.slim arg_scope
  5. 语句 查询每个人每个科目的最高分_转行数据分析师专栏（SQL篇）-05多表查询...
  6. 传统IDC为什么要上云计算平台篇之一
  7. python解决urllib发送请求报错：urllib.error.URLError: ＜urlopen error [SSL: CERTIFICATE_VERIFY_FAILED].....＞
  8. 利用IO多路复用，使用linux下的EpollSelector实现并发服务器
  9. 福建省12.5米DEM数字高程数据
  10. 什么是DMZ区域，DMZ区域的作用与原理
  11. Wework的线上社交，能否支撑其169亿估值？
  12. 可充电电池安规认证标准、GB 9706.1-2020对医用电气设备中电池的要求
  13. 自适应业务提供的NGN业务体系结构项目调研论文（Draft1）
  14. 四舍五入VS银行家舍入 (四舍六入五取偶)
  15. ​一文了解ICP备案
  16. uniapp仿微信--聊天界面模板
  17. 如何在网页上添加支付宝链接
  18. freeSWITCH detect_speech源码分析
  19. android 家长控制app下载,任天堂家长控制app下载-任天堂家长控制 安卓版v1.0.2-PC6安卓网...
  20. 你为什么还没有好工作？（转载）

热门文章

  1. 【hihocoder1082】然而沼跃鱼早就看穿了一切——字符串
  2. linux内核snat分析,Linux2.6.29.6内核netfilter代码中SNAT的过程跟踪
  3. Java开源企业信息化平台O2OA服务器架构示意图
  4. 千亿级金融场景下，基于Pulsar的云原生消息队列有怎样的表现？
  5. 穷游第13国之韩国囧途之旅
  6. uniapp将聊天页面定位始终定位到最底部展示
  7. button标签和input的button
  8. C语言学习笔记（九）
  9. MxCAD5.2 2017.2.23更新
  10. 多模态的研究现状与应用场景的调查研究