贝叶斯定理：

对于随机事件A和B：A发生的概率为P（A），B发生的概率为P（B），在B发生的情况下，A发生的概率为P（A|B）。A和B一起发生的联合概率为P（AB）。有：P（A|B） X P(B) = P(AB) = P(B|A) X P(A)，则有：

P(A|B) = P(B|A)P(A) / P(B)

文本分类（Text Categorization）是指计算机将一片文档归于预先给定的某一类或几类的过程。文本分类的特征提取过程是分词。目前比较好的中文分词器有中科院的ictclas，庖丁，IK等等。经过分词后，每个词就是一个特征。分词中可以自己配置停用词库，扩展词库等。特征选择有诸如TF-IDF，CHI等特征选择算法，就不在此赘述。

朴素贝叶斯计算先验概率P（C）和条件概率P（X|C）的方法有两种：多项式模型和伯努利模型。两者在计算的时候有两点差别：多项式会统计词频，而伯努利认为单词出现就记为1，没出现记为0，可以看到一个是基于词频，一个是基于文档频率；伯努利在分类时，将词库中的没有出现在待分类文本的词作为反方考虑。

在计算条件概率时，当待分类文本中的某个词没有出现在词库中时，概率为0，会导致很严重的问题，需要考虑拉普拉斯平滑（laplace smoothing）：它是将所有词出现的次数+1，再进行统计。

再一个问题就是概率太小而词数太多，会超double，用log将乘法转成加法。

伯努利朴素贝叶斯算法伪代码如下：

伯努利朴素贝叶斯代码：

Java代码  

1. /**

2. * @author zhongmin.yzm

3. * 语料训练并载入内存

4. * */

5. public class TrainingDataManager {

6. /** 特征索引 */

7. private Map<String, Integer> termIndex;

8. /** 类索引 */

9. private Map<String, Integer> classIndex;

10. /** 索引-类名 */

11. public List<String>          className;

12. /**类的个数*/

13. private int                  numClasses = 0;

14. /**训练样本的所有特征(出现多次只算一个)*/

15. private int                  vocabulary = 0;

16. /**训练文本总数*/

17. private int                  DocsNum    = 0;

18. /**属于某类的文档个数*/

19. private int[]                classDocs;

20. /**类别c中包含属性 x的训练文本数量*/

21. private int[][]              classKeyMap;

22. /** 标志位: 分类时的优化 */

23. private static boolean       flag[];

24. private void buildIndex(List<List<String>> contents, List<String> labels) {

25. classIndex = new HashMap<String, Integer>();

26. termIndex = new HashMap<String, Integer>();

27. className = new ArrayList<String>();

28. Integer idTerm = new Integer(-1);

29. Integer idClass = new Integer(-1);

30. DocsNum = labels.size();

31. for (int i = 0; i < DocsNum; ++i) {

32. List<String> content = contents.get(i);

33. String label = labels.get(i);

34. if (!classIndex.containsKey(label)) {

35. idClass++;

36. classIndex.put(label, idClass);

37. className.add(label);

38. }

39. for (String term : content) {

40. if (!termIndex.containsKey(term)) {

41. idTerm++;

42. termIndex.put(term, idTerm);

43. }

44. }

45. }

46. vocabulary = termIndex.size();

47. numClasses = classIndex.size();

48. }

49. public void startTraining(List<List<String>> contents, List<String> labels) {

50. buildIndex(contents, labels);

51. //去重

52. List<List<Integer>> contentsIndex = new ArrayList<List<Integer>>();

53. for (int i = 0; i < DocsNum; ++i) {

54. List<Integer> contentIndex = new ArrayList<Integer>();

55. List<String> content = contents.get(i);

56. for (String str : content) {

57. Integer wordIndex = termIndex.get(str);

58. contentIndex.add(wordIndex);

59. }

60. Collections.sort(contentIndex);

61. int num = contentIndex.size();

62. List<Integer> tmp = new ArrayList<Integer>();

63. for (int j = 0; j < num; ++j) {

64. if (j == 0 || contentIndex.get(j - 1) != contentIndex.get(j)) {

65. tmp.add(contentIndex.get(j));

66. }

67. }

68. contentsIndex.add(tmp);

69. }

70. //

71. classDocs = new int[numClasses];

72. classKeyMap = new int[numClasses][vocabulary];

73. flag = new boolean[vocabulary];

74. for (int i = 0; i < DocsNum; ++i) {

75. List<Integer> content = contentsIndex.get(i);

76. String label = labels.get(i);

77. Integer labelIndex = classIndex.get(label);

78. classDocs[labelIndex]++;

79. for (Integer wordIndex : content) {

80. classKeyMap[labelIndex][wordIndex]++;

81. }

82. }

83. }

84. /** 分类 时间复杂度 O(c*v) */

85. public String classify(List<String> text) {

86. double maxPro = Double.NEGATIVE_INFINITY;

87. int resultIndex = 0;

88. //标记待分类文本中哪些特征 属于 特征表

89. for (int i = 0; i < vocabulary; ++i)

90. flag[i] = false;

91. for (String term : text) {

92. Integer wordIndex = termIndex.get(term);

93. if (wordIndex != null)

94. flag[wordIndex] = true;

95. }

96. //对特征集中的每个特征: 若出现在待分类文本中,直接计算;否则作为反方参与

97. for (int classIndex = 0; classIndex < numClasses; ++classIndex) {

98. double pro = Math.log10(getPreProbability(classIndex));

99. for (int wordIndex = 0; wordIndex < vocabulary; ++wordIndex) {

100. if (flag[wordIndex])

101. pro += Math.log10(getClassConditionalProbability(classIndex, wordIndex));

102. else

103. pro += Math.log10(1 - getClassConditionalProbability(classIndex, wordIndex));

104. }

105. if (maxPro < pro) {

106. maxPro = pro;

107. resultIndex = classIndex;

108. }

109. }

110. return className.get(resultIndex);

111. }

112. /** 先验概率: 类C包含的文档数/总文档数 */

113. private double getPreProbability(int classIndex) {

114. double ret = 0.0;

115. ret = 1.0 * classDocs[classIndex] / DocsNum;

116. return ret;

117. }

118. /** 条件概率: 类C中包含关键字t的文档个数/类C包含的文档数 */

119. private double getClassConditionalProbability(int classIndex, int termIndex) {

120. int NCX = classKeyMap[classIndex][termIndex];

121. int N = classDocs[classIndex];

122. double ret = (NCX + 1.0) / (N + DocsNum);

123. return ret;

124. }

125. }