先放上一张Demo的测试图

  • 测试的句子及每个分词的词性标注为：   目前/t 这/rzv 条/q 高速公路/n 之间/f 的/ude1 路段/n 已/d 紧急/a 封闭/v 。/w

需要基础知识

  • HMM模型（隐马尔可夫模型）
  • 模型的定义

隐马尔科夫模型（hidden Markov model）是关于时序的概率模型，是最简单的动态贝叶斯网络

  • 模型的参数

HMM模型由Pi、A、B 唯一决定   Pi、A、B 成为HMM模型的三要素

  • HMM用在词性标注问题
  • 对于下面这句话可以用HMM进行建模

目前/t 这/rzv 条/q 高速公路/n 之间/f 的/ude1 路段/n 已/d 紧急/a 封闭/v 。/w

因此  可以通过训练语料来根据词性以及分词还有两者之间的关系进行统计获得三种概率

  • 维特比算法
  • 在给定已知分词的句子时如何进行词性标注呢

这就是HMM模型中的预测问题

此时采用维特比算法

注：对维特比算法的举例理解

a b c d 表示的是四种状态

1 2 3 是三个观测时间节点

在t=3的时刻要计算到达此时的4种状态的所有路径，例如，到达a状态的有从t=1，t=2的4*4=16种情况，要找到概率最大的一条路径记录下来；对于其他的状态点也是这样计算下去保存最优路径。

算法中步骤3中的式子表示两个时刻的距离，每次记录的是根据之间的概率最大记住前一时刻的某一状态。

整个工程的流程

详细内容（含源代码）

  • 语料情况

  • 语料划分

