多种贝叶斯模型构建文本分类

摘要： 当前数据挖掘技术使用最为广泛的莫过于文本挖掘领域，包括领域本体构建、短文本实体抽取以及代码的语义级构件方法研究。常用的数据挖掘功能包括分类、聚类、预测和关联四大模型。本文针对四大模型之一的分类进行讨论。分类算法包括回归、决策树、支持向量机、贝叶斯等，显然，不少涉及机器学习的知识（随后会写些机器学习专题）。本文重点介绍 贝叶斯分类，涉及朴素贝叶斯模型、二项独立模型、多项模型、混合模型 等知识。在本人研究贝叶斯分类过程中，发现很多博客重复现象严重，并且在构建模型过程中存在大量的问题。包括博客园中最受欢迎的几篇，整个模型构造就不符合理论。索性自己重新查阅外文文献，进而得到很大帮助。本文针对几种模型，采用算法概述、算法公式解析、公式推理、优缺点比较等进行总结。（ 本文原创，转载注明出处。 ）

公式 P( Category | Document) = (P ( Document | Category ) * P( Category))/ P(Document)

朴素贝叶斯分类器： P(c|d)~=P(c)*P(d|c)

训练阶段：对每一个W_k，C_i估计先验条件概率P(w_k|c_i)和概率P(C_i)

分类阶段：计算后验概率，返回使后验概率最大的类

C(d)=argmax {P(C_i)*P(d|c_i)}

