数据挖掘-基于贝叶斯算法及KNN算法的newsgroup18828文本分类器的JAVA实现（上）

(update 2012.12.28 关于本项目下载及运行的常见问题 FAQ见newsgroup18828文本分类器、文本聚类器、关联分析频繁模式挖掘算法的Java实现工程下载及运行FAQ)

本文主要内容如下：
对newsgroup文档集进行预处理，提取出30095 个特征词

计算每篇文档中的特征词的TF*IDF值，实现文档向量化，在KNN算法中使用

用JAVA实现了KNN算法及朴素贝叶斯算法的newsgroup文本分类器

1、Newsgroup文档集介绍

Newsgroups最早由Lang于1995收集并在[Lang 1995]中使用。它含有20000篇左右的Usenet文档，几乎平均分配20个不同的新闻组。除了其中4.5%的文档属于两个或两个以上的新闻组以外，其余文档仅属于一个新闻组，因此它通常被作为单标注分类问题来处理。Newsgroups已经成为文本分及聚类中常用的文档集。美国MIT大学Jason Rennie对Newsgroups作了必要的处理，使得每个文档只属于一个新闻组，形成Newsgroups-18828。

2、Newsgroup文档预处理

要做文本分类首先得完成文本的预处理，预处理的主要步骤如下

STEP ONE:英文词法分析，去除数字、连字符、标点符号、特殊字符，所有大写字母转换成小写，可以用正则表达式

String res[] = line.split("[^a-zA-Z]");

STEP TWO:去停用词，过滤对分类无价值的词

STEP THRE:词根还原stemming,基于Porter算法

文档预处理类 DataPreProcess.java如下

[java] view plain copy