取前面约80%作为train语料     后面约20%作为测试语料

  • 创建分词表和中文词性表
  1. public class DoIt {
  2.     List<String> wordlist;
  3.     List<String> labellist;
  4.  
  5.     public DoIt() {
  6.         wordlist = new ArrayList<String>();
  7.         labellist = new ArrayList<String>();
  8.     }
  9.  
  10.     public int[] creatlist(String train) throws IOException{
  11.         System.out.println("----- 创建List -----");
  12.         System.out.println(".......... . .  .");
  13.         File file = new File(train);
  14.         int[] twonum = new int[2];
  15.         if(!file.exists()) {
  16.             throw new IOException(file + "不存在！！！");
  17.         }
  18.         if(!file.isFile()) {
  19.             throw new IOException(file + "不是文件！！！");
  20.         }
  21.         BufferedReader br = new BufferedReader(
  22.                 new InputStreamReader(
  23.                         new FileInputStream(file)));
  24.         String str = null;
  25.         while((str = br.readLine()) != null) {
  26.             String[] strarray = str.split(" ");
  27.             for (String substr: strarray) {
  28.                 String[] tempstr = substr.split("/");
  29.                 if (tempstr.length == 2) {
  30.                     String word = tempstr[0];
  31.                     String label = tempstr[1];
  32.                     if(!wordlist.contains(word)) {
  33.                         wordlist.add(word);
  34.                     }
  35.                     if(!labellist.contains(label)) {
  36.                         labellist.add(label);
  37.                     }
  38.                 }
  39.             }
  40.         }
  41.         br.close();
  42.         twonum[0] = wordlist.size();
  43.         twonum[1] = labellist.size();
  44.         listtodocument(labellist, "labellist.dat");     //写文件
  45.         listtodocument(wordlist, "wordlist.dat");
  46.         System.out.println("----- 创建List完成 -----");
  47.  
  48.         return twonum;
  49.     }
  50.  
  51.     //list 写到 文件
  52.     public void listtodocument(List<String> list, String filename) throws IOException{
  53.         PrintWriter pw = new PrintWriter(filename);
  54.         for (String string: list) {
  55.             pw.print(string + " ");
  56.         }
  57.         pw.flush();
  58.         pw.close();
  59.     }
  60. }
  • 训练  得到模型的关键三个关键参数
  1. public class DoIt {
  2.     List<String> wordlist;
  3.     List<String> labellist;
  4.  
  5.     public DoIt() {
  6.         wordlist = new ArrayList<String>();
  7.         labellist = new ArrayList<String>();
  8.     }
  9.  
  10.     public void learn(String train, String model, int[] twonum) throws IOException{
  11.  
  12.         System.out.println("----- 开始训练 -----");
  13.         //System.out.println(twonum[0] +"---------" + twonum[1]);
  14.         int wordnum = twonum[0];
  15.         int labelnum = twonum[1];
  16.         double[] pi = new double[labelnum];
  17.         double[][] A = new double[labelnum][labelnum];
  18.         double[][] B = new double[labelnum][wordnum];
  19.         for (int i = 0; i < labelnum; i++) {
  20.             pi[i] = 1;
  21.             for (int j = 0; j < labelnum; j++) {
  22.                 A[i][j] = 1;
  23.             }
  24.             for (int k = 0; k < wordnum; k++) {
  25.                 B[i][k] = 1;
  26.             }
  27.         }
  28.         File file = new File(train);
  29.         if(!file.exists()) {
  30.             throw new IOException(file + "不存在！！！");
  31.         }
  32.         if(!file.isFile()) {
  33.             throw new IOException(file + "不是文件！！！");
  34.         }
  35.         BufferedReader br = new BufferedReader(
  36.                 new InputStreamReader(
  37.                         new FileInputStream(file)));
  38.         PrintWriter pw = new PrintWriter(model);
  39.         String str = null;
  40.         int frontindex = -1;
  41.         int rowpi = 0;
  42.         while((str = br.readLine()) != null) {
  43.             rowpi ++;
  44.             System.out.println("--learn读取到文件的行号： " + rowpi);
  45.             String[] strarray = str.split(" ");
  46.             for (String substr: strarray) {
  47.                 String[] tempstr = substr.split("/");
  48.                 if (tempstr.length == 2) {
  49.                     String word = tempstr[0];
  50.                     String label = tempstr[1];
  51.                     int wordindex = wordlist.indexOf(word);
  52.                     int labelindex = labellist.indexOf(label);
  53.                     B[labelindex][wordindex] += 1;
  54.                     if (frontindex != -1) {
  55.                         A[frontindex][labelindex] += 1;
  56.                     }
  57.                     frontindex = labelindex;
  58.                 }
  59.             }
  60.             String firstlabel = strarray[0].split("/")[1];
  61.             int firstlabelindex = labellist.indexOf(firstlabel);
  62.            // System.out.println(firstlabel);
  63.             pi[firstlabelindex] += 1;
  64.  
  65.         }
  66.         System.out.println("----- 写参数到model -----");
  67.         //计算概率   写入model文件
  68.         int factor = 1000;
  69.         pw.println(3);
  70.         pw.println(4);
  71.         pw.println(labelnum + 4);
  72.         for (int i = 0; i < labelnum; i++) {
  73.             pw.print(factor * pi[i] / rowpi + " ");
  74.         }
  75.         pw.println();
  76.         double rowsumA = 0;
  77.         //pw.println("A");
  78.         for (int i = 0; i < labelnum; i++) {
  79.  
  80.             for (int j = 0; j < labelnum; j++) {
  81.                 rowsumA += A[i][j];
  82.             }
  83.             for (int j = 0; j < labelnum; j++) {
  84.                 pw.print(factor * A[i][j] / rowsumA + " ");
  85.             }
  86.             rowsumA = 0;
  87.             pw.println();
  88.         }
  89.         double rowsumB = 0;
  90.         //pw.println("B");
  91.         for (int i = 0; i < labelnum; i++) {
  92.             for (int k = 0; k < wordnum; k++) {
  93.                 rowsumB += B[i][k];
  94.             }
  95.             for (int k = 0; k < wordnum; k++) {
  96.                 pw.print(factor * B[i][k] / rowsumB + " ");
  97.             }
  98.             rowsumB = 0;
  99.             pw.println();
  100.         }
  101.         pw.flush();
  102.         br.close();
  103.         pw.close();
  104.         System.out.println("--- 文件写入完毕 训练完成 ---");
  105.     }
  106.  
  107.     //训练  写 参数 到model文件中
  108.     public void tomodel(String allfile, String train, String model) throws IOException{
  109.         //int[] twonum = creatlist(train);
  110.  
  111.         int[] twonum = creatlist(allfile);
  112.         learn(train, model, twonum);
  113.  
  114.     }
  115.  
  116.     //训练的入口
  117.     public void pleaselearn(String filename) throws IOException{
  118.         double start = System.currentTimeMillis();
  119.  
  120.         String train = filename;
  121.         String model = "model.dat";
  122.         String allfile = "dataa.dat";
  123.         tomodel(allfile, train, model);
  124.  
  125.         double end = System.currentTimeMillis();
  126.         System.out.println("训练用时(s)： " + (end - start) / 1000);
  127.     }
  128.  
  129. }
  • 测试   读入模型的参数和测试文本进行译码操作  并将结果与源测试文件的内容以行为单位写入结果
  1. public class tDoIt {
  2.     List<String> wordlist;
  3.     List<String> labellist;
  4.  
  5.     public tDoIt() {
  6.         wordlist = new ArrayList<String>();
  7.         labellist = new ArrayList<String>();
  8.     }
  9.  
  10.     //进行测试
  11.     public void test(String model, String test, String result) throws IOException{
  12.         System.out.println("----- 开始测试 -----");
  13.         String[] wordd = readdocument("wordlist.dat");
  14.         for (String stri: wordd) {
  15.             wordlist.add(stri);
  16.         }
  17.  
  18.         String[] label = readdocument("labellist.dat");
  19.         for (String strii: label) {
  20.             labellist.add(strii);
  21.         }
  22.  
  23.         File filemodel = new File(model);
  24.         File filetest = new File(test);
  25.         if(!filemodel.exists()) {
  26.             throw new IOException(filemodel + "不存在！！！");
  27.         }
  28.         if(!filemodel.isFile()) {
  29.             throw new IOException(filemodel + "不是文件！！！");
  30.         }
  31.         if(!filetest.exists()) {
  32.             throw new IOException(filetest + "不存在！！！");
  33.         }
  34.         if(!filetest.isFile()) {
  35.             throw new IOException(filetest + "不是文件！！！");
  36.         }
  37.         BufferedReader brmodel = new BufferedReader(
  38.                 new InputStreamReader(
  39.                         new FileInputStream(filemodel)));
  40.         BufferedReader brtest = new BufferedReader(
  41.                 new InputStreamReader(
  42.                         new FileInputStream(filetest)));
  43.         String[] rowpi = null;
  44.         String[] rowA = null;
  45.         String[] rowB = null;
  46.         String strmodel = null;
  47.         int rownumpi = tempreadfile(filemodel)[0];
  48.         int rownumA = tempreadfile(filemodel)[1];
  49.         int rownumB  = tempreadfile(filemodel)[2];
  50.         double[] pi = new double[rownumB - rownumA];
  51.         double[][] A = new double[rownumB - rownumA][];
  52.         double[][] B = new double[rownumB - rownumA][];
  53.         int j = 0, k = 0;
  54.         for (int i = 0; (strmodel = brmodel.readLine()) != null; i++) {
  55.             if(i >= rownumpi && i < rownumA) {
  56.                 rowpi = strmodel.split(" ");
  57.                 pi = strtodouble(rowpi);
  58.             }else if (i >= rownumA && i < rownumB) {
  59.                 rowA = strmodel.split(" ");
  60.                 A[j++] = strtodouble(rowA);
  61.             }else if(i >= rownumB){
  62.                 rowB = strmodel.split(" ");
  63.                 B[k++] = strtodouble(rowB);
  64.             }
  65.  
  66.         }
  67.  
  68.         StringBuilder strbd;
  69.         PrintWriter pw = new PrintWriter(result);
  70.         String teststr = null;
  71.         int row = 1;
  72.         while((teststr = brtest.readLine()) != null) {
  73.             pw.println(teststr);
  74.             System.out.println("--test读取到文件的行号： " + row++);
  75.  
  76.             String[] strarray = teststr.split(" ");
  77.             strbd = new StringBuilder();
  78.             for (String substr: strarray) {
  79.                 String[] tempstr = substr.split("/");
  80.                 if (tempstr.length == 2) {
  81.                     String word = tempstr[0];
  82.                     strbd.append(word + " ");
  83.                 }
  84.             }
  85.  
  86.             int[] labelindex = viterbi(strbd.toString(), pi, A, B);
  87.             String[] strwords = strbd.toString().split(" ");
  88.  
  89.             for (int i = 0; i < labelindex.length; i++) {
  90.                 pw.print(strwords[i] + "/" + labellist.get(labelindex[i]) + " ");
  91.             }
  92.  
  93.             pw.println();
  94.  
  95.         }
  96.         pw.flush();
  97.         brmodel.close();
  98.         brtest.close();
  99.         pw.close();
  100.     }
  101.  
  102.     // viterbi
  103.     public int[] viterbi(String string, double[] pi, double[][] A, double[][] B) throws IOException{
  104.  
  105.         String[] words = string.split(" ");
  106.         double[][] delta = new double[words.length][pi.length];
  107.         int[][] way = new int[words.length][pi.length];
  108.         int[] labelindex = new int[words.length];
  109.         for (int i = 0; i < pi.length; i++) {
  110.             delta[0][i] = pi[i] * B[i][wordlist.indexOf(words[0])];
  111.         }
  112.         for (int t = 1; t < words.length; t++) {
  113.             for (int i = 0; i < pi.length; i++) {
  114.                 for (int j = 0; j < pi.length; j++) {
  115.                     if(delta[t][i] < delta[t-1][j] * A[j][i] * B[i][wordlist.indexOf(words[t])]) {
  116.                         delta[t][i] = delta[t-1][j] * A[j][i] * B[i][wordlist.indexOf(words[t])];
  117.                         way[t][i] = j;
  118.                     }
  119.                 }
  120.             }
  121.         }
  122.         double max = delta[words.length - 1][0];
  123.         labelindex[words.length - 1] = 0;
  124.         for (int i = 0; i < pi.length; i++) {
  125.             if (delta[words.length - 1][i] > max) {
  126.                 max = delta[words.length - 1][i];
  127.                 labelindex[words.length - 1] = i;
  128.             }
  129.         }
  130.         for (int t = words.length - 2; t >= 0; t--) {
  131.             labelindex[t] = way[t + 1][labelindex[t + 1]];
  132.         }
  133.         return labelindex;
  134.  
  135.     }
  136.  
  137.     // 读文件到数组
  138.     public String[] readdocument(String filename) throws IOException{
  139.         BufferedReader br = new BufferedReader(
  140.                 new InputStreamReader(
  141.                         new FileInputStream(filename)));
  142.         String[] strarray = br.readLine().split(" ");
  143.         br.close();
  144.         return strarray;
  145.  
  146.     }
  147.     //读取文件前的三个参数
  148.     public int[] tempreadfile(File file) throws IOException {
  149.         int[] threenum = new int[3];
  150.         BufferedReader br = new BufferedReader(
  151.                 new InputStreamReader(
  152.                         new FileInputStream(file)));
  153.         int i = 0;
  154.         String str;
  155.         while((str = br.readLine()) != null) {
  156.             if(i > 2) {
  157.                 break;
  158.             }
  159.             threenum[i++] = Integer.parseInt(str);
  160.         }
  161.         br.close();
  162.         return threenum;
  163.     }
  164.  
  165.     //转String 为 double类型
  166.     public double[] strtodouble(String[] strarray) {
  167.         double[] dbs = new double[strarray.length];
  168.         for (int i = 0; i < strarray.length; i++) {
  169.             dbs[i] = Double.valueOf(strarray[i]);
  170.         }
  171.         return dbs;
  172.     }
  173.  
  174.     //测试的入口
  175.     public void pleasetest(String filename, String resultname) throws IOException{
  176.         double start = System.currentTimeMillis();
  177.  
  178.         String test = filename;
  179.         String model = "model.dat";
  180.         String result = resultname;
  181.         test(model, test, result);
  182.  
  183.         double end = System.currentTimeMillis();
  184.         System.out.println("测试用时(min)： " + (end - start) / 1000 / 60);
  185.     }
  186.  
  187. }
  • 得到result.dat文件  格式如下

  • 进行评估  读入结果文件  统计 分词个数与正确标注的分词个数  求解准确率  输出结果
  1. public class eDoIt {
  2.     public void evaluation(String filename) throws IOException{
  3.  
  4.         File file = new File(filename);
  5.         if (!file.exists()) {
  6.             throw new IOException(file + "不存在！！！");
  7.         }
  8.         if (!file.isFile()) {
  9.             throw new IOException(file + "不是文件");
  10.         }
  11.         BufferedReader br = new BufferedReader(
  12.                 new InputStreamReader(
  13.                         new FileInputStream(file)));
  14.         int sum = 0;
  15.         int correct = 0;
  16.         String str;
  17.         String[] strarray;
  18.         int flag = -1;
  19.         int k = 1;
  20.         while(true) {
  21.             str = null;
  22.             strarray = new String[2];
  23.             for (int i = 0; i < 2; i++) {
  24.                 str = br.readLine();
  25.                 if (str != null) {
  26.                     strarray[i] = str;
  27.                 }else {
  28.                     flag = 1;
  29.                     break;
  30.                 }
  31.             }
  32.             if (flag > 0)
  33.                 break;
  34.             String[] temp1 = strarray[1].split(" ");
  35.             String[] temp2 = strarray[0].split(" ");
  36.             for (int i = 0; i < temp1.length; i++) {
  37.                 if (temp1[i].split("/").length == 2 && temp2[i].split("/").length == 2){
  38.                     sum++;
  39.                     String[] str1 = temp1[i].split("/");
  40.                     String[] str2 = temp2[i].split("/");
  41.                     if (str1[1].equals(str2[1])) {
  42.                         correct++;
  43.                 }
  44.                 }
  45.  
  46.             }
  47.         }
  48.         double accuracy = 100.0 * correct / sum;
  49.  
  50.         System.out.println("总单词的个数：" + sum +  "\n正确标注的单词个数：" + correct);
  51.         System.out.println("准确率为：" + accuracy + "%");
  52.  
  53.         br.close();
  54.  
  55.     }
  56. }
  • 评估结果如下

  • 采用训练好的模型参数写一个进行词性标注的交互Demo
  1. public class dDoIt {
  2.  
  3.     List<String> wordlist;
  4.     List<String> labellist;
  5.  
  6.     public dDoIt() {
  7.         wordlist = new ArrayList<String>();
  8.         labellist = new ArrayList<String>();
  9.     }
  10.  
  11.     //进行decode
  12.     public void decode(String model) throws Exception{
  13.         Scanner console;
  14.         System.out.println("[MADE BY XINGLICHAO]");
  15.         System.out.println("词性标注系统加载中...");
  16.         System.out.println("------------------------------------");
  17.  
  18.         String[] wordd = readdocument("wordlist.dat");
  19.         for (String stri: wordd) {
  20.             wordlist.add(stri);
  21.         }
  22.  
  23.         String[] label = readdocument("labellist.dat");
  24.         for (String strii: label) {
  25.             labellist.add(strii);
  26.         }
  27.  
  28.         File filemodel = new File(model);
  29.  
  30.         if(!filemodel.exists()) {
  31.             throw new IOException(filemodel + "不存在！！！");
  32.         }
  33.         if(!filemodel.isFile()) {
  34.             throw new IOException(filemodel + "不是文件！！！");
  35.         }
  36.  
  37.         BufferedReader brmodel = new BufferedReader(
  38.                 new InputStreamReader(
  39.                         new FileInputStream(filemodel)));
  40.  
  41.         String[] rowpi = null;
  42.         String[] rowA = null;
  43.         String[] rowB = null;
  44.         String strmodel = null;
  45.         int rownumpi = tempreadfile(filemodel)[0];
  46.         int rownumA = tempreadfile(filemodel)[1];
  47.         int rownumB  = tempreadfile(filemodel)[2];
  48.  
  49.         double[] pi = new double[rownumB - rownumA];
  50.         double[][] A = new double[rownumB - rownumA][];
  51.         double[][] B = new double[rownumB - rownumA][];
  52.         int j = 0, k = 0;
  53.         for (int i = 0; (strmodel = brmodel.readLine()) != null; i++) {
  54.             if(i >= rownumpi && i < rownumA) {
  55.                 rowpi = strmodel.split(" ");
  56.                 pi = strtodouble(rowpi);
  57.             }else if (i >= rownumA && i < rownumB) {
  58.                 rowA = strmodel.split(" ");
  59.                 A[j++] = strtodouble(rowA);
  60.             }else if(i >= rownumB){
  61.                 rowB = strmodel.split(" ");
  62.                 B[k++] = strtodouble(rowB);
  63.             }
  64.  
  65.         }
  66.  
  67.         while(true) {
  68.             System.out.println("依次输入句子的各个分词并以空格分离：");
  69.             System.out.println("[结束使用 请按  0 ]");
  70.             System.out.println("------------------------------------");
  71.             console = new Scanner(System.in);
  72.             try {
  73.                 String str = console.nextLine();
  74.                 if (str.equals("0")) {
  75.                     brmodel.close();
  76.                     console.close();
  77.                     System.out.println();
  78.                     System.out.println("应用结束...");
  79.                     System.exit(0);
  80.                 }
  81.                 long start = System.currentTimeMillis();
  82.                 int[] labelindex = viterbi(str, pi, A, B);
  83.                 String[] strwords = str.split(" ");
  84.                 System.out.println();
  85.                 System.out.println("------------------------------------");
  86.                 System.out.println("标注结果：");
  87.                 for (int i = 0; i < labelindex.length; i++) {
  88.                     System.out.print(strwords[i] + "/" + labellist.get(labelindex[i]) + " ");
  89.  
  90.                 }
  91.                 System.out.println();
  92.                 long end = System.currentTimeMillis();
  93.                 System.out.println("\n[本次标注用时 " + (end-start) + " ms]");
  94.                 System.out.println("------------------------------------");
  95.  
  96.             }catch(Exception e) {
  97.                 System.out.println("\n你的分词超出了我的能力范围!!");
  98.                 System.out.println("------------------------------------");
  99.             }
  100.         }
  101.     }
  102.  
  103.     // viterbi
  104.     public int[] viterbi(String string, double[] pi, double[][] A, double[][] B) throws IOException{
  105.  
  106.         String[] words = string.split(" ");
  107.         double[][] delta = new double[words.length][pi.length];
  108.         int[][] way = new int[words.length][pi.length];
  109.         int[] labelindex = new int[words.length];
  110.  
  111.         for (int i = 0; i < pi.length; i++) {
  112.             delta[0][i] = pi[i] * B[i][wordlist.indexOf(words[0])];
  113.         }
  114.         for (int t = 1; t < words.length; t++) {
  115.             for (int i = 0; i < pi.length; i++) {
  116.                 for (int j = 0; j < pi.length; j++) {
  117.                     if(delta[t][i] < delta[t-1][j] * A[j][i] * B[i][wordlist.indexOf(words[t])]) {
  118.                         delta[t][i] = delta[t-1][j] * A[j][i] * B[i][wordlist.indexOf(words[t])];
  119.                         way[t][i] = j;
  120.                     }
  121.                 }
  122.             }
  123.         }
  124.         double max = delta[words.length - 1][0];
  125.         labelindex[words.length - 1] = 0;
  126.         for (int i = 0; i < pi.length; i++) {
  127.             if (delta[words.length - 1][i] > max) {
  128.                 max = delta[words.length - 1][i];
  129.                 labelindex[words.length - 1] = i;
  130.             }
  131.         }
  132.         for (int t = words.length - 2; t >= 0; t--) {
  133.             labelindex[t] = way[t + 1][labelindex[t + 1]];
  134.         }
  135.         return labelindex;
  136.     }
  137.  
  138.     // 读文件到数组
  139.     public String[] readdocument(String filename) throws IOException{
  140.         BufferedReader br = new BufferedReader(
  141.                 new InputStreamReader(
  142.                         new FileInputStream(filename)));
  143.         String[] strarray = br.readLine().split(" ");
  144.         br.close();
  145.         return strarray;
  146.  
  147.     }
  148.     //读取文件前的三个参数
  149.     public int[] tempreadfile(File file) throws IOException {
  150.         int[] threenum = new int[3];
  151.         BufferedReader br = new BufferedReader(
  152.                 new InputStreamReader(
  153.                         new FileInputStream(file)));
  154.         int i = 0;
  155.         String str;
  156.         while((str = br.readLine()) != null) {
  157.             if(i > 2) {
  158.                 break;
  159.             }
  160.             threenum[i++] = Integer.parseInt(str);
  161.         }
  162.         br.close();
  163.         return threenum;
  164.     }
  165.  
  166.     //转String 为 double类型
  167.     public double[] strtodouble(String[] strarray) {
  168.         double[] dbs = new double[strarray.length];
  169.         for (int i = 0; i < strarray.length; i++) {
  170.             dbs[i] = Double.valueOf(strarray[i]);
  171.         }
  172.         return dbs;
  173.     }
  174.  
  175. }
  • 续..........

