用C++完成贝叶斯分类算法的设计与实现

Posted 2023-04-09

因为是本人的毕业设计，因此需要开题报告，类似于如何去完成该课题，流程是那些，有源代码是最好不过了，跪求，哪位大侠有的话可以发本人邮箱：[e-mail]，不胜感激~~~

1. 收集大量的垃圾邮件和非垃圾邮件，建立垃圾邮件集和非垃圾邮件集。 2. 提取邮件主题和邮件体中的独立字符串，例如 ABC32，￥234等作为TOKEN串并统计提取出的TOKEN串出现的次数即字频。按照上述的方法分别处理垃圾邮件集和非垃圾邮件集中的所有邮件。 3. 每一个邮件集对应一个哈希表，hashtable_good对应非垃圾邮件集而hashtable_bad对应垃圾邮件集。表中存储TOKEN串到字频的映射关系。 4. 计算每个哈希表中TOKEN串出现的概率P=（某TOKEN串的字频）/（对应哈希表的长度）。 5. 综合考虑hashtable_good和hashtable_bad，推断出当新来的邮件中出现某个TOKEN串时，该新邮件为垃圾邮件的概率。数学表达式为： A 事件 ---- 邮件为垃圾邮件； t1,t2 …….tn 代表 TOKEN 串 则 P （ A|ti ）表示在邮件中出现 TOKEN 串 ti 时，该邮件为垃圾邮件的概率。 设 P1 （ ti ） = （ ti 在 hashtable_good 中的值） P2 （ ti ） = （ ti 在 hashtable_ bad 中的值） 则 P （ A|ti ） =P2 （ ti ） /[ （ P1 （ ti ） +P2 （ ti ） ] ； 6. 建立新的哈希表hashtable_probability存储TOKEN串ti到P（A|ti）的映射 7. 至此，垃圾邮件集和非垃圾邮件集的学习过程结束。根据建立的哈希表 hashtable_probability可以估计一封新到的邮件为垃圾邮件的可能性。 当新到一封邮件时，按照步骤2，生成TOKEN串。查询hashtable_probability得到该TOKEN 串的键值。 假设由该邮件共得到N个TOKEN 串，t1,t2…….tn,hashtable_probability中对应的值为 P1 ， P2 ， ……PN ， P(A|t1 ,t2, t3……tn) 表示在邮件中同时出现多个TOKEN串t1,t2……tn时，该邮件为垃圾邮件的概率。 由复合概率公式可得 P(A|t1 ,t2, t3……tn)=（P1*P2*……PN）/[P1*P2*……PN+（1-P1）*（1-P2）*……（1-PN）] 当 P(A|t1 ,t2, t3……tn) 超过预定阈值时，就可以判断邮件为垃圾邮件。

参考资料：百度一下

参考技术A 你算法都有了，那报告上无非是写写啥是贝叶斯分类算法，自己选用什么开发工作实现，大体上的代码结构（设计那些类，类的功能和层次关系）不就ok了吗，老师又不会看你代码，你就是写一坨字母上去估计也能通过开题报告。天下文章一大抄，奉劝兄台要善于综合利用。本回答被提问者采纳 参考技术B t接口代码(实现Analyzer):
1using System;
2using System.Collections.Generic;
3using System.Text;
4using System.IO;
5
6using Lucene.Net.Analysis;
7using Lucene.Net.Analysis.Standard;
8
9namespace AspxOn.Search.FenLei
10
11
12 /**//// <summary>
13 /// ICTCLAS分词组件for Lucene.net接口
14 /// </summary>
15 public class ICTCLASAnalyzer : Analyzer
16
17 //定义要过滤的词
18 public static readonly System.String[] CHINESE_ENGLISH_STOP_WORDS = new string[428];
19 public string NoisePath = Environment.CurrentDirectory + "\\data\\stopwords.txt";
20
21 public ICTCLASAnalyzer()
22
23 StreamReader reader = new StreamReader(NoisePath, System.Text.Encoding.Default);
24 string noise = reader.ReadLine();
25 int i = 0;
26
27 while (!string.IsNullOrEmpty(noise))
28
29 CHINESE_ENGLISH_STOP_WORDS[i] = noise;
30 noise = reader.ReadLine();
31 i++;
32
33
34
35
36 /**//**//**//// Constructs a filtered by a @link
37 /// StandardFilter, a and a .
38 ///
39 public override TokenStream TokenStream(System.String fieldName, System.IO.TextReader reader)
40
41 TokenStream result = new ICTCLASTokenizer(reader);
42 result = new StandardFilter(result);
43 result = new LowerCaseFilter(result);
44 result = new StopFilter(result, CHINESE_ENGLISH_STOP_WORDS);
45 return result;
46
47
48
49
50