package com.naivebayes.bnc; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import jeasy.analysis.MMAnalyzer; /**  * @公式 P( Category | Document) = (P ( Document | Category ) * P( Category))/ P(Document)  * @朴素贝叶斯分类器： P(c|d)~=P(c)*P(d|c)  * @算法思想：  *  训练阶段：对每一个W_k，C_i估计先验条件概率P(w_k|c_i)和概率P(C_i)  *  分类阶段：计算后验概率，返回使后验概率最大的类  *  C(d)=argmax {P(C_i)*P(d|c_i)}  * @条件：给定目标值时属性之间相互条件独立。换言之。该假定说明给定实例的目标值情况下。观察到联合的a1,a2...an的概率正好是对每个单独属性的概率乘积： P(a1,a2...an | Vj ) =Πi P( ai| Vj ).  * @缺点： 在属性个数比较多或者属性之间相关性较大时，NBC模型的分类效率比不上决策树模型。  * @优点：决策树模型也有一些缺点，比如处理缺失数据时的困难，过度拟合问题的出现，以及忽略数据集中属性之间的相关性等，适用NBC（朴素贝叶斯分类）  * @比较：在属性相关性较小时，NBC模型的性能稍微良好。属性相关性较小的时候，其他的算法性能也很好，这是由于信息熵理论决定的。  * @author 白宁超  *  */  public class NaiveBayesToClass {  //统计某类文档的数目  public static Map<String,Integer> classDocnum=new HashMap<String, Integer>();    //属于类别的单词 总数  public static int classAlldocnum=0;   //统计某类中某个单词出现的次数  public static Map<String,Integer> classWordfru=new HashMap<String, Integer>();   //统计某类中的单词总数  public static Map<String,Integer> classAllwordnum=new HashMap<String, Integer>();   /**   * 朴素贝叶斯文本分类器   * 训练阶段   * 算法思想：文档d属于某类c的概率=文档空间随机抽取一个文档d属于某类c的概率*文档中的单词与总单词的比例   *  P(c|d)~=P(c)*P(d|c)   *  P(c)=classDocnum/classAlldocnum   * 计算参数：   *    classDocnum：某类中的文档数目   *    classAlldocnum：数据集中总的文档数目   *    classWordfru：某类下文档中单词频数   *    classAllwordnum:某类中总的单词数   * @param fileDirPath 训练集文件夹目录   */  public static void  BayesModel(String fileDirPath){   try{    File dir=new File(fileDirPath);    if(dir.exists()&&dir.isDirectory()){     File[] files=dir.listFiles();  //获取所有训练集文件     for(File file:files){      String classNo=file.getName().split("//_")[0];//获取文件类标      FileInputStream   stream=new FileInputStream(file);  //获取文件流      InputStreamReader strRead=new InputStreamReader(stream,"UTF-8"); //对文件进行读取，且指定编码格式      BufferedReader bufReader = new BufferedReader(strRead);      String line=null;      //读取文件内容      while((line=bufReader.readLine())!=null){       //统计某类文档的数目       if(classDocnum.containsKey(classNo)){        classDocnum.put(classNo, classDocnum.get(classNo)+1);       }       else{        classDocnum.put(classNo, 1);//第一次存数据，没有类标，但是已经读取一行，故设置1       }       String lineText = line.trim(); //除去字符串开头和末尾的空格或其他字符       String[] words = lineText.split(" ");        //遍历所有单词       for(String word:words){        //统计某类中的单词总数        if(classAllwordnum.containsKey(classNo)){         classAllwordnum.put(classNo, classAllwordnum.get(classNo)+1);        }        else{         classAllwordnum.put(classNo, 1);        }        //统计某类中某个单词出现的次数        String wordNo=classNo+"_"+word;        if(classWordfru.containsKey(wordNo)){         classWordfru.put(wordNo, classWordfru.get(wordNo)+1);        }        else{         classWordfru.put(wordNo, 1);        }       }       classAlldocnum++;      }      strRead.close();     }    }    else{     System.out.println("找不到目录文件"+fileDirPath);    }    }   catch (Exception e) {    System.out.println("出错信息描述如下："+e.getMessage());   }  }  /**   * 对测试文本进行分类预测   * 预测阶段：   * @param testText  测试数据集   * @return 返回分类结果   */  public static String PredictReslut(String testText){   //预测结果   String PredictResult="";   testText=SplitWords(testText, " ");// 对测试文档进行中文分词处理   String[] words=testText.split(" ");  //对字符串进行分割   double argmax = Double.NEGATIVE_INFINITY;//最大类概率（默认值为负无穷小）,是否可以写成0？（无穷小本身就是接近0）   Iterator iterator=classDocnum.keySet().iterator();//遍历   while(iterator.hasNext()){    String classNo = (String) iterator.next();    double prior = classDocnum.get(classNo)/(double)classAlldocnum;//先验概率    double classcount=(double)(classAllwordnum.get(classNo)+1);//某一类的最大值    double likelihoodProbability=0;         //初始化似然概率    //根据公式求解最大似然概率，其中words相当于属性即多维的    for (int i = 0; i < words.length; i++){     String word_classNo = words[i]+"_"+classNo;     //获取测试数据的单词类别     //与训练数据词库进行对比，求得相似的概率     if(classWordfru.containsKey(word_classNo)){      //将连乘装换成对数相加【ln(a*b)=lna+lnb】,提高效率      likelihoodProbability += Math.log(classWordfru.get(word_classNo)/classcount);     }     else{      likelihoodProbability += Math.log(1/classcount);     }    }    //利用自然对数e^loga = a，取得原始值     likelihoodProbability = Math.exp(likelihoodProbability)*prior;     System.out.println("classNo:"+classNo);     System.out.println("最大似然概率:"+argmax);     System.out.println("似然概率:"+likelihoodProbability);     if(likelihoodProbability>argmax){      argmax = likelihoodProbability;  //最大似然概率一直保持最大的似然概率      PredictResult = classNo;  //返回分类的结果     }   }   System.out.println("***************************************************");   System.out.println("【朴素贝叶斯最终分类结果：】"+PredictResult);   return PredictResult;  }  /**   * 对字符串进行中文分词处理   * @param text   给定预处理的字符串   * @param splitToken  用于分割的标记。如","   * @return  处理后的字符串   */  public static String SplitWords(String text,String splitToken){   String result = null;   MMAnalyzer analyzer = new MMAnalyzer();   //极易中文分词   try   {    result = analyzer.segment(text, splitToken);    }      catch (IOException e){      e.printStackTrace();     }     return result;  } } 

package com.bernouli.bnc; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; import jeasy.analysis.MMAnalyzer; public class BernouliBayesClass {  //统计某类中文档的数目  public static Map<String,Integer> classcountMap=new HashMap<String, Integer>();   //统计训练集中总文档的数目  public static Integer datacount=0;   //训练集中所含单词通过类标进行标记（训练集的单词已经去重，不考虑频数）  public static Map<String,Integer> likelihoodMap=new HashMap<String, Integer>();   //所有类词汇集合（总词汇表的长度）  public static Set<String> vocabularySet = new HashSet<String>();  /**   * 建立朴素贝叶斯文本分类模型   * @param fileDirPath 文件目录   */  public static void BayesModel(String fileDirPath){   try{    File dir=new File(fileDirPath);    if(dir.exists()&&dir.isDirectory()){     File[] files=dir.listFiles();  //获取所有训练集文件     //遍历训练集文件     for(File file:files){      String classNo=file.getName().split("//_")[0];//获取文件类标      FileInputStream   stream=new FileInputStream(file);  //获取文件流      InputStreamReader strRead=new InputStreamReader(stream,"UTF-8"); //对文件进行读取，且指定编码格式      BufferedReader bufReader = new BufferedReader(strRead);      String line=null;      //读取文件内容      while((line=bufReader.readLine())!=null){       //统计某类文档的数目       if(classcountMap.containsKey(classNo)){        classcountMap.put(classNo, classcountMap.get(classNo)+1);       }       else{        classcountMap.put(classNo, 1);//第一次存数据，没有类标，但是已经读取一行，故设置1       }       String lineText = line.trim(); //除去字符串开头和末尾的空格或其他字符       String[] words = lineText.split(" ");        Set<String> wordaSet = arrayToSet(words);//单词去重，列出词汇表的尺寸       if(!wordaSet.isEmpty()){        vocabularySet.addAll(wordaSet);//加入词汇表集合       }       //遍历所有单词       for(String word:words){        String wordNo=word+"_"+classNo;        if(likelihoodMap.containsKey(wordNo)){         likelihoodMap.put(wordNo, likelihoodMap.get(wordNo)+1);        }        else{         likelihoodMap.put(wordNo, 1);        }       }       datacount++;      }      strRead.close();     }    }    else{     System.out.println("找不到目录文件"+fileDirPath);    }   }   catch (Exception e) {    System.out.println("出错信息描述如下："+e.getMessage());   }  }  /**   * 将数组转换成Set集合(相当于去重)   * @param words    * @return   */  public static Set<String> arrayToSet(String[] words){   Set<String> wordaSet = new HashSet<String>();   for (String word:words) {    if(""!=word&&!word.equals("")){     wordaSet.add(word);    }   }   return wordaSet;  }  /**   * 对字符串进行中文分词处理   * @param text   给定预处理的字符串   * @param splitToken  用于分割的标记。如","   * @return  处理后的字符串   */  public static String SplitWords(String text,String splitToken){   String result = null;   MMAnalyzer analyzer = new MMAnalyzer();   //极易中文分词   try{    result = analyzer.segment(text, splitToken);    }      catch (IOException e){      e.printStackTrace();     }     return result;  }  /**   * 对测试文本进行分类预测   * @param testText  测试数据集   * @return 返回分类结果   */  public static String PredictReslut(String testText){   String PredictResult="";   testText=SplitWords(testText, " ");  // 对测试文档进行中文分词处理   String[] words=testText.split(" ");  //对字符串进行分割   Set<String> wordSet = arrayToSet(words);//单词去重，获取测试集的单词表尺寸   //TODO 不存在的单词的校验   wordSet.addAll(vocabularySet);   double argmax = Double.NEGATIVE_INFINITY;//最大类概率（默认值为负无穷小）,是否可以写成0？（无穷小本身就是接近0）   //for (Iterator iterator = classcountMap.keySet().iterator(); iterator.hasNext();)    Iterator iterator=classcountMap.keySet().iterator();//遍历   while(iterator.hasNext()){    String classNo = (String) iterator.next();    double prior = classcountMap.get(classNo)/(double)datacount;//先验概率    double likelihoodProbability=0;         //初始化似然概率    //根据公式求解最大似然概率，其中words相当于属性即多维的    for (String word:wordSet){     if(""!=word){      String word_classNo = word+"_"+classNo;     //获取测试数据的单词类别      //与训练数据词库进行对比，求得相似的概率      if(likelihoodMap.containsKey(word_classNo)){       //将连乘装换成对数相加【ln(a*b)=lna+lnb】,提高效率       likelihoodProbability += Math.log((likelihoodMap.get(word_classNo)+1)/((double)classcountMap.get(classNo)+2));      }      else{       likelihoodProbability +=Math.log((1-1/(double)(classcountMap.get(classNo)+2)));      }     }    }    //利用自然对数e^loga = a，取得原始值      likelihoodProbability += Math.exp(likelihoodProbability)*prior;     System.out.println("最大似然概率:"+argmax);     System.out.println("第["+classNo+"]类似然概率:"+likelihoodProbability);     if(likelihoodProbability>argmax){      argmax = likelihoodProbability;  //最大似然概率一直保持最大的似然概率      PredictResult = classNo;  //返回分类的结果     }   }   System.out.println("***************************************************");   System.out.println("【伯努利模型最终分类结果：】"+PredictResult);   return PredictResult;  }  public static void main(String[] args) {   long beginTime=System.currentTimeMillis();   String filedir="./data_training";   String testText = "南京 爆炸 事件 中 ， 南京 电视台 生活 频道 因为 最 早 做 了 现场 直播 而 受到 上级 批评 ； 爆出 “ 最 牛1 官腔 ” 的1 江苏 电视台 城市 频道 也 因 直播 此 事 被 上级 批评 ， 相关 栏目 也 面临 停 播 。 不 知道 是 官员 的1 可悲 、 人民 的1 可悲 ， 还 是 记者 的1 可悲 ！ 一 个 悲剧 的1 社会 ！ 真 TM 龌龊";   BayesModel(filedir);   PredictReslut(testText);    long endTime=System.currentTimeMillis();    long between=endTime-beginTime;    System.out.println("共计用时："+between+"毫秒");  } } 

package com.multinomial.bnc; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; import jeasy.analysis.MMAnalyzer; public class MultinoBayesclass {  //词汇表集合(词汇表的尺寸，不考虑频数，即重复单词)  public static Set<String> vocabularySet = new HashSet<String>();  //属于总的单词数  public static Integer datacount=0;   //训练文档中含有单词并且类标为某类的单词数  public static Map<String,Integer> likelihoodMap=new HashMap<String, Integer>();   //训练集中某类的单词数  public static Map<String,Integer> classVocabularyMap=new HashMap<String, Integer>();   /**   * 建立朴素贝叶斯文本分类模型   * @param fileDirPath 文件目录   */  public static void BayesModel(String fileDirPath){   try{    File dir=new File(fileDirPath);    if(dir.exists()&&dir.isDirectory()){     File[] files=dir.listFiles();  //获取所有训练集文件     //遍历训练集文件     for(File file:files){      String classNo=file.getName().split("//_")[0];//获取文件类标      FileInputStream   stream=new FileInputStream(file);  //获取文件流      InputStreamReader strRead=new InputStreamReader(stream,"UTF-8"); //对文件进行读取，且指定编码格式      BufferedReader bufReader = new BufferedReader(strRead);      String line=null;      //读取文件内容      while((line=bufReader.readLine())!=null){       String lineText = line.trim(); //除去字符串开头和末尾的空格或其他字符       String[] words = lineText.split(" ");        //加入词汇表集合       for(String word:words){        vocabularySet.add(word);        //统计某类中的单词总数        if(classVocabularyMap.containsKey(classNo)){         classVocabularyMap.put(classNo, classVocabularyMap.get(classNo)+1);        }        else{         classVocabularyMap.put(classNo, 1);        }        //统计某类中某个单词出现的次数        String wordNo=word+"_"+classNo;        if(likelihoodMap.containsKey(wordNo)){         likelihoodMap.put(wordNo, likelihoodMap.get(wordNo)+1);        }        else{         likelihoodMap.put(wordNo, 1);        }       }       datacount++;      }      strRead.close();     }    }    else{     System.out.println("找不到目录文件"+fileDirPath);    }   }   catch (Exception e) {    System.out.println("出错信息描述如下："+e.getMessage());   }  }  /**   * 对测试文本进行分类预测   * @param testText  测试数据集   * @return 返回分类结果   */  public static String PredictReslut(String testText)  {   int vsSize = vocabularySet.size();//词汇表长度   String PredictResult="";   testText=SplitWords(testText, " ");// 对测试文档进行中文分词处理   String[] words=testText.split(" ");  //对字符串进行分割   double argmax = Double.NEGATIVE_INFINITY;//最大类概率（默认值为负无穷小）,是否可以写成0？（无穷小本身就是接近0）   Iterator iterator=classVocabularyMap.keySet().iterator();//遍历   while(iterator.hasNext())   {    String classNo = (String) iterator.next();    double prior = classVocabularyMap.get(classNo)/(double)datacount;//先验概率    double likelihoodProbability=0;         //初始化似然概率    //根据公式求解最大似然概率，其中words相当于属性即多维的    for (String word:words)     {     if(""!=word)     {      String word_classNo = word+"_"+classNo;     //获取测试数据的单词类别      //与训练数据词库进行对比，求得相似的概率      if(likelihoodMap.containsKey(word_classNo)){       //将连乘装换成对数相加【ln(a*b)=lna+lnb】,提高效率       likelihoodProbability +=Math.log((likelihoodMap.get(word_classNo)+1)/((double)classVocabularyMap.get(classNo)+vsSize));      }      else{       likelihoodProbability += Math.log((1/(double)(classVocabularyMap.get(classNo)+vsSize)));      }     }    }    //利用自然对数e^loga = a，取得原始值     likelihoodProbability +=Math.exp(likelihoodProbability)*prior;     System.out.println("最大似然概率:"+argmax);     System.out.println("第["+classNo+"]类似然概率:"+likelihoodProbability);     if(likelihoodProbability>argmax)     {      argmax = likelihoodProbability;  //最大似然概率一直保持最大的似然概率      PredictResult = classNo;  //返回分类的结果     }     }   System.out.println("***************************************************");   System.out.println("【多项式模型最终分类结果：】"+PredictResult);   return PredictResult;  }  /**   * 对字符串进行中文分词处理   * @param text   给定预处理的字符串   * @param splitToken  用于分割的标记。如","   * @return  处理后的字符串   */  public static String SplitWords(String text,String splitToken){   String result = null;   MMAnalyzer analyzer = new MMAnalyzer();   //极易中文分词   try{    result = analyzer.segment(text, splitToken);    }      catch (IOException e){      e.printStackTrace();     }     return result;  }  public static void main(String[] args) {   String filedir="./data_training";   String testText = "南京 爆炸 事件 中 ， 南京 电视台 生活 频道 因为 最 早 做 了 现场 直播 而 受到 上级 批评 ； 爆出 “ 最 牛1 官腔 ” 的1 江苏 电视台 城市 频道 也 因 直播 此 事 被 上级 批评 ， 相关 栏目 也 面临 停 播 。 不 知道 是 官员 的1 可悲 、 人民 的1 可悲 ， 还 是 记者 的1 可悲 ！ 一 个 悲剧 的1 社会 ！ 真 TM 龌龊";   BayesModel(filedir);   PredictReslut(testText);  } }