在进行test时   标注的速度慢   由于数据较大   一次进行读取测试  时间花费太长  所以 想到将文件按行切分成多个文件  分别进行测试   最后 再将得到的结果小文件   整合成一个大文件用于评估

按行切分文件 与 合并文件  点这里

Github：https://github.com/xinglicha0/Chinese-word-tagging-system-based-on-Hmm

自然语言处理---用隐马尔科夫模型（HMM）实现词性标注---1998年1月份人民日报语料---learn---test---evaluation---Demo---java实现的更多相关文章

  1. 隐马尔科夫模型HMM（一）HMM模型

    隐马尔科夫模型HMM(一)HMM模型基础 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比 ...

  2. 隐马尔科夫模型HMM

    崔晓源 翻译 我们通常都习惯寻找一个事物在一段时间里的变化规律.在很多领域我们都希望找到这个规律,比如计算机中的指令顺序,句子中的词顺序和语音中的词顺序等等.一个最适用的例子就是天气的预测. 首先,本 ...

  3. 隐马尔科夫模型 HMM(Hidden Markov Model)

    本科阶段学了三四遍的HMM,机器学习课,自然语言处理课,中文信息处理课:如今学研究生的自然语言处理,又碰见了这个老熟人: 虽多次碰到,但总觉得一知半解,对其了解不够全面,借着这次的机会,我想要直接搞定 ...

  4. 隐马尔科夫模型HMM学习最佳范例

    谷歌路过这个专门介绍HMM及其相关算法的主页:http://rrurl.cn/vAgKhh 里面图文并茂动感十足,写得通俗易懂,可以说是介绍HMM很好的范例了.一个名为52nlp的博主(google ...

  5. 猪猪的机器学习笔记（十七）隐马尔科夫模型HMM

    隐马尔科夫模型HMM 作者:樱花猪 摘要: 本文为七月算法(julyedu.com)12月机器学习第十七次课在线笔记.隐马尔可夫模型(Hidden Markov Model,HMM)是统计模型,它用来 ...

  6. 隐马尔科夫模型HMM（二）前向后向算法评估观察序列概率

    隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比算法 ...

  7. 隐马尔科夫模型HMM（三）鲍姆-韦尔奇算法求解HMM参数

    隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比算法 ...

  8. 隐马尔科夫模型HMM（四）维特比算法解码隐藏状态序列

    隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数 隐马尔科夫模型HMM(四)维特比算法解码隐藏状态 ...

  9. 用hmmlearn学习隐马尔科夫模型HMM

    在之前的HMM系列中,我们对隐马尔科夫模型HMM的原理以及三个问题的求解方法做了总结.本文我们就从实践的角度用Python的hmmlearn库来学习HMM的使用.关于hmmlearn的更多资料在官方文 ...

  10. 机器学习之隐马尔科夫模型HMM（六）

    摘要 隐马尔可夫模型(Hidden Markov Model,HMM)是统计模型,它用来描述一个含有隐含未知参数的马尔科夫过程.其难点是从可观察的参数中确定该过程的隐含参数,然后利用这些参数来作进一步 ...