ICTCLAS中文分词for Lucene.Net接口代码(实现Tokenizer):

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5using Lucene.Net.Analysis;
6using SharpICTCLAS;
7using System.IO;
8
9namespace AspxOn.Search.FenLei
10
11 public class ICTCLASTokenizer : Tokenizer
12
13 int nKind = 1;
14 List<WordResult[]> result;
15 int startIndex = 0;
16 int endIndex = 0;
17 int i = 1;
18 /**//**/
19 /**////
20 /// 待分词的句子
21 ///
22 private string sentence;
23 /**//**/
24 /**//// Constructs a tokenizer for this Reader.
25 public ICTCLASTokenizer(System.IO.TextReader reader)
26
27 this.input = reader;
28 sentence = input.ReadToEnd();
29 sentence = sentence.Replace("\r\n", "");
30 string DictPath = Path.Combine(Environment.CurrentDirectory, "Data") + Path.DirectorySeparatorChar;
31 //Console.WriteLine("正在初始化字典库，请稍候");
32 WordSegment wordSegment = new WordSegment();
33 wordSegment.InitWordSegment(DictPath);
34 result = wordSegment.Segment(sentence, nKind);
35
36
37 /**//**/
38 /**//// 进行切词，返回数据流中下一个token或者数据流为空时返回null
39 ///
40 public override Token Next()
41
42 Token token = null;
43 while (i < result[0].Length - 1)
44
45 string word = result[0][i].sWord;
46 endIndex = startIndex + word.Length - 1;
47 token = new Token(word, startIndex, endIndex);
48 startIndex = endIndex + 1;
49
50 i++;
51 return token;
52
53
54 return null;
55
56
57
58
中文分词器代码：

1using System;
2using System.Collections.Generic;
3using System.Text;
4using System.IO;
5
6using Lucene.Net.Analysis;
7using Lucene.Net.Analysis.Standard;
8using Lucene.Net.Documents;
9
10using Lucene.Net.Analysis.Cn;
11using Lucene.Net.Analysis.KTDictSeg;
12
13namespace AspxOn.Search.FenLei
14
15 /**//// <summary>
16 /// 中文分词器
17 /// </summary>
18 public class ChineseSpliter
19
20 public static string Split(string text, string splitToken)
21
22 StringBuilder sb = new StringBuilder();
23
24 Analyzer an = new ICTCLASAnalyzer();
25
26 //TokenStream ts = an.ReusableTokenStream("", new StringReader(text));
27
28 TokenStream ts = an.TokenStream("", new StringReader(text));
29
30 Lucene.Net.Analysis.Token token;
31 while ((token = ts.Next()) != null)
32
33 sb.Append(splitToken + token.TermText());
34
35
36 return sb.ToString().Substring(1);
37
38
39
先验概率计算代码：

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace AspxOn.Search.FenLei
6
7 /**//// <summary>
8 /// 先验概率（事先概率）计算
9 /// </summary>
10 public class PriorProbability
11
12 private static TrainingDataManager tdm = new TrainingDataManager();
13
14 /**//// <summary>
15 /// 计算先验概率
16 /// </summary>
17 /// <param name="c">给定的分类</param>
18 /// <returns>给定条件下的先验概率</returns>
19 public static float CaculatePc(string c)
20
21 float ret = 0F;
22 float Nc = tdm.GetTrainFileCountOfCertainClassification(c);
23 float N = tdm.GetTrainFileCount();
24 ret = Nc / N;
25 return ret;
26
27
28

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace AspxOn.Search.FenLei
6
7 /**//// <summary>
8 /// 条件概率计算
9 /// </summary>
10 public class ClassConditionalProbability
11
12
13 private static TrainingDataManager tdm = new TrainingDataManager();
14 private static float M = 0F;
15
16 /**//// <summary>
17 /// 类条件概率
18 /// </summary>
19 /// <param name="x">给定关键字</param>
20 /// <param name="c">给定分类</param>
21 /// <returns></returns>
22 public static float CaculatePxc(string x, string c)
23
24 float ret = 0F;
25 float Nxc = tdm.GetCountContainKeyOfClassification(c, x);
26 float Nc = tdm.GetTrainFileCountOfCertainClassification(c);
27 float V = tdm.GetTrainingClassifications().Length;
28
29 ret = (Nxc + 1) / (Nc + V + M);//为避免出现0这样的极端情况，进行加权处理
30
31 return ret;
32
33
34