1. packagecom.pku.yangliu;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.FileWriter;
7. importjava.io.IOException;
8. importjava.util.ArrayList;
10. /**
11. *Newsgroups文档集预处理类
12. */
13. publicclassDataPreProcess{
15. /**输入文件调用处理数据函数
16. *@paramstrDirnewsgroup文件目录的绝对路径
17. *@throwsIOException
18. */
19. publicvoiddoProcess(StringstrDir)throwsIOException{
20. FilefileDir=newFile(strDir);
21. if(!fileDir.exists()){
22. System.out.println("Filenotexist:"+strDir);
23. return;
24. }
25. StringsubStrDir=strDir.substring(strDir.lastIndexOf('/'));
26. StringdirTarget=strDir+"/../../processedSample_includeNotSpecial"+subStrDir;
27. FilefileTarget=newFile(dirTarget);
28. if(!fileTarget.exists()){//注意processedSample需要先建立目录建出来，否则会报错，因为母目录不存在
29. fileTarget.mkdir();
30. }
31. File[]srcFiles=fileDir.listFiles();
32. String[]stemFileNames=newString[srcFiles.length];
33. for(inti=0;i<srcFiles.length;i++){
34. StringfileFullName=srcFiles[i].getCanonicalPath();
35. StringfileShortName=srcFiles[i].getName();
36. if(!newFile(fileFullName).isDirectory()){//确认子文件名不是目录如果是可以再次递归调用
37. System.out.println("Beginpreprocess:"+fileFullName);
38. StringBuilderstringBuilder=newStringBuilder();
39. stringBuilder.append(dirTarget+"/"+fileShortName);
40. createProcessFile(fileFullName,stringBuilder.toString());
41. stemFileNames[i]=stringBuilder.toString();
42. }
43. else{
44. fileFullName=fileFullName.replace("\\","/");
45. doProcess(fileFullName);
46. }
47. }
48. //下面调用stem算法
49. if(stemFileNames.length>0&&stemFileNames[0]!=null){
50. Stemmer.porterMain(stemFileNames);
51. }
52. }
54. /**进行文本预处理生成目标文件
55. *@paramsrcDir源文件文件目录的绝对路径
56. *@paramtargetDir生成的目标文件的绝对路径
57. *@throwsIOException
58. */
59. privatestaticvoidcreateProcessFile(StringsrcDir,StringtargetDir)throwsIOException{
60. //TODOAuto-generatedmethodstub
61. FileReadersrcFileReader=newFileReader(srcDir);
62. FileReaderstopWordsReader=newFileReader("F:/DataMiningSample/stopwords.txt");
63. FileWritertargetFileWriter=newFileWriter(targetDir);
64. BufferedReadersrcFileBR=newBufferedReader(srcFileReader);//装饰模式
65. BufferedReaderstopWordsBR=newBufferedReader(stopWordsReader);
66. Stringline,resLine,stopWordsLine;
67. //用stopWordsBR够着停用词的ArrayList容器
68. ArrayList<String>stopWordsArray=newArrayList<String>();
69. while((stopWordsLine=stopWordsBR.readLine())!=null){
70. if(!stopWordsLine.isEmpty()){
71. stopWordsArray.add(stopWordsLine);
72. }
73. }
74. while((line=srcFileBR.readLine())!=null){
75. resLine=lineProcess(line,stopWordsArray);
76. if(!resLine.isEmpty()){
77. //按行写，一行写一个单词
78. String[]tempStr=resLine.split("");//\s
79. for(inti=0;i<tempStr.length;i++){
80. if(!tempStr[i].isEmpty()){
81. targetFileWriter.append(tempStr[i]+"\n");
82. }
83. }
84. }
85. }
86. targetFileWriter.flush();
87. targetFileWriter.close();
88. srcFileReader.close();
89. stopWordsReader.close();
90. srcFileBR.close();
91. stopWordsBR.close();
92. }
94. /**对每行字符串进行处理，主要是词法分析、去停用词和stemming
95. *@paramline待处理的一行字符串
96. *@paramArrayList<String>停用词数组
97. *@returnString处理好的一行字符串，是由处理好的单词重新生成，以空格为分隔符
98. *@throwsIOException
99. */
100. privatestaticStringlineProcess(Stringline,ArrayList<String>stopWordsArray)throwsIOException{
101. //TODOAuto-generatedmethodstub
102. //step1英文词法分析，去除数字、连字符、标点符号、特殊字符，所有大写字母转换成小写，可以考虑用正则表达式
103. Stringres[]=line.split("[^a-zA-Z]");
104. //这里要小心，防止把有单词中间有数字和连字符的单词截断了，但是截断也没事
106. StringresString=newString();
107. //step2去停用词
108. //step3stemming,返回后一起做
109. for(inti=0;i<res.length;i++){
110. if(!res[i].isEmpty()&&!stopWordsArray.contains(res[i].toLowerCase())){
111. resString+=""+res[i].toLowerCase()+"";
112. }
113. }
114. returnresString;
115. }
117. /**
118. *@paramargs
119. *@throwsIOException
120. */
121. publicvoidBPPMain(String[]args)throwsIOException{
122. //TODOAuto-generatedmethodstub
123. DataPreProcessdataPrePro=newDataPreProcess();
124. dataPrePro.doProcess("F:/DataMiningSample/orginSample");
126. }
128. }

steming的porter算法可以Google，有C及JAVA的实现版本，点击下载 porter算法JAVA版本

2、特征词的选取

首先统计经过预处理后在所有文档中出现不重复的单词一共有87554个，对这些词进行统计发现：
出现次数大于等于1次的词有87554个
出现次数大于等于3次的词有36456个
出现次数大于等于4次的词有30095个
特征词的选取策略：
策略一：保留所有词作为特征词 共计87554个
策略二：选取出现次数大于等于4次的词作为特征词共计30095个
特征词的选取策略：采用策略一，后面将对两种特征词选取策略的计算时间和平均准确率做对比

测试集与训练集的创建类CreateTrainAndTestSample.java如下

[java] view plain copy