随机推荐

  1. HGOI20180814 （NOIP 模拟Day1）

    100pts=40+60+0 rank 56 若串联那么显然是这样: 若并联那么显然是这样: 串联时C<1,并联时C>1,贪心策略<1时尽可能串联,>1时尽可能并联 考虑这样一 ...

  2. 洛谷 P4568 [JLOI2011]飞行路线 解题报告

    P4568 [JLOI2011]飞行路线 题目描述 Alice和Bob现在要乘飞机旅行,他们选择了一家相对便宜的航空公司.该航空公司一共在\(n\)个城市设有业务,设这些城市分别标记为0到\(n−1\ ...

  3. Java后台面试 常见问题

    Java后台面试 常见问题   从三月份找实习到现在,面了一些公司,挂了不少,但最终还是拿到小米.百度.阿里.京东.新浪.CVTE.乐视家的研发岗offer.我找的是java后台开发,把常见的问题分享 ...

  4. spring的controller默认是单例还是多例

    转: spring的controller默认是单例还是多例 先看看spring的bean作用域有几种,分别有啥不同. spring bean作用域有以下5个: singleton:单例模式,当spri ...

  5. error while loading shared libraries: libmysqlcppconn.so.7: cannot open shared object file: No such file or directory

    1. 即使libmysqlcppconn.so.7和与之相关存在,也报这个错误. 解决方法:临时添加LD_LIBRARY_PATH, 假使 libmysqlcppconn.so在/usr/local/ ...

  6. ubuntu14的unity desktop显示异常

    在多用户下,卸载compiz后某个单一用户出现菜单栏和任务栏图标消失的情况. 这时,需要在图形界面下重置compiz $dconf reset -f /org/compiz/ 重启unity $set ...

  7. 如何构建 Redis 高可用架构？

    温国兵 民工哥技术之路 今天 1 .题记 Redis 是一个开源的使用 ANSI C 语言编写.支持网络.可基于内存亦可持久化的日志型.Key-Value 数据库,并提供多种语言的 API. 如今,互 ...

  8. 口琴练习部分 - 多孔单音奏法 & 简单伴奏

     多孔单音奏法(口含5个孔) 加入伴奏 理论知识 - 盖住 理论知识 - 松开 舌头一抬一合形成一个伴奏 高级一点的伴奏练习 正拍伴奏: 当要吹吸某一个音时,舌头先离开琴格,然后迅速盖上.

  9. 质数——6N±1法

    6N±1法求素数 任何一个自然数,总可以表示成为如下的形式之一: 6N,6N+1,6N+2,6N+3,6N+4,6N+5 (N=0,1,2,…) 显然,当N≥1时,6N,6N+2,6N+3,6N+4都 ...

  10. Linux命令（二）关机重启