Python机器学习（十五）朴素贝叶斯算法原理与代码实现

 

算法原理

朴素贝叶斯是经典的机器学习算法之一，也是为数不多的基于概率论的分类算法。朴素贝叶斯原理简单，也很容易实现，多用于文本分类，比如垃圾邮件过滤。

该算法的优点在于简单易懂、学习效率高、在某些领域的分类问题中能够与决策树、神经网络相媲美。

但由于该算法以自变量之间的独立（条件特征独立）性和连续变量的正态性假设为前提，就会导致算法精度在某种程度上受影响。

marco 博客https://www.cnblogs.com/marc01in/p/4775440.html的简单例子能够很形象说明其核心思想：

 

现在出现一个新的点new_point (x,y)，其分类未知。我们可以用p1(x,y)表示数据点(x,y)属于红色一类的概率，同时也可以用p2(x,y)表示数据点(x,y)属于蓝色一类的概率。那要把new_point归在红、蓝哪一类呢？

我们提出这样的规则：

如果p1(x,y) > p2(x,y)，则(x,y)为红色一类。

如果p1(x,y) <p2(x,y),  则(x,y)为蓝色一类。

换人类的语言来描述这一规则：选择概率高的一类作为新点的分类。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

用条件概率的方式定义这一贝叶斯分类准则：

如果p(red|x,y) > p(blue|x,y), 则(x,y)属于红色一类。

如果p(red|x,y) < p(blue|x,y), 则(x,y)属于蓝色一类。

也就是说，在出现一个需要分类的新点时，我们只需要计算这个点的

max(p(c1 | x,y),p(c2 | x,y),p(c3 | x,y)...p(cn| x,y))。其对于的最大概率标签，就是这个新点的分类啦。

那么问题来了，对于分类i 如何求解p(ci| x,y)？

没错，就是贝叶斯公式：

    

如果要确定某个样本归属于哪一类，则需要计算出归属不同类的概率，再从中挑选出最大的概率。

我们把上面的贝叶斯公式写出这样，也许你能更好的理解：

        

而这个公式告诉我们，需要计算最大的后验概率，只需要计算出分子的最大值即可，而不同水平的概率P(C)非常容易获得，故难点就在于P(X|C)的概率计算。而问题的解决，正是聪明之处，即贝叶斯假设变量X间是条件独立的，故而P(X|C)的概率就可以计算为：

      

 

一般流程

1. 收集数据：提供数据源（一般训练数据与测试数据比例为7:3）；

2. 准备数据：将数据源解析成词条向量；

3. 分析数据：检查词条确保解析的正确性；

4. 训练算法：用训练数据生成的分类器；

5. 测试算法：用训练生成的分类器预测测试数据的结果，对比真实结果，计算错误率，衡量分类器的准确度。

6. 使用算法：通过错误率来评估分类器；

代码实现（python）

myBayes.py：代码实现文件，代码已做了详细注释，包含3个示例：

1. 过滤侮辱文档