1. packagecom.pku.yangliu;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.FileWriter;
7. importjava.io.IOException;
8. importjava.util.SortedMap;
9. importjava.util.TreeMap;
11. /**创建训练样例集合与测试样例集合
12. *
13. */
14. publicclassCreateTrainAndTestSample{
16. voidfilterSpecialWords()throwsIOException{
17. //TODOAuto-generatedmethodstub
18. Stringword;
19. ComputeWordsVectorcwv=newComputeWordsVector();
20. StringfileDir="F:/DataMiningSample/processedSample_includeNotSpecial";
21. SortedMap<String,Double>wordMap=newTreeMap<String,Double>();
22. wordMap=cwv.countWords(fileDir,wordMap);
23. cwv.printWordMap(wordMap);//把wordMap输出到文件
24. File[]sampleDir=newFile(fileDir).listFiles();
25. for(inti=0;i<sampleDir.length;i++){
26. File[]sample=sampleDir[i].listFiles();
27. StringtargetDir="F:/DataMiningSample/processedSampleOnlySpecial/"+sampleDir[i].getName();
28. FiletargetDirFile=newFile(targetDir);
29. if(!targetDirFile.exists()){
30. targetDirFile.mkdir();
31. }
32. for(intj=0;j<sample.length;j++){
33. StringfileShortName=sample[j].getName();
34. if(fileShortName.contains("stemed")){
35. targetDir="F:/DataMiningSample/processedSampleOnlySpecial/"+sampleDir[i].getName()+"/"+fileShortName.substring(0,5);
36. FileWritertgWriter=newFileWriter(targetDir);
37. FileReadersamReader=newFileReader(sample[j]);
38. BufferedReadersamBR=newBufferedReader(samReader);
39. while((word=samBR.readLine())!=null){
40. if(wordMap.containsKey(word)){
41. tgWriter.append(word+"\n");
42. }
43. }
44. tgWriter.flush();
45. tgWriter.close();
46. }
47. }
48. }
49. }
51. voidcreateTestSamples(StringfileDir,doubletrainSamplePercent,intindexOfSample,StringclassifyResultFile)throwsIOException{
52. //TODOAuto-generatedmethodstub
53. Stringword,targetDir;
54. FileWritercrWriter=newFileWriter(classifyResultFile);//测试样例正确类目记录文件
55. File[]sampleDir=newFile(fileDir).listFiles();
56. for(inti=0;i<sampleDir.length;i++){
57. File[]sample=sampleDir[i].listFiles();
58. doubletestBeginIndex=indexOfSample*(sample.length*(1-trainSamplePercent));//测试样例的起始文件序号
59. doubletestEndIndex=(indexOfSample+1)*(sample.length*(1-trainSamplePercent));//测试样例集的结束文件序号
60. for(intj=0;j<sample.length;j++){
61. FileReadersamReader=newFileReader(sample[j]);
62. BufferedReadersamBR=newBufferedReader(samReader);
63. StringfileShortName=sample[j].getName();
64. StringsubFileName=fileShortName;
65. if(j>testBeginIndex&&j<testEndIndex){//序号在规定区间内的作为测试样本，需要为测试样本生成类别-序号文件，最后加入分类的结果，一行对应一个文件，方便统计准确率
66. targetDir="F:/DataMiningSample/TestSample"+indexOfSample+"/"+sampleDir[i].getName();
67. crWriter.append(subFileName+""+sampleDir[i].getName()+"\n");
69. }
70. else{//其余作为训练样本
71. targetDir="F:/DataMiningSample/TrainSample"+indexOfSample+"/"+sampleDir[i].getName();
72. }
73. targetDir=targetDir.replace("\\","/");
74. FiletrainSamFile=newFile(targetDir);
75. if(!trainSamFile.exists()){
76. trainSamFile.mkdir();
77. }
78. targetDir+="/"+subFileName;
79. FileWritertsWriter=newFileWriter(newFile(targetDir));
80. while((word=samBR.readLine())!=null){
81. tsWriter.append(word+"\n");
82. }
83. tsWriter.flush();
84. tsWriter.close();
85. }
86. }
87. crWriter.flush();
88. crWriter.close();
89. }
90. }

3、贝叶斯算法描述及实现

根据朴素贝叶斯公式，每个测试样例属于某个类别的概率 = 所有测试样例包含特征词类条件概率P(tk|c)之积 * 先验概率P(c)

在具体计算类条件概率和先验概率时，朴素贝叶斯分类器有两种模型

（1）多元分布模型( multinomial model ) –以单词为粒度，也就是说，考虑每个文件里面重复出现多次的单词。注意多项分布其实是从二项分布拓展出来的，如果采用多项分布模型，那么每个单词表示变量就不再是二值变量（出现/不出现），而是每个单词在文件中出现的次数
类条件概率P(tk|c)=(类c下单词tk在各个文档中出现过的次数之和+1)/（类c下单词总数+训练样本中不重复特征词总数）
先验概率P(c)=类c下的单词总数/整个训练样本的单词总数
（2）伯努利模型（Bernoulli model） –以文件为粒度，或者说是采用二项分布模型，伯努利实验即N次独立重复随机实验，只考虑事件发生/不发生，所以每个单词的表示变量是布尔型的
类条件概率P(tk|c)=（类c下包含单词tk的文件数+1）/(类c下文件总数+2)（注意：开始此处错写成了单词，多谢网友提醒后更正）
先验概率P(c)=类c下文件总数/整个训练样本的文件总数
本分类器选用多元分布模型计算，根据《Introduction to Information Retrieval 》，多元分布模型计算准确率更高