2. 过滤垃圾邮件

3. 寻找在线RSS源排名靠前的单词

  1 # -*- coding: utf-8 -*-
  2 """
  3 Created on Mon Nov  5 14:02:18 2018
  4 
  5 @author: weixw
  6 """
  7 
  8 import numpy as np
  9 
 10 def loadDataSet():
 11     postingList=[[\'my\', \'dog\', \'has\', \'flea\', \'problems\', \'help\', \'please\'],
 12                  [\'maybe\', \'not\', \'take\', \'him\', \'to\', \'dog\', \'park\', \'stupid\'],
 13                  [\'my\', \'dalmation\', \'is\', \'so\', \'cute\', \'I\', \'love\', \'him\'],
 14                  [\'stop\', \'posting\', \'stupid\', \'worthless\', \'garbage\'],
 15                  [\'mr\', \'licks\', \'ate\', \'my\', \'steak\', \'how\', \'to\', \'stop\', \'him\'],
 16                  [\'quit\', \'buying\', \'worthless\', \'dog\', \'food\', \'stupid\']]
 17     classVec = [0,1,0,1,0,1]    #1 侮辱性, 0 not
 18     return postingList,classVec
 19 
 20 #输入：原始数据集
 21 #功能：创建一个包含所有原始数据集词语集合，这个列表中词语不重复。
 22 #输出：不重复词列表
 23 def createVocabList(dataSet):
 24     #创建一个空集合，这个集合中内容唯一，并且可动态扩展。
 25     vocabSet = set([])  #create empty set
 26     #获取每一行数据list
 27     for document in dataSet:
 28         #将每一行数据取出，合并到vocabSet集合中，vocabSet会自动过滤重复词
 29         vocabSet = vocabSet | set(document) #union of the two sets
 30     #将集合转化为列表list
 31     return list(vocabSet)
 32 
 33 #输入：列表集合（唯一），输入集合（一行文档内容）
 34 \'\'\'
 35 功能：检查输入集合单词是否在列表集合中，在则在列表集合对应位置设置为1，否则为0
 36 将每个词在文档中出现与否作为一个特征，称为词集模型(set-of-words model)
 37 \'\'\'
 38 #输出：向量列表（判断输入文档中每个单词是否在词汇样本中）
 39 def setOfWords2Vec(vocabList, inputSet):
 40     #初始化为0，长度为vocabList长度的集合
 41     returnVec = [0]*len(vocabList)
 42     #检查inputSet中每个单词是否在vocabList集合中，在则在vocabList对应位置置1，否则不作处理
 43     for word in inputSet:
 44         if word in vocabList:
 45             returnVec[vocabList.index(word)] = 1
 46         else: print ("the word: %s is not in my Vocabulary!" % word)
 47     return returnVec
 48 
 49 #输入:trainMatrix（文档数组（处理为0,1向量）），trainCategory（列标签数组）
 50 \'\'\'
 51 功能：生成分类器（获取最佳训练参数权值）
 52 训练样本以及测试样本大小要相同，通过标签指定行词语类别来计算训练样本对应位置权重参数值。
 53 这里有个假定前提，每一行词语是相互独立的，也就有
 54 p(w/c1) = p(w0,w1,w2...wn/c1) = p(w0/c1)*p(w1/c1)*p(w2/c1)***p(wn/c1)
 55 \'\'\'
 56 #输出：p0Vect（文档中非侮辱性词语概率），p1Vect（侮辱性词语概率），pAbusive（标签类中侮辱性标签概率） 
 57 def trainNB0(trainMatrix,trainCategory):
 58     #数据集行大小
 59     numTrainDocs = len(trainMatrix)
 60     #数据集列大小
 61     numWords = len(trainMatrix[0])
 62     #标签类中侮辱性标签概率（0：非侮辱，1：侮辱）
 63     #引入float强制转换是使结果为小数
 64     pAbusive = sum(trainCategory)/float(numTrainDocs)
 65     #初始化为数据集列大小的单位矩阵
 66     #p0Num：非侮辱性矩阵，p1Num：侮辱性矩阵
 67     p0Num = np.ones(numWords); p1Num = np.ones(numWords)      #change to ones() 
 68     #使np.log > 1，防止np.log分母为0而无法计算
 69     
 70     #防止分母为0。因为计算每个子项概率采用的对数log（防止下溢出），是以2为底的，如果pADDenom = 2.0，则避免了分母为0的可能。
 71     p0Denom = 2.0; p1Denom = 2.0                        #change to 2.0
 72     #遍历数据集每一行
 73     for i in range(numTrainDocs):
 74         #如果标签类中该行定义为侮辱性标签
 75         if trainCategory[i] == 1:
 76             #将数据集中指定侮辱性行对应数据迭代求和，结果还是矩阵
 77             #统计数据集中指定侮辱性行存在的词语（为1），并求和，结果是数字
 78             p1Num += trainMatrix[i]
 79             p1Denom += sum(trainMatrix[i])
 80         #如果标签类中该行定义为非侮辱性标签
 81         else:
 82             #将数据集中指定非侮辱性行对应数据迭代求和，结果还是矩阵
 83             p0Num += trainMatrix[i]
 84             #统计数据集中指定非侮辱性行存在的词语（为1），并求和，结果是数字
 85             p0Denom += sum(trainMatrix[i])
 86     #这里有个假定前提，每一行词语是相互独立的，也就有
 87     #p(w/c1) = p(w0,w1,w2...wn/c1) = p(w0/c1)*p(w1/c1)*p(w2/c1)***p(wn/c1)
 88     #计算数据集中侮辱性词语概率p(w/c1)
 89     #取对数是防止下溢出，由于概率因子都非常小，当计算乘积p(W0/Ci)*p(W1/Ci)*p(W2/Ci)...*p(Wn/Ci)时，得到结果会更小，
 90     #四舍五入会为0，所以采用log(a*b) = log(a) + log(b)
 91     p1Vect = np.log(p1Num/p1Denom)          #change to log()
 92     #计算数据集中非侮辱性词语概率p(w/c0)
 93     p0Vect = np.log(p0Num/p0Denom)          #change to log()
 94 
 95     return p0Vect,p1Vect,pAbusive
 96 \'\'\'
 97 输入：vec2Classify（测试文档（0.1向量）），p0Vec（非侮辱性概率训练参数），
 98 p1Vec（侮辱性概率训练参数），pClass1（标签类中侮辱性标签概率）
 99 功能：比较侮辱性和非侮辱性后验概率，判断测试文档所属类别
100 朴素贝叶斯公式：p(Ci/W) = p(W/Ci)p(Ci)/p(W)
101 输出：1：侮辱性文档 0：非侮辱性文档
102 \'\'\'
103 def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
104     #计算文档属于侮辱性标签概率p(c1/w)
105     #np.log是以2为底，求和实际是相乘
106     p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)    #element-wise mult
107     #计算文档属于非侮辱性标签概率p(c0/w)
108     p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
109     if p1 > p0:
110         #u"侮辱文档"
111         return 1 
112     else: 
113         #u"非侮辱文档"
114         return 0 
115  
116 #输入：列表集合（唯一），输入集合（文档或词汇表）
117 \'\'\'
118 功能：检查输入集合单词是否在列表集合中，在则在列表集合对应位置加1
119 如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，
120 称为词袋模型(bags-of-words model)。在词袋中，每个单子可以出现多次，而在词集中，每个词只能出现一次。
121 \'\'\'
122 #输出：向量列表（统计输入文档中每个单词在词汇样本中个数）
123 def bagOfWords2VecMN(vocabList, inputSet):
124     returnVec = [0]*len(vocabList)
125     for word in inputSet:
126         if word in vocabList:
127             returnVec[vocabList.index(word)] += 1
128     return returnVec
129 
130 #测试（过滤网站恶意留言）
131 def testingNB():
132     #获取数据集（数组），标签列表
133     listOPosts,listClasses = loadDataSet()
134     #将数据集数组转化为内容唯一的数据集list
135     #创建一个包含所有原始数据集词语集合，这个列表中词语不重复。
136     myVocabList = createVocabList(listOPosts)
137     trainMat=[]
138     #遍历数据集中每一行数组，将词语转化为向量0,1（1：该行数据中词语在myVocabList存在）
139     #词语文档 => 向量文档
140     for postinDoc in listOPosts:
141         trainMat.append(bagOfWords2VecMN(myVocabList, postinDoc))
142     #计算分类器训练参数
143     p0V,p1V,pAb = trainNB0(np.array(trainMat),np.array(listClasses))
144     #测试1
145     testEntry = [\'love\', \'my\', \'dalmation\']
146     #词语文档 => 向量文档
147     thisDoc = np.array(bagOfWords2VecMN(myVocabList, testEntry))
148     #结果分类
149     print (testEntry,\'classified as: \',  u"0 （非侮辱文档）" if(classifyNB(thisDoc,p0V,p1V,pAb) == 0)  else u"1（侮辱文档）")
150     #测试2
151     testEntry = [\'stupid\', \'garbage\']
152     #词语文档 => 向量文档
153     thisDoc = np.array(bagOfWords2VecMN(myVocabList, testEntry))
154     #结果分类
155     print (testEntry,\'classified as: \', u"0 （非侮辱文档）" if(classifyNB(thisDoc,p0V,p1V,pAb) == 0)  else u"1（侮辱文档）")
156     
157 
158 #输入：文本字符串
159 \'\'\'
160 功能：文本处理，过滤掉一些不需要的字符（?，&，=...）以及URL中en和py这样的单词，
161 并全部转换为小写
162 \'\'\'
163 #输出：处理后的字符串集合
164 def textParse(bigString):    #input is big string, #output is word list
165     import re
166     #分隔符是除单词、数字外的任意字符都是分隔符
167     #string.split()只是以" "分隔
168     #正则匹配
169     listOfTokens = re.split(r\'\\W*\', bigString)
170     #过滤掉少于2个字符的字符串，并全部转换为小写
171     return [tok.lower() for tok in listOfTokens if len(tok) > 2] 
172 
173 #测试（过滤垃圾邮件）
174 #说明：50封邮件中随机选取10封作为测试样本，剩下40封作为训练样本
175 def spamTest():
176     docList=[]; classList = []; fullText =[]
177     #email文件下26封正常邮件，26封垃圾邮件
178     for i in range(1,26):
179         #准备数据，文本预处理
180         wordList = textParse(open(\'email/spam/%d.txt\' % i).read())
181         #保存为list（list递增 二维）
182         docList.append(wordList)
183         #保存为array（扩展 一维）
184         fullText.extend(wordList)
185         #标记邮件类别，垃圾邮件
186         classList.append(1)
187         #准备数据，文本预处理
188         wordList = textParse(open(\'email/ham/%d.txt\' % i).read())
189         #保存为list（list递增 二维）
190         docList.append(wordList)
191         #保存为array（扩展 一维）
192         fullText.extend(wordList)
193         #标记邮件类别，正常邮件
194         classList.append(0)
195     #将数据集数组转化为内容唯一的数据集list
196     #创建一个包含所有原始数据集词语集合，这个列表中词语不重复。
197     vocabList = createVocabList(docList)#create vocabulary
198     #python3.x   range返回的是range对象，不返回数组对象
199     trainingSet = list(range(50)); testSet=[]           #create test set
200     #随机选取10封邮件作为测试数据
201     for i in range(10):
202         #在50封邮件中随机抽选
203         randIndex = int(np.random.uniform(0,len(trainingSet)))
204         #保存list中
205         testSet.append(trainingSet[randIndex])
206         #选取并保存后，去除该邮件对应的索引
207         del(trainingSet[randIndex])  
208     trainMat=[]; trainClasses = []
209     #剩余40封邮件作为训练样本，训练分类器参数
210     for docIndex in trainingSet:#train the classifier (get probs) trainNB0
211         #将处理后的文本转化为词向量（词袋模型），并保存
212         trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
213         #保存对应标签
214         trainClasses.append(classList[docIndex])
215     #训练，获取最终训练参数
216     p0V,p1V,pSpam = trainNB0(np.array(trainMat),np.array(trainClasses))
217     
218     errRate = 0.0;iterNumber = 20
219     #迭代20次
220     for i in range(iterNumber):
221         errorCount = 0
222         #遍历测试数据集
223         for docIndex in testSet:        #classify the remaining items
224             #将处理后的测试数据转化为词向量（词袋模型），并保存
225             wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
226             #将训练后的参数导入分类器，输入测试的词向量，与测试数据对应标签比较，统计错误率
227             result = classifyNB(np.array(wordVector),p0V,p1V,pSpam)
228             if result != classList[docIndex]:
229                 errorCount += 1
230 #                print ("docIndex:%d,classification error:%s"%(docIndex, docList[docIndex]))
231                 print ("docIndex:%d,classification error, predict result: %d mark class result %d:"%(docIndex, result, classList[docIndex]))
232         #每次错误率
233         print (\'the error rate is: \',float(errorCount)/len(testSet))
234         errRate += float(errorCount)/len(testSet)  
235     #平均错误率
236     print ("the mean error rate is:", float(errRate)/iterNumber)
237     
238     #return vocabList,fullText
239     
240 
241 #输入：vocabList（去重词汇表），fullText（未去重所有单词）
242 \'\'\'
243 功能：计算高频词汇。遍历词汇表中每个词并统计它在文本中出现的次数，然后根据出现次数从高到低对词典进行排序,
244 最后返回排序最高的30个单词。
245 \'\'\'
246 #输出：按降序排列的前30个单词以及单词对应出现次数
247 def calcMostFreq(vocabList,fullText):
248     import operator
249     freqDict = {}
250     #遍历词汇表中每个单词，统计每个单词出现的次数，然后以键值对保存
251     for token in vocabList:
252         freqDict[token]=fullText.count(token)
253     #以单词出现次数倒叙排列
254     sortedFreq = sorted(freqDict.items(), key=operator.itemgetter(1), reverse=True) 
255     #返回前30个键值对对象
256     return sortedFreq[:30]       
257 
258 #输入：feed1（RSS1源），feed0（RSS0源）
259 \'\'\'
260 功能：
261 1 根据朴素贝叶斯公式生成分类器;
262 2 判断随机抽选测试数据属于源RSS0或者RSS1;
263 3 计算分类错误率；
264 \'\'\'
265 #输出：vocabList（词汇表），p0V（源RSS0概率），p1V（源RSS1概率）
266 def localWords(feed1,feed0):
267 #    import feedparser
268     docList=[]; classList = []; fullText =[]
269     #获取源RSS0,RSS1最小行大小
270     minLen = min(len(feed1[\'entries\']),len(feed0[\'entries\']))
271     for i in range(minLen):
272         #文本处理
273         wordList = textParse(feed1[\'entries\'][i][\'summary\'])
274         #保存list（二维）
275         docList.append(wordList)
276         #保存array(一维)
277         fullText.extend(wordList)
278         #添加标签
279         classList.append(1) #NY is class 1
280          #文本处理
281         wordList = textParse(feed0[\'entries\'][i][\'summary\'])
282         #保存list（二维）
283         docList.append(wordList)
284         #保存array(一维)
285         fullText.extend(wordList)
286         #添加标签
287         classList.append(0)
288     #生成词汇表
289     vocabList = createVocabList(docList)#create 
以上是关于用C++完成贝叶斯分类算法的设计与实现的主要内容，如果未能解决你的问题，请参考以下文章
 
 Java代码利用朴素贝叶斯分类算法实现信息分类
 实现 | 朴素贝叶斯模型算法研究与实例分析
 第五篇：朴素贝叶斯分类算法原理分析与代码实现
 Java代码利用朴素贝叶斯分类算法实现信息分类
 机器学习——朴素贝叶斯算法
 朴素贝叶斯分类算法介绍及python代码实现案例