贝叶斯算法的实现有以下注意点：

(1) 计算概率用到了BigDecimal类实现任意精度计算
(2) 用交叉验证法做十次分类实验，对准确率取平均值
(3) 根据正确类目文件和分类结果文计算混淆矩阵并且输出
(4) Map<String,Double> cateWordsProb key为“类目_单词”, value为该类目下该单词的出现次数，避免重复计算

贝叶斯算法实现类如下 NaiveBayesianClassifier.java

[java] view plain copy

1. packagecom.pku.yangliu;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.FileWriter;
7. importjava.io.IOException;
8. importjava.math.BigDecimal;
9. importjava.util.Iterator;
10. importjava.util.Map;
11. importjava.util.Set;
12. importjava.util.SortedSet;
13. importjava.util.TreeMap;
14. importjava.util.TreeSet;
15. importjava.util.Vector;
17. /**利用朴素贝叶斯算法对newsgroup文档集做分类，采用十组交叉测试取平均值
18. *采用多项式模型,stanford信息检索导论课件上面言多项式模型比伯努利模型准确度高
19. *类条件概率P(tk|c)=(类c下单词tk在各个文档中出现过的次数之和+1)/(类c下单词总数+|V|)
20. *
21. */
22. publicclassNaiveBayesianClassifier{
24. /**用贝叶斯法对测试文档集分类
25. *@paramtrainDir训练文档集目录
26. *@paramtestDir测试文档集目录
27. *@paramclassifyResultFileNew分类结果文件路径
28. *@throwsException
29. */
30. privatevoiddoProcess(StringtrainDir,StringtestDir,
31. StringclassifyResultFileNew)throwsException{
32. //TODOAuto-generatedmethodstub
33. Map<String,Double>cateWordsNum=newTreeMap<String,Double>();//保存训练集每个类别的总词数
34. Map<String,Double>cateWordsProb=newTreeMap<String,Double>();//保存训练样本每个类别中每个属性词的出现词数
35. cateWordsProb=getCateWordsProb(trainDir);
36. cateWordsNum=getCateWordsNum(trainDir);
37. doubletotalWordsNum=0.0;//记录所有训练集的总词数
38. Set<Map.Entry<String,Double>>cateWordsNumSet=cateWordsNum.entrySet();
39. for(Iterator<Map.Entry<String,Double>>it=cateWordsNumSet.iterator();it.hasNext();){
40. Map.Entry<String,Double>me=it.next();
41. totalWordsNum+=me.getValue();
42. }
43. //下面开始读取测试样例做分类
44. Vector<String>testFileWords=newVector<String>();
45. Stringword;
46. File[]testDirFiles=newFile(testDir).listFiles();
47. FileWritercrWriter=newFileWriter(classifyResultFileNew);
48. for(inti=0;i<testDirFiles.length;i++){
49. File[]testSample=testDirFiles[i].listFiles();
50. for(intj=0;j<testSample.length;j++){
51. testFileWords.clear();
52. FileReaderspReader=newFileReader(testSample[j]);
53. BufferedReaderspBR=newBufferedReader(spReader);
54. while((word=spBR.readLine())!=null){
55. testFileWords.add(word);
56. }
57. //下面分别计算该测试样例属于二十个类别的概率
58. File[]trainDirFiles=newFile(trainDir).listFiles();
59. BigDecimalmaxP=newBigDecimal(0);
60. StringbestCate=null;
61. for(intk=0;k<trainDirFiles.length;k++){
62. BigDecimalp=computeCateProb(trainDirFiles[k],testFileWords,cateWordsNum,totalWordsNum,cateWordsProb);
63. if(k==0){
64. maxP=p;
65. bestCate=trainDirFiles[k].getName();
66. continue;
67. }
68. if(p.compareTo(maxP)==1){
69. maxP=p;
70. bestCate=trainDirFiles[k].getName();
71. }
72. }
73. crWriter.append(testSample[j].getName()+""+bestCate+"\n");
74. crWriter.flush();
75. }
76. }
77. crWriter.close();
78. }
80. /**统计某类训练样本中每个单词的出现次数
81. *@paramstrDir训练样本集目录
82. *@returnMap<String,Double>cateWordsProb用"类目_单词"对来索引的map,保存的val就是该类目下该单词的出现次数
83. *@throwsIOException
84. */
85. publicMap<String,Double>getCateWordsProb(StringstrDir)throwsIOException{
86. Map<String,Double>cateWordsProb=newTreeMap<String,Double>();
87. FilesampleFile=newFile(strDir);
88. File[]sampleDir=sampleFile.listFiles();
89. Stringword;
90. for(inti=0;i<sampleDir.length;i++){
91. File[]sample=sampleDir[i].listFiles();
92. for(intj=0;j<sample.length;j++){
93. FileReadersamReader=newFileReader(sample[j]);
94. BufferedReadersamBR=newBufferedReader(samReader);
95. while((word=samBR.readLine())!=null){
96. Stringkey=sampleDir[i].getName()+"_"+word;
97. if(cateWordsProb.containsKey(key)){
98. doublecount=cateWordsProb.get(key)+1.0;
99. cateWordsProb.put(key,count);
100. }
101. else{
102. cateWordsProb.put(key,1.0);
103. }
104. }
105. }
106. }
107. returncateWordsProb;
108. }
110. /**计算某一个测试样本属于某个类别的概率
111. *@paramMap<String,Double>cateWordsProb记录每个目录中出现的单词及次数
112. *@paramFiletrainFile该类别所有的训练样本所在目录
113. *@paramVector<String>testFileWords该测试样本中的所有词构成的容器
114. *@paramdoubletotalWordsNum记录所有训练样本的单词总数
115. *@paramMap<String,Double>cateWordsNum记录每个类别的单词总数
116. *@returnBigDecimal返回该测试样本在该类别中的概率
117. *@throwsException
118. *@throwsIOException
119. */
120. privateBigDecimalcomputeCateProb(FiletrainFile,Vector<String>testFileWords,Map<String,Double>cateWordsNum,doubletotalWordsNum,Map<String,Double>cateWordsProb)throwsException{
121. //TODOAuto-generatedmethodstub
122. BigDecimalprobability=newBigDecimal(1);
123. doublewordNumInCate=cateWordsNum.get(trainFile.getName());
124. BigDecimalwordNumInCateBD=newBigDecimal(wordNumInCate);
125. BigDecimaltotalWordsNumBD=newBigDecimal(totalWordsNum);
126. for(Iterator<String>it=testFileWords.iterator();it.hasNext();){
127. Stringme=it.next();
128. Stringkey=trainFile.getName()+"_"+me;
129. doubletestFileWordNumInCate;
130. if(cateWordsProb.containsKey(key)){
131. testFileWordNumInCate=cateWordsProb.get(key);
132. }elsetestFileWordNumInCate=0.0;
133. BigDecimaltestFileWordNumInCateBD=newBigDecimal(testFileWordNumInCate);
134. BigDecimalxcProb=(testFileWordNumInCateBD.add(newBigDecimal(0.0001))).divide(totalWordsNumBD.add(wordNumInCateBD),10,BigDecimal.ROUND_CEILING);
135. probability=probability.multiply(xcProb);
136. }
137. BigDecimalres=probability.multiply(wordNumInCateBD.divide(totalWordsNumBD,10,BigDecimal.ROUND_CEILING));
138. returnres;
139. }
141. /**获得每个类目下的单词总数
142. *@paramtrainDir训练文档集目录
143. *@returnMap<String,Double><目录名，单词总数>的map
144. *@throwsIOException
145. */
146. privateMap<String,Double>getCateWordsNum(StringtrainDir)throwsIOException{
147. //TODOAuto-generatedmethodstub
148. Map<String,Double>cateWordsNum=newTreeMap<String,Double>();
149. File[]sampleDir=newFile(trainDir).listFiles();
150. for(inti=0;i<sampleDir.length;i++){
151. doublecount=0;
152. File[]sample=sampleDir[i].listFiles();
153. for(intj=0;j<sample.length;j++){
154. FileReaderspReader=newFileReader(sample[j]);
155. BufferedReaderspBR=newBufferedReader(spReader);
156. while(spBR.readLine()!=null){
157. count++;
158. }
159. }
160. cateWordsNum.put(sampleDir[i].getName(),count);
161. }
162. returncateWordsNum;
163. }
165. /**根据正确类目文件和分类结果文件统计出准确率
166. *@paramclassifyResultFile正确类目文件
167. *@paramclassifyResultFileNew分类结果文件
168. *@returndouble分类的准确率
169. *@throwsIOException
170. */
171. doublecomputeAccuracy(StringclassifyResultFile,
172. StringclassifyResultFileNew)throwsIOException{
173. //TODOAuto-generatedmethodstub
174. Map<String,String>rightCate=newTreeMap<String,String>();
175. Map<String,String>resultCate=newTreeMap<String,String>();
176. rightCate=getMapFromResultFile(classifyResultFile);
177. resultCate=getMapFromResultFile(classifyResultFileNew);
178. Set<Map.Entry<String,String>>resCateSet=resultCate.entrySet();
179. doublerightCount=0.0;
180. for(Iterator<Map.Entry<String,String>>it=resCateSet.iterator();it.hasNext();){
181. Map.Entry<String,String>me=it.next();
182. if(me.getValue().equals(rightCate.get(me.getKey()))){
183. rightCount++;
184. }
185. }
186. computerConfusionMatrix(rightCate,resultCate);
187. returnrightCount/resultCate.size();
188. }
190. /**根据正确类目文件和分类结果文计算混淆矩阵并且输出
191. *@paramrightCate正确类目对应map
192. *@paramresultCate分类结果对应map
193. *@returndouble分类的准确率
194. *@throwsIOException
195. */
196. privatevoidcomputerConfusionMatrix(Map<String,String>rightCate,
197. Map<String,String>resultCate){
198. //TODOAuto-generatedmethodstub
199. int[][]confusionMatrix=newint[20][20];
200. //首先求出类目对应的数组索引
201. SortedSet<String>cateNames=newTreeSet<String>();
202. Set<Map.Entry<String,String>>rightCateSet=rightCate.entrySet();
203. for(Iterator<Map.Entry<String,String>>it=rightCateSet.iterator();it.hasNext();){
204. Map.Entry<String,String>me=it.next();
205. cateNames.add(me.getValue());
206. }
207. cateNames.add("rec.sport.baseball");//防止数少一个类目
208. String[]cateNamesArray=cateNames.toArray(newString[0]);
209. Map<String,Integer>cateNamesToIndex=newTreeMap<String,Integer>();
210. for(inti=0;i<cateNamesArray.length;i++){
211. cateNamesToIndex.put(cateNamesArray[i],i);
212. }
213. for(Iterator<Map.Entry<String,String>>it=rightCateSet.iterator();it.hasNext();){
214. Map.Entry<String,String>me=it.next();
215. confusionMatrix[cateNamesToIndex.get(me.getValue())][cateNamesToIndex.get(resultCate.get(me.getKey()))]++;
216. }
217. //输出混淆矩阵
218. double[]hangSum=newdouble[20];
219. System.out.print("");
220. for(inti=0;i<20;i++){
221. System.out.print(i+"");
222. }
223. System.out.println();
224. for(inti=0;i<20;i++){
225. System.out.print(i+"");
226. for(intj=0;j<20;j++){
227. System.out.print(confusionMatrix[i][j]+"");
228. hangSum[i]+=confusionMatrix[i][j];
229. }
230. System.out.println(confusionMatrix[i][i]/hangSum[i]);
231. }
232. System.out.println();
233. }
235. /**从分类结果文件中读取map
236. *@paramclassifyResultFileNew类目文件
237. *@returnMap<String,String>由<文件名，类目名>保存的map
238. *@throwsIOException
239. */
240. privateMap<String,String>getMapFromResultFile(
241. StringclassifyResultFileNew)throwsIOException{
242. //TODOAuto-generatedmethodstub
243. FilecrFile=newFile(classifyResultFileNew);
244. FileReadercrReader=newFileReader(crFile);
245. BufferedReadercrBR=newBufferedReader(crReader);
246. Map<String,String>res=newTreeMap<String,String>();
247. String[]s;
248. Stringline;
249. while((line=crBR.readLine())!=null){
250. s=line.split("");
251. res.put(s[0],s[1]);
252. }
253. returnres;
254. }
256. /**
257. *@paramargs
258. *@throwsException
259. */
260. publicvoidNaiveBayesianClassifierMain(String[]args)throwsException{
261. //TODOAuto-generatedmethodstub
262. //首先创建训练集和测试集
263. CreateTrainAndTestSamplectt=newCreateTrainAndTestSample();
264. NaiveBayesianClassifiernbClassifier=newNaiveBayesianClassifier();
265. ctt.filterSpecialWords();//根据包含非特征词的文档集生成只包含特征词的文档集到processedSampleOnlySpecial目录下
266. double[]accuracyOfEveryExp=newdouble[10];
267. doubleaccuracyAvg,sum=0;
268. for(inti=0;i<10;i++){//用交叉验证法做十次分类实验，对准确率取平均值
269. StringTrainDir="F:/DataMiningSample/TrainSample"+i;
270. StringTestDir="F:/DataMiningSample/TestSample"+i;
271. StringclassifyRightCate="F:/DataMiningSample/classifyRightCate"+i+".txt";
272. StringclassifyResultFileNew="F:/DataMiningSample/classifyResultNew"+i+".txt";
273. ctt.createTestSamples("F:/DataMiningSample/processedSampleOnlySpecial",0.9,i,classifyRightCate);
274. nbClassifier.doProcess(TrainDir,TestDir,classifyResultFileNew);
275. accuracyOfEveryExp[i]=nbClassifier.computeAccuracy(classifyRightCate,classifyResultFileNew);
276. System.out.println("TheaccuracyforNaiveBayesianClassifierin"+i+"thExpis:"+accuracyOfEveryExp[i]);
277. }
278. for(inti=0;i<10;i++){
279. sum+=accuracyOfEveryExp[i];
280. }
281. accuracyAvg=sum/10;
282. System.out.println("TheaverageaccuracyforNaiveBayesianClassifierinallExpsis:"+accuracyAvg);
284. }
285. }

4 朴素贝叶斯算法对newsgroup文档集做分类的结果

为方便计算混淆矩阵，将类目编号如下

0 alt.atheism
1 comp.graphics
2 comp.os.ms-windows.misc
3comp.sys.ibm.pc.hdwar
4comp.sys.mac.hardwar
5 comp.windows.x
6 misc.forsale
7 rec.autos
8 rec.motorcycles
9 rec.sport.baseball
10 rec.sport.hockey
11 sci.crypt
12 sci.electronics
13 sci.med
14 sci.space
15 soc.religion.christian
16 talk.politics.guns
17 talk.politics.mideast
18 talk.politics.misc
19 talk.religion.misc

贝叶斯算法分类结果-混淆矩阵表示，以交叉验证的第6次实验结果为例，分类准确率达到80.47%

程序运行硬件环境：Intel Core 2 Duo CPU T5750 2GHZ, 2G内存，实验结果如下
取所有词共87554个作为特征词：10次交叉验证实验平均准确率78.19%，用时23min,准确率范围75.65%-80.47%，第6次实验准确率超过80%
取出现次数大于等于4次的词共计30095个作为特征词： 10次交叉验证实验平均准确率77.91%，用时22min，准确率范围75.51%-80.26%，第6次实验准确率超过80%

结论：朴素贝叶斯算法不必去除出现次数很低的词，因为出现次数很低的词的IDF比较 大，去除后分类准确率下降，而计算时间并没有显著减少

5 贝叶斯算法的改进

为了进一步提高贝叶斯算法的分类准确率，可以考虑

(1) 优化特征词的选取策略

(2)改进多项式模型的类条件概率的计算公式，改进为类条件概率P(tk|c)=(类c下单词tk在各个文档中出现过的次数之和+0.001)/（类c下单词总数+训练样本中不重复特征词总数），分子当tk没有出现时，只加0.001，这样更加精确的描述的词的统计分布规律，做此改进后的混淆矩阵如下

可以看到第6次分组实验的准确率提高到84.79%，第7词分组实验的准确率达到85.24%，平均准确率由77.91%提高到了82.23%,优化效果还是很明显的

KNN算法描述及JAVA实现，和两种算法的准确率对比，见数据挖掘- 基于贝叶斯算法及KNN算法的newsgroup18828文档分类器的JAVA实现（下）