简单朴素贝叶斯分类器的思想与算法分析
在数据仓库和数据挖掘应用中，分类是一种非常重要的方法．分类的概念是在已有数据的基础上学会一个分类函数或构造出一个分类模型，即我们通常所说的分类器(Classifier)．该函数或模型能够把数据集合中的数据记录映射到给定类别中的某一个值，从而可以应用于数据预测．目前，分类的主要算法有贝叶斯算法、决策树算法（如ID3、C4.5等）、规则推导、人工神经网络、最近邻算法、支持向量机等等．这些算法在许多现实数据集合上具有较好的预测精度．其中朴素贝叶斯算法具有良好的可解释性等，在实践中的应用最为广泛．
朴素贝叶斯算法是基于统计理论的方法，它能够预测所属类别的概率．简单朴素贝叶斯分类器假设一个指定类别中各属性的取值是相互独立的．这一假设称为给定类别条件下的独立性(Class Conditional Independence)假设，它可以有效减少在构造分类器时所需要的计算量．
简单朴素贝叶斯算法的分类模型是基于Bayes 定理的，下面就简单介绍一下Bayes 定理．设X 为一个类别未知的数据样本，H 为某个假设，C 表示类别集合，若数据样本X 属于一个特定的类别c ，那么分类问题就是决定P (H /X )，即在获得数据样本X 时，H 假设成立的概率．由于P (H ) , P (X ), P (X /H )的概率值可以从（供学习使用的）数据集合中得到，Bayes 定理描述了如何根据P (H ) , P (X ), P (X /H )计算获得的P (H /X )，有关的具体公式定义描述如下：
(/)()
(/)()
P X H P H P H X P X =
(1)
简单朴素贝叶斯分类器进行分类操作的步骤说明如下：
1． 每个数据样本均是由一个n 维特征向量X ={x 1,x 2, ……, x n }来描述其n 个属性（A 1, A 2, ……, A n ）的具体取值．
2． 假设共有m 个不同类别，{C 1, C 2, ……, C n }．给定一个未知类别的数据样本X ，分类器在已知样本X 的情况下，预测X 属于事后概率最大的那个类别．也就是说，朴素贝叶斯分类器将未知类别的样本X 归属到类别C i ，当且仅当：P (C i /X )> P (C j /X ) 其中1≤j ≤m ,j ≠i ．
也就是P (C i /X )最大．其中的类别C i 就称为最大事后概率的假设，根据Bayes 定理可知，
(/)()
(/)()
i i i P X C P C P C X P X =
(2)
3． 由于P (X )对于所有的类别均是相同的，所以，要使公式（2）取得最大值，只需要P (X /C i )P (C i )取最大即可．类别的事前概率P (C i )可以通过公式P (C i )=s i /s 进行估算，其中s i 为训练样本集合类别C i 的个数，s 为整个训练样本集合的大小．
4． 根据所给定包含多个属性的数据集，直接计算P (X /C i )的运算量是非常大的．为实现对P (X /C i )的有效估算，朴素贝叶斯分类器通常都是假设各类别是相互独立的即各属性的取值是相互独立的．即：
1
(/)(/)n
i k i k P X C P x C -=∏
(3)
可以根据训练数据样本估算P (X 1/C i )，P (X 2/C i )，……，P (X n /C i )的值，具体处理方法说明如下：
若A k 是名称型属性,就有P (X k /C i )=s ik /s i ，这里s ik 为训练样本中类别为C i 且属性A k 的取值为v k 的样本数，s i 为训练样本中类别为C i 的样本数．
若A k 是数值型属性,那么假设属性具有高斯分布，概率P (X k /C i )就用概率密度f (X k /C i )代替，即
2
2()2()(,,)C i C
i
i i x k i k C C f x g x μδμδ--
==
(4)
其中， g (x k ,μc i ,δc i )为属性A k 的高斯规范密度函数，μc i ,δ
c i
为训练样本中类别为C i
的属性为A k 的均值和方差．数值型属性的均值计算公式为： x mean =(x 1+x 2+……+x n )/n ，其中x 1, x 2, ……, x n 表示数值型属性的值，n 表示实例个数．数值型属性的方差计算公式为：
222
12()()()1
mean mean n mean x x x x x x Devs n -+-+
+-=
-
(5)
其中x 1, x 2, ……, x n 表示数值型属性的值，x mean 表示方差，n 表示实例个数．
5． 为预测一个样本X 的类别，可对每个类别C i 估算相应的P (X /C i )P (C i )，样本X 归属到类别C i ，当且仅当：P (C i /X )> P (C j /X ) 其中1≤j ≤m , j ≠i ．
也可通过求百分比percent(C i )= P (C i /X )/∑P (C k /X )，百分比最大值对应的类标就位样本X 的类别．
下面就以有关天气问题的数据为例仔细介绍一下朴素贝叶斯分类器进行分类的过程．有关天气的数据如下表所示：
outlook (类型) temperature (温度) humidity (湿度) windy (风) play
(玩) sunny 85 85 False No sunny 80 90 True No overcast 83 86 False Yes rainy 70 96 False Yes rainy 68 80 False Yes rainy 65 70 True No overcast 64 65 True Yes sunny 72 95 False No sunny 69 70 False yes rainy 75 80 False yes sunny 75 70 True yes overcast 72 90 True yes overcast 81 75 False yes rainy 71 91 True
no
概率的表示方法：P (yes/sunny,80,76,false)=0.25就表示在outlook =sunny, temperature =80, humidity =76,windy =false 的条件下paly =yes 条件概率为0.25．
1．求得名称型属性的后验概率
以P (sunny/yes)为例进行详细说明．首先，计算类标为yes 的实例个数为9个，然后计算类标为yes 并且outlook 属性为sunny 的实例个数为2，所以P (sunny/yes)=2/9，这是很自然的事情，为了避免有时该概率值为0，需要对该概率值进行标准化：即分子加上属性outlook 值的个数，也就是3（因为outlook 的值有sunny, rainy, overcast 三个），分母加上1，标准化后的条件概率P (sunny/yes)=(2+1)/(9+3)=3/12．重复上述步骤，可得属性outlook 的后验概率为：
P (sunny/yes)=3/12 P (overcast/yes)=5/12 P (rainy/yes)=4/12 P (sunny/no)=4/8
P (overcast/no)=1/8
P (rainy/no)=3/8
属性windy 的后验概率为： P (false/yes)=7/11 P (false /yes)=4/11 P (false/no)=3/7
P (false /no)=4/7
2．求得数值型属性的均值
数值型属性的均值计算公式为：x mean =(x 1+x 2+……+x n )/n ，其中x 1, x 2, ……, x n 表示数值型属性的值，n 表示实例个数．下面就以求在play =yes 的条件下数值型属性temperature 的均值为例详细说明求解过程：mean- temperature (yes)=(83+70+68+64+69+75+75+72+81)/9=73同理：
mean- temperature (no)=(85+80+65+72+71)/5=74.6
mean- humidity (yes)=(86+96+80+65+70+80+70+90+75)/9=79.1 mean- humidity (no)=(85+90+70+95+91/5=86.2 3．求得数值型属性的方差 数值型属性的方差计算公式为：
222
12()()()1
mean mean n mean x x x x x x Devs n -+-+
+-=
- (6)
其中x 1, x 2, ……, x n 表示数值型属性的值，x mean 表示方差，n 表示实例个数．下面就以求在play =yes 的条件下数值型属性temperature 的方差为例详细说明求解过程．
Devs-temperature (yes)
=((83-73)2+(70-73)2+(68-73)2+(64-73)2+(69-73)2+(75-73)2+(75-73)2+(72-73)2+(81-73)2)/9 =6.2
同理，可求得
Devs-temperature (no)=7.9 Devs-humidity (no)=10.2 Devs-humidity (no)=9.7
4．求得类属性的先验概率
以P(yes)为例进行详细说明．首先计算数据集的实例总数为14，然后计算类标为yes
的实例总数为9，所以P(yes)=9/14，为避免有时该概率值为0，需要对该概率值进行标准化：即分子加上类属性play值的个数，也就是2（因为play的值有yes, no二个），分母加上1，标准化后的条件概率P(yes)=(9+1)/(14+2)=10/16，同理可求得P(no)=(5+1)/(14+2)=6/16．5．根据上述参数计算待分类实例属于每个类的概率，选择概率值最大的类作为待分类实例的类标．下面以实例（sunny，66，90，true）为例说明一下其分类过程：
首先求P(yes/sunny,66,90,true),根据bayes定理和条件独立性假设，
P(yes/sunny,66,90,true)=(P(yes)P(sunny/yes)P(true/yes)f(66/yes)f(90/yes))/P(sunny,66,90,true) 由于P(sunny,66,90,true)为常数，最后求类的百分比的时候可以抵消，可以不加考虑，而P(66/yes)可用概率密度f(66/yes)来代替，这对最后的求类的百分比也没有影响，所以我们只需求P(yes)P(sunny/yes)P(true/yes) f(66/yes) f(90/yes)．而P(yes)，P(sunny/yes)，P(true/yes)已经求得，根据正态分布假设，f(66/yes), f(90/yes) 也很容易求得．
2
2
(mean-temperature(yes))
2(Devs-temperature(yes))
(66/)
x
f yes
-
-
=
(6)
2
2
(6673)
26.20.034
-
-
?
==
同理可求得f(90/yes)=0.0221，所以：
P(yes)P(sunny/yes)P(true/yes)f(66/yes)f(90/yes)=10/16×3/12×0.034×0.0221×4/11=0.000043．
重复上述步骤可得：f(66/no)=0.0291，f(90/no)=0.0380，因而有：
P(no)P(sunny/no)P(true/no) f(66/no) f(90/no)=6/16×4/8×4/7×0.0291×0.0380=0.00018 所以，待分类实例属于类yes的百分比为
probability-of-yes=0.000043/(0.000043+0.000118)=26.7%
probability-of-no=0.000118/(0.000043+0.000118)=73.3%
因此，待分类实例的类属性值为no．
基于本文所述ID3的基本思想，ID3的具体算法是：
下面我们介绍一下其算法实现的有关细节．我们所介绍的ID3程序是在weka系统下利用java语言编写的分类器程序．该程序主要包括以下几个方法：
globalInfo()
返回该分类器的描述字符串．
BuildClassifier(Instances instances)
BuildClassifier()方法从一个训练数据集合instances构造一个分类器．求出所有名称型属性的后验概率，类属性的先验概率，数值属性的均值和方差，为后来的分类工作做准备．
distributionForInstance (Instance instance)
该方法计算待分类实例instance属于各个类标的百分比，并且将各个百分比数值存于一个数组中，最后返回该数组．
toString()
把分类器的参数（均值，方差，各先验概率，各后验概率）以字符串的形式返回．
normalDens(double x, double mean, double stdDev)
该方法用于根据正态分布（均值为mean，方差为stdDev）计算数值型属性当属性值为x时的概率密度．
Main()
当类从命令行被执行时，就会调用main()方法．它只是用所给的命令行选项告诉Weka 的Evaluation类来评估朴素贝叶斯，并且打印所得到的数组．完成这个功能的一行表达式包括在try-catch声明中．try-catch声明用于发现Weka例程或其它Java方法中抛出的各种异常．
附一：朴素贝叶斯源程序及其注解：
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
/* 本程序为免费软件;你可以通过免费软件中心的发布的GNU公共许可的任何版本下下重写或者修改它.
* 开发本程序的目的是是希望它是有用的,但没有任何授权,甚至没有潜在的商用或其它特殊目的的授权.
* 想要了解更多细节,请参阅GNU公共许可.
*在拿到程序的同时,你应该收到GNU公共许可;假如没有的话,请致函免费软件中心Inc., 675 Mass
Ave, Cambridge, MA 02139, USA.
/*
* NaiveBayesSimple.java
* Copyright (C) 1999 Eibe Frank
*
*/
package weka.classifiers.bayes;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import java.io.*;
import java.util.*;
import weka.core.*;
/**
* Class for building and using a simple Naive Bayes classifier.
* Numeric attributes are modelled by a normal distribution. For more
* information, see
*
* Richard Duda and Peter Hart (1973).Pattern
* Classification and Scene Analysis. Wiley, New York.
*
* @author Eibe Frank (eibe@https://www.doczj.com/doc/e0178194.html,)
* @version $Revision: 1.15 $
*/
/*
*创建和使用Naive Bayes分类器的类
*数值型属性均符合正态分布
*/
public class NaiveBayesSimple e X tends Classifier { //分类器的构造函数
public NaiveBayesSimple() { try {
jbInit(); //分类器初始化 } catch (E X ception e X ) {
e X .printStackTrace(); //创建分类器对象时若出现异常则输出堆栈信息 } }
/** All the counts for nominal attributes. 所有名称型属性的计数数组*/
protected double [][][] m_Counts; /*属于每个类每个名称型属性的每个取值的个数数组,其中第一维表示类名,第二维表示属性名,第三维表示属性值,比如m_Counts[yes][outlook][sunny]*/
/** The means for numeric attributes. 数值型属性的均值数组*/
protected double [][] m_Means; /*数值型属性的均值数组,其中第一维表示类名, 第二维表示属性名,比如m_Means[no][temperature], 公式为：
12n
mean x x x x n
++
+=
(7)
*/
/** The standard deviations for numeric attributes.数值型属性的标准差数组 */ protected double [][] m_Devs; /*数值型属性的标准差数组，其中第一维表示类名， 第二维表示属性名，比如m_Devs[no][temperature]，公式为：
222
12()()()1
mean mean n mean x x x x x x Devs n -+-+
+-=
-
(8)
*/
/** The prior probabilities of the classes. 每个类的先验概率数组 */
protected double [] m_Priors; //每个类的先验概率,第一维表示类名,比如m_Prior[yes] /** The instances used for training. 用于训练的实例*/ protected Instances m_Instances; //定义用于训练的实例 /** Constant for normal distribution. 正态分布常量*/
protected static double NORM_CONST = Math.sqrt(2 * Math.PI); // /**
* Returns a string describing this classifier * @return a description of the classifier suitable for * displaying in the e X plorer/e X perimenter gui */ /*
*返回该分类器的描述字符串
*返回适合于图形界面用户的分类器的描述
*/
方法一：
public String globalInfo() { //返回该分类器的描述字符串
return "Class for building and using a simple Naive Bayes classifier."
+"Numeric attributes are modelled by a normal distribution. For more "
+"information, see\n\n"
+"Richard Duda and Peter Hart (1973). Pattern "
+"Classification and Scene Analysis. Wiley, New York.";
}
/**
* Generates the classifier.
*
* @param instances set of instances serving as training data
* @e X ception E X ception if the classifier has not been generated successfully
*/
/**
* 构造分类器
*
* 参数instances表示训练例集合
* 若分类器不正正常构造,则出现异常提示
*/
方法二：
public void buildClassifier(Instances instances) throws E X ception { // 构造分类器
int attInde X = 0; //属性索引
double sum; //属于每个类的每个名称型属性的总个数
if (instances.checkForStringAttributes()) {
throw new UnsupportedAttributeTypeE X ception("Cannot handle string attributes!");
} //若实例集合为string型则提示异常
if (instances.classAttribute().isNumeric()) {
throw new UnsupportedClassTypeE X ception("Naive Bayes: Class is numeric!");
} //若实例集合的类属性为数值型则提示异常
m_Instances = new Instances(instances, 0); //空实例
// Reserve space为数组m_Counts[][][],m_Means[][],m_Devs[][],m_Priors[]分配空间
m_Counts = new double[instances.numClasses()] [instances.numAttributes() - 1][0];
/*属于每个类每个名称型属性的每个取值的个数数组,其中第一维表示类名,第二维表示属性名,第三维表示属性值,instances.numClasses()返回实例集的类值的个数,instances.numAttributes()返回实例集的属性个数,包括类属性,这也是第二维减一的原因,第三维之所以为零是因为后续分配空间的方便*/
m_Means = new double[instances.numClasses()] [instances.numAttributes() - 1];
/*数值型属性的均值数组,其中第一维表示类名, 第二维表示属性名,instances.numClasses()返回实例集的类值的个数, instances.numAttributes()返回实例集的属性个数,包括类属性,这也是第二维减一的原因, */
m_Devs = new double[instances.numClasses()][instances.numAttributes() - 1];
/*数值型属性的标准差数组,其中第一维表示类名, 第二维表示属性名,instances.numClasses()返回实例集的类值的个数, instances.numAttributes()返回实例集的属性个数,包括类属性,这也是第二维减一的原因, */
m_Priors = new double[instances.numClasses()];
/*每个类的先验概率数组,第一维表示类名,instances.numClasses()返回实例集的类值的个数, */
第一步：
Enumeration enu = instances.enumerateAttributes(); //返回一个实例集的属性集
while (enu.hasMoreElements()) { //遍历实例集的每个属性,为m_Counts[][][]分配空间
Attribute attribute = (Attribute) enu.ne X tElement(); //循环从属性集中取每个属性
if (attribute.isNominal()) { //属性若为名称型属性
for (int j = 0; j < instances.numClasses(); j++) { //遍历类
m_Counts[j][attInde X] = new double[attribute.numValues()];
/*为属于每个类的每个名称型属性的每个取值的个数数组m_Counts[][][]预留空
间,attribute.numValues()返回属性attibute 的值的个数. */
}
} else { //属性若为数值型属性 for (int j = 0; j < instances.numClasses(); j++) { //遍历类
m_Counts[j][attInde X ] = new double[1]; //若该属性不为名称型属性,则数组初始
化为长度为1的一维数组
}
}
attInde X ++; //属性索引加一,执行下一个属性 } 第二步：
Enumeration enu = instances.enumerateAttributes(); //返回一个实例集的属性集 while (enu.hasMoreElements()) { //遍历实例集的每个属性,为 m_Counts[][][]分配空间
Attribute attribute = (Attribute) enu.ne X tElement(); //循环从属性集中取每个属性 if (attribute.isNominal()) { //属性若为名称型属性 for (int j = 0; j < instances.numClasses(); j++) { //遍历类
m_Counts[j][attInde X ] = new double[attribute.numValues()];
/*为属于每个类的每个名称型属性的每个取值的个数数组m_Counts[][][]预留空间,attribute.numValues()返回属性attibute 的值的个数. */
}
} else { //属性若为数值型属性 for (int j = 0; j < instances.numClasses(); j++) { //遍历类
m_Counts[j][attInde X ] = new double[1]; //若该属性不为名称型属性,则数组初始
化为长度为1的一维数组
}
}
attInde X ++; //属性索引加一,执行下一个属性 }
/**Compute means 计算数值型属性的均值,公式为:
12n
mean x x x x n
++
+=
(9)
*/ 第三步：
Enumeration enumAtts = instances.enumerateAttributes(); //返回实例集对应的属性的集合
attInde X = 0; //属性索引,用于循环遍历属性
while (enumAtts.hasMoreElements()) { //遍历属性,计算数组 m_Means[][] Attribute attribute = (Attribute) enumAtts.ne X tElement(); //取得一个属性 if (attribute.isNumeric()) { //该属性为数值型属性则继续执行 for (int j = 0; j < instances.numClasses(); j++) { //遍历类标,计算数组 m_Means[][] if (m_Counts[j][attInde X ][0] < 2) { //若该类值对应的数值型属性值个数小于2,则抛
出异常
throw new E X ception("attribute " + https://www.doczj.com/doc/e0178194.html,() + ": less than two values for class " +
instances.classAttribute().value(j));
}
m_Means[j][attInde X ] /= m_Counts[j][attInde X ][0]; //求得该数值型属性的每个类标
对应的均值
}
}
attInde X ++; //属性索引加1,继续执行下一属性 } 第四步：
/* Compute standard deviations 计算数值型属性的标准差,公式为:
222
12()()()1
mean mean n mean x x x x x x Devs n -+-+
+-=
-
(10)
*/
enumInsts = instances.enumerateInstances(); //取得实例集合
while (enumInsts.hasMoreElements()) { /*遍历实例集合,计算数值型属性的m_Devs[][],本循环的结果是在m_Devs[][]存放方差计算公式中的分子,即偏移量的平方和*/
Instance instance = (Instance) enumInsts.ne X tElement(); //从实例集合中取出一个实例 if (!instance.classIsMissing()) { //若该实例类信息完整的话则继续执行 enumAtts = instances.enumerateAttributes(); //取得实例集对应的的属性集 attInde X = 0; //属性索引,用于遍历属性
while (enumAtts.hasMoreElements()) { //遍历属性,计算数值型属性的m_Devs[][]
Attribute attribute = (Attribute) enumAtts.ne X tElement(); //从属性集合中取得一个
属性
if (!instance.isMissing(attribute)) { // 若该实例的该属性没有缺损则继续执行if (attribute.isNumeric()) { //若该属性为数值型属性则继续执行
m_Devs[(int)instance.classValue()][attInde X] +=
(m_Means[(int)instance.classValue()][attInde X]-
instance.value(attribute))*
(m_Means[(int)instance.classValue()][attInde X]-
instance.value(attribute)); //求得偏移量的平方和,即方差就算公式中的分子
}
}
attInde X++; //属性索引加1,继续执行下一属性
}
}
}
enumAtts = instances.enumerateAttributes(); //取得实例集对应的属性集合
attInde X = 0; //属性索引,用于遍历属性
while (enumAtts.hasMoreElements()) { //遍历属性,计算每个数值型属性的方差,结果存于m_Devs[]
Attribute attribute = (Attribute) enumAtts.ne X tElement(); //从属性集合中取得一个属性
if (attribute.isNumeric()) { //若该属性为数值型则继续执行
for (int j = 0; j < instances.numClasses(); j++) { //遍历类,求得该数值型的每个类值的标准差
if (m_Devs[j][attInde X] <= 0) { //若偏移量的平方和为0,则抛出异常,否则计算m_Devs[]
throw new E X ception("attribute " + https://www.doczj.com/doc/e0178194.html,() +
": standard deviation is 0 for class " +
instances.classAttribute().value(j));
}
else {
// 为什么(_Counts[j][attInde X][0] - 1)
m_Devs[j][attInde X] /= m_Counts[j][attInde X][0] - 1; /*利用偏移量的平方和除以数值型属性的个数减1求得标准差的平方*/
m_Devs[j][attInde X] = Math.sqrt(m_Devs[j][attInde X]); //对上一步的结果开方
求得标准差
}
}
}
attInde X++; //属性索引值加上1,继续执行下一属性
}
第五步：
// Normalize counts 标准化数组m_Counts[][][],即把原来个数数组m_Counts[][][]中的个数转化为概率数组m_Counts[][][]
enumAtts = instances.enumerateAttributes(); //取得属性集合
attInde X = 0; //属性索引,用于遍历属性
while (enumAtts.hasMoreElements()) { //遍历属性,求得概率数组m_Counts[][][]
Attribute attribute = (Attribute) enumAtts.ne X tElement(); //从属性集合中取得一个属性
if (attribute.isNominal()) { //若属性为名称型属性则继续执行
for (int j = 0; j < instances.numClasses(); j++) { //遍历类,求得概率数组m_Counts[][][]
sum = Utils.sum(m_Counts[j][attInde X]); /*计算该类对应的实例的总数,函数Utils.sum(m_Counts[yes][Outlook])返回属于"yes"类的实例个数*/
for (int i = 0; i < attribute.numValues(); i++) { //遍历该属性对应的属性值
m_Counts[j][attInde X][i] = (m_Counts[j][attInde X][i] + 1) / (sum + (double)attribute.numValues());
/*计算该类值对应的该属性值的概率(分子为m_Counts[][][]+1,分母为该类值对应的实例的总数加上属性值的个数),比如m_Counts[yes][Outlook][sunny]=(m_Counts[yes][Outlook][sunny]+1)/(sum + 属性值的个数) */ }
}
}
attInde X++; //属性索引加1,继续执行下一属性
}
第六步：
// Normalize priors 标准化先验概率
sum = Utils.sum(m_Priors); //计算实例的总数
for (int j = 0; j < instances.numClasses(); j++) //遍历类
m_Priors[j] = (m_Priors[j] + 1) / (sum + (double)instances.numClasses()); /*计算每个类的先验概率(分子为每个类的实例个数加1,分母为实例集的实例总数加上类标的个数) */ }
/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @e X ception E X ception if distribution can't be computed
*/
/*
*计算给定测试例的类概率分布
*
*参数instance表示待分类的实例
*返回预测概率分布表
*若预测概率分布不能计算的话返回异常
*/
方法三：
public double[] distributionForInstance(Instance instance) throws E X ception {
double [] probs = new double[instance.numClasses()]; //预测概率百分比数组,该数组将要存放的是待定实例属于每个类的概率所占的百分比
int attInde X; //属性标记,用于遍历属性
for (int j = 0; j < instance.numClasses(); j++) { //遍历每个类,计算probs[]
probs[j] = 1; //对数组probs[]进行初始化
Enumeration enumAtts = instance.enumerateAttributes(); //取得待定实例的属性集合
attInde X = 0; //属性标记置0,将要开始遍历
while (enumAtts.hasMoreElements()) { //属性遍历
Attribute attribute = (Attribute) enumAtts.ne X tElement(); //从属性集合中取得一个属性
if (!instance.isMissing(attribute)) { //若给定实例的属性没有缺损则继续执行
if (attribute.isNominal()) { //若该属性为名称型属性则继续执行
probs[j] *= m_Counts[j][attInde X][(int)instance.value(attribute)]; //该属性为名称型属性就直接乘以该类该属性值的概率m_Counts[][][](上面已经计算)
} else {
probs[j] *= normalDens(instance.value(attribute), m_Means[j][attInde X],
m_Devs[j][attInde X]);} //该属性为数值型属性就乘以该类该属性值对应的概率密度(利用正态分布概率密度公式求出)
}
attInde X++; //属性值加1,继续遍历下一属性
}
probs[j] *= m_Priors[j]; //用probs[j]乘以先验概率m_Priors[j],结果表示bayias公式的分子
}
// Normalize probabilities 标准化待定实例属于每个类的概率所占的百分比
Utils.normalize(probs); /*求得待定实例属于每个类的概率所占的百分比,即probs[j]=probs[j]/(probs[0]+probs[1]+probs[2]+......+) */
return probs; //返回
}
/**
* Returns a description of the classifier.
*
* @return a description of the classifier as a string.
*/
/*
*返回分类器的描述
*
*
*/
方法四：
public String toString() {
if (m_Instances == null) {
return "Naive Bayes (simple): No model built yet."; /*若实例集为空,则返回"Naive Bayes (simple): No model built yet." */
}
try {
StringBuffer te X t = new StringBuffer("Naive Bayes (simple)"); //建立字符串缓冲区,用于描述分类器
int attInde X; //建立属性索引索引
for (int i = 0; i < m_Instances.numClasses(); i++) { //遍历类
te X t.append("\n\nClass " + m_Instances.classAttribute().value(i)
+ ": P(C) = "
+ Utils.doubleToString(m_Priors[i], 10, 8)
+ "\n\n"); //在字符串缓冲区存储每个类的先验概率
Enumeration enumAtts = m_Instances.enumerateAttributes(); //取得属性集合
attInde X = 0; //属性标志置0
while (enumAtts.hasMoreElements()) { //遍历属性
Attribute attribute = (Attribute) enumAtts.ne X tElement(); //取得一个属性
te X t.append("Attribute " + https://www.doczj.com/doc/e0178194.html,() + "\n"); //在字符串缓冲区存储每个属性的名称
if (attribute.isNominal()) { //若属性为名称型属性时则继续执行
for (int j = 0; j < attribute.numValues(); j++) { //遍历每个属性值
te X t.append(attribute.value(j) + "\t"); //在字符串缓冲区存储每个值属性的名称
}
te X t.append("\n");
for (int j = 0; j < attribute.numValues(); j++) //遍历每个属性值
te X t.append(Utils.
doubleToString(m_Counts[i][attInde X][j], 10, 8)
+ "\t"); //在字符串缓冲区存储该类对应的每个属性值的概率} else { //若属性为数值型属性则继续执行
te X t.append("Mean: " + Utils.
doubleToString(m_Means[i][attInde X], 10, 8) + "\t"); //若该属性为数值型属性,则在字符串缓冲区存储该类对应的属性的均值
te X t.append("Standard Deviation: "
+ Utils.doubleToString(m_Devs[i][attInde X], 10, 8)); //若该属性为数值型属性,则在字符串缓冲区存储该类对应的属性的方差
}
te X t.append("\n\n");
attInde X++; //属性索引加一,继续执行下一属性
}
}
return te X t.toString(); //返回字符串缓冲区的内容
} catch (E X ception e) {
return "Can't print Naive Bayes classifier!"; //若分类器描述串建立不成功,则返回"Can't print Naive Bayes classifier!"
}
}
/**
* Density function of normal distribution. 给定均值mean,方差stdDev,计算某个属性值X的正态分布概率密度
*/
方法五：
protected double normalDens(double X, double mean, double stdDev) {
/**给定属性值,利用正态分布计算概率密度
2
2
()
2
()
x
P x e
δ
δ
-
=(11) */
double diff = X - mean;
return (1 / (NORM_CONST * stdDev))
* Math.e X p(-(diff * diff / (2 * stdDev * stdDev))); //根据正态分布的公式计算概率密度
}
/**
* Main method for testing this class.
*
* @param argv the options
*/
/*
*测试NaiveBayesSimple类的主函数
*/
方法六：
public static void main(String [] argv) {
Classifier scheme; //分类器声明
try {
scheme = new NaiveBayesSimple(); //构造分类器
System.out.println(Evaluation.evaluateModel(scheme, argv)); //输出结果
/*
函数Evaluation.evaluateModel(scheme, argv)用来根据参数argv设定的评价方式对分类器scheme进行评价,把评价的结果以字符串的形式返回
*/
} catch (E X ception e) {
System.err.println(e.getMessage());
}
}
private void jbInit() throws E X ception {
} //构造分类器的初始化函数
}
附二：其在weather数据集合上构造分类器的过程及运行结果：
构造分类器过程：
第一步
****************
m_Counts[yes][outlook]=new double[3] m_Counts[no][outlook]=new double[3] m_Counts[yes][windy]=new double[2] m_Counts[no][windy]=new double[2]
****************
第二步
****************
m_Counts[yes][outlook][sunny]=2 m_Counts[yes][outlook][overcast]=4
m_Counts[yes][outlook][rainy]=3
m_Counts[yes][windy][true]=3 m_Counts[yes][windy][false]=6
m_Counts[no][outlook][sunny]=3 m_Counts[no][outlook][overcast]=0
m_Counts[no][outlook][rainy]=2
m_Counts[no][windy][true]=3 m_Counts[no][windy][false]=2
m_Means[yes][temperature]=657 m_Means[yes][humidity]=712
m_Means[no][temperature]=373 m_Means[no][humidity]=431
m_Priors[yes]=9 m_Priors[no]=5
****************
第三步
****************
m_Means[yes][temperature]=73 m_Means[yes][humidity]=79.1111
m_Means[no][temperature]=74.6 m_Means[no][humidity]=86.2
****************
第四步
****************
m_Devs[yes][temperature]=6.1644 m_Devs[yes][humidity]=10.2157
m_Devs[no][temperature]=7.893 m_Devs[no][humidity]=9.7314
****************
第五步
****************
m_Counts[yes][outlook][sunny]=0.25 m_Counts[yes][outlook][overcast]=0.4167 m_Counts[yes][outlook][rainy]=0.3333
m_Counts[yes][windy][true]=0.3636 m_Counts[yes][windy][false]=0.6364
m_Counts[no][outlook][sunny]=0.5 m_Counts[no][outlook][overcast]=0.125 m_Counts[no][outlook][rainy]=0.375
m_Counts[no][windy][true]=0.5714 m_Counts[no][windy][false]=0.4286
****************
第六步
****************
m_Priors[yes]=0.625 m_Priors[no]=0.375
****************
运行结果：
Naive Bayes (simple)
Class yes: P(C) = 0.625
Attribute outlook
sunny overcast rainy
0.25 0.41666667 0.33333333
Attribute temperature
Mean: 73 Standard Deviation: 6.164414
Attribute humidity
Mean: 79.11111111 Standard Deviation: 10.21572861
Attribute windy
TRUE FALSE
0.36363636 0.63636364
Class no: P(C) = 0.375
最近发现很多公司招聘数据挖掘的职位都提到贝叶斯分类，其实我不太清楚他们是要求理解贝叶斯分类算法，还是要求只需要通过工具（SPSS，SAS，Mahout）使用贝叶斯分类算法进行分类。 反正不管是需求什么都最好是了解其原理，才能知其然，还知其所以然。我尽量简单的描述贝叶斯定义和分类算法，复杂而有全面的描述参考“数据挖掘：概念与技术”。贝叶斯是一个人，叫（Thomas Bayes），下面这哥们就是。 本文介绍了贝叶斯定理，朴素贝叶斯分类算法及其使用MapReduce实现。 贝叶斯定理 首先了解下贝叶斯定理 P X H P(H) P H X= 是不是有感觉都是符号看起来真复杂，我们根据下图理解贝叶斯定理。 这里D是所有顾客（全集），H是购买H商品的顾客，X是购买X商品的顾客。自然X∩H是即购买X又购买H的顾客。 P(X) 指先验概率，指所有顾客中购买X的概率。同理P(H)指的是所有顾客中购买H 的概率，见下式。
X P X= H P H= P(H|X) 指后验概率，在购买X商品的顾客，购买H的概率。同理P(X|H)指的是购买H商品的顾客购买X的概率，见下式。 X∩H P H|X= X∩H P X|H= 将这些公式带入上面贝叶斯定理自然就成立了。 朴素贝叶斯分类 分类算法有很多，基本上决策树，贝叶斯分类和神经网络是齐名的。朴素贝叶斯分类假定一个属性值对给定分类的影响独立于其他属性值。 描述： 这里有个例子假定我们有一个顾客X（age = middle，income=high，sex =man）：?年龄（age）取值可以是：小（young），中（middle），大（old） ?收入（income）取值可以是：低（low），中（average），高（high） ?性别（sex）取值可以是：男（man），女（woman） 其选择电脑颜色的分类标号H：白色（white），蓝色（blue），粉色（pink） 问题： 用朴素贝叶斯分类法预测顾客X，选择哪个颜色的分类标号，也就是预测X属于具有最高后验概率的分类。 解答： Step 1 也就是说我们要分别计算X选择分类标号为白色（white），蓝色（blue），粉色（pink）的后验概率，然后进行比较取其中最大值。 根据贝叶斯定理
数据挖掘（8）：朴素贝叶斯分类算法原理与实践 隔了很久没有写数据挖掘系列的文章了，今天介绍一下朴素贝叶斯分类算法，讲一下基本原理，再以文本分类实践。 一个简单的例子 朴素贝叶斯算法是一个典型的统计学习方法，主要理论基础就是一个贝叶斯公式，贝叶斯公式的基本定义如下： 这个公式虽然看上去简单，但它却能总结历史，预知未来。公式的右边是总结历史，公式的左边是预知未来，如果把Y看出类别，X看出特征，P(Yk|X)就是在已知特征X的情况下求Yk类别的概率，而对P(Yk|X)的计算又全部转化到类别Yk的特征分布上来。举个例子，大学的时候，某男生经常去图书室晚自习，发现他喜欢的那个女生也常去那个自习室，心中窃喜，于是每天买点好吃点在那个自习室蹲点等她来，可是人家女生不一定每天都来，眼看天气渐渐炎热，图书馆又不开空调，如果那个女生没有去自修室，该男生也就不去，每次男生鼓足勇气说：“嘿，你明天还来不？”,“啊，不知道，看情况”。然后该男生每天就把她去自习室与否以及一些其他情况做一下记录，用Y表示该女生是否去自习室，即Y={去，不去}，X是跟去自修室有关联的一系列条件，比如当天上了哪门主课，蹲点统计了一段时间后，该男生打算今天不再蹲点，而是先预测一下她会不会去，现在已经知道了今天上了常微分方法这么主课，于是计算P(Y=去|常微分方
程)与P(Y=不去|常微分方程)，看哪个概率大，如果P(Y=去|常微分方程) >P(Y=不去|常微分方程)，那这个男生不管多热都屁颠屁颠去自习室了，否则不就去自习室受罪了。P(Y=去|常微分方程)的计算可以转为计算以前她去的情况下，那天主课是常微分的概率P(常微分方程|Y=去)，注意公式右边的分母对每个类别（去/不去）都是一样的，所以计算的时候忽略掉分母，这样虽然得到的概率值已经不再是0~1之间，但是其大小还是能选择类别。 后来他发现还有一些其他条件可以挖，比如当天星期几、当天的天气，以及上一次与她在自修室的气氛，统计了一段时间后，该男子一计算，发现不好算了，因为总结历史的公式： 这里n=3，x(1)表示主课，x(2)表示天气，x(3)表示星期几，x(4)表示气氛，Y仍然是{去，不去}，现在主课有8门，天气有晴、雨、阴三种、气氛有A+,A,B+,B，C五种，那么总共需要估计的参数有8*3*7*5*2=1680个，每天只能收集到一条数据，那么等凑齐1 680条数据大学都毕业了，男生打呼不妙，于是做了一个独立性假设，假设这些影响她去自习室的原因是独立互不相关的，于是 有了这个独立假设后，需要估计的参数就变为，(8+3+7+5)*2 = 46个了，而且每天收集的一条数据，可以提供4个参数，这样该男生就预测越来越准了。
贝叶斯分类器的matlab实现 贝叶斯分类原理： 1)在已知P(Wi)，P(X|Wi)(i=1,2)及给出待识别的X的情况下，根据贝叶斯公式计算出后验概率P(Wi|X) ; 2)根据1)中计算的后验概率值，找到最大的后验概率，则样本X属于该类 举例： 解决方案： 但对于两类来说，因为分母相同，所以可采取如下分类标准：
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %By Shelley from NCUT，April 14th 2011 %Email:just_for_h264@https://www.doczj.com/doc/e0178194.html, %此程序利用贝叶斯分类算法，首先对两类样本进行训练， %进而可在屏幕上任意取点，程序可输出属于第一类，还是第二类%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% clear; close all %读入两类训练样本数据 load data %求两类训练样本的均值和方差 u1=mean(Sample1); u2=mean(Sample2); sigm1=cov(Sample1); sigm2=cov(Sample2); %计算两个样本的密度函数并显示 x=-20:0.5:40; y= -20:0.5:20; [X,Y] = meshgrid(x,y); F1 = mvnpdf([X(:),Y(:)],u1,sigm1); F2 = mvnpdf([X(:),Y(:)],u2,sigm2); P1=reshape(F1,size(X)); P2=reshape(F2,size(X)); figure(2) surf(X,Y,P1) hold on surf(X,Y,P2) shading interp colorbar title('条件概率密度函数曲线'); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %以下为测试部分 %利用ginput随机选取屏幕上的点（可连续取10个点）
朴素贝叶斯 优点：在数据较少的情况下仍然有效，可以处理多类别问题 缺点：对于输入数据的准备方式较为敏感 适用数据类型：标称型数据 贝叶斯准则： 使用朴素贝叶斯进行文档分类 朴素贝叶斯的一般过程 （1）收集数据：可以使用任何方法。本文使用RSS源 （2）准备数据：需要数值型或者布尔型数据 （3）分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好 （4）训练算法：计算不同的独立特征的条件概率 （5）测试算法：计算错误率 （6）使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。 准备数据：从文本中构建词向量 摘自机器学习实战。 [['my','dog','has','flea','problems','help','please'], 0 ['maybe','not','take','him','to','dog','park','stupid'], 1 ['my','dalmation','is','so','cute','I','love','him'], 0
['stop','posting','stupid','worthless','garbage'], 1 ['mr','licks','ate','my','steak','how','to','stop','him'], 0 ['quit','buying','worthless','dog','food','stupid']] 1 以上是六句话，标记是0句子的表示正常句，标记是1句子的表示为粗口。我们通过分析每个句子中的每个词，在粗口句或是正常句出现的概率，可以找出那些词是粗口。 在bayes.py文件中添加如下代码： [python]view plaincopy 1.# coding=utf-8 2. 3.def loadDataSet(): 4. postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please' ], 5. ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'], 6. ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'], 7. ['stop', 'posting', 'stupid', 'worthless', 'garbage'], 8. ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'], 9. ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']] 10. classVec = [0, 1, 0, 1, 0, 1] # 1代表侮辱性文字，0代表正常言论 11.return postingList, classVec 12. 13.def createVocabList(dataSet): 14. vocabSet = set([]) 15.for document in dataSet: 16. vocabSet = vocabSet | set(document) 17.return list(vocabSet) 18. 19.def setOfWords2Vec(vocabList, inputSet): 20. returnVec = [0] * len(vocabList) 21.for word in inputSet: 22.if word in vocabList: 23. returnVec[vocabList.index(word)] = 1 24.else: 25.print"the word: %s is not in my Vocabulary!" % word 26.return returnVec
用于运动识别的聚类特征融合方法和装置 提供了一种用于运动识别的聚类特征融合方法和装置，所述方法包括：将从被采集者的加速度信号 中提取的时频域特征集的子集内的时频域特征表示成以聚类中心为基向量的线性方程组；通过求解线性方程组来确定每组聚类中心基向量的系数；使用聚类中心基向量的系数计算聚类中心基向量对子集的方差贡献率；基于方差贡献率计算子集的聚类中心的融合权重；以及基于融合权重来获得融合后的时频域特征集。 加速度信号 →时频域特征 →以聚类中心为基向量的线性方程组 →基向量的系数 →方差贡献率 →融合权重 基于特征组合的步态行为识别方法 本发明公开了一种基于特征组合的步态行为识别方法，包括以下步骤：通过加速度传感器获取用户在行为状态下身体的运动加速度信息；从上述运动加速度信息中计算各轴的峰值、频率、步态周期和四分位差及不同轴之间的互相关系数；采用聚合法选取参数组成特征向量；以样本集和步态加速度信号的特征向量作为训练集，对分类器进行训练，使的分类器具有分类步态行为的能力；将待识别的步态加速度信号的所有特征向量输入到训练后的分类器中，并分别赋予所属类别，统计所有特征向量的所属类别，并将出现次数最多的类别赋予待识别的步态加速度信号。实现简化计算过程，降低特征向量的维数并具有良好的有效性的目的。 传感器 →样本及和步态加速度信号的特征向量作为训练集 →分类器具有分类步态行为的能力 基于贝叶斯网络的核心网故障诊断方法及系统 本发明公开了一种基于贝叶斯网络的核心网故障诊断方法及系统，该方法从核心网的故障受理中心采集包含有告警信息和故障类型的原始数据并生成样本数据，之后存储到后备训练数据集中进行积累，达到设定的阈值后放入训练数据集中；运用贝叶斯网络算法对训练数据集中的样本数据进行计算，构造贝叶斯网络分类器；从核心网的网络管理系统采集含有告警信息的原始数据，经贝叶斯网络分类器计算获得告警信息对应的故障类型。本发明，利用贝叶斯网络分类器构建故障诊断系统，实现了对错综复杂的核心网故障进行智能化的系统诊断功能，提高了诊断的准确性和灵活性，并且该系统构建于网络管理系统之上，易于实施，对核心网综合信息处理具有广泛的适应性。 告警信息和故障类型 →训练集 —>贝叶斯网络分类器
朴素贝叶斯分类器的应用 作者：阮一峰 日期：2013年12月16日 生活中很多场合需要用到分类，比如新闻分类、病人分类等等。 本文介绍朴素贝叶斯分类器（Naive Bayes classifier），它是一种简单有效的常用分类算法。 一、病人分类的例子 让我从一个例子开始讲起，你会看到贝叶斯分类器很好懂，一点都不难。 某个医院早上收了六个门诊病人，如下表。 症状职业疾病 打喷嚏护士感冒 打喷嚏农夫过敏 头痛建筑工人脑震荡 头痛建筑工人感冒 打喷嚏教师感冒 头痛教师脑震荡 现在又来了第七个病人，是一个打喷嚏的建筑工人。请问他患上感冒的概率有多大？ 根据贝叶斯定理： P(A|B) = P(B|A) P(A) / P(B)
可得 P(感冒|打喷嚏x建筑工人) = P(打喷嚏x建筑工人|感冒) x P(感冒) / P(打喷嚏x建筑工人) 假定"打喷嚏"和"建筑工人"这两个特征是独立的，因此，上面的等式就变成了 P(感冒|打喷嚏x建筑工人) = P(打喷嚏|感冒) x P(建筑工人|感冒) x P(感冒) / P(打喷嚏) x P(建筑工人) 这是可以计算的。 P(感冒|打喷嚏x建筑工人) = 0.66 x 0.33 x 0.5 / 0.5 x 0.33 = 0.66 因此，这个打喷嚏的建筑工人，有66%的概率是得了感冒。同理，可以计算这个病人患上过敏或脑震荡的概率。比较这几个概率，就可以知道他最可能得什么病。 这就是贝叶斯分类器的基本方法：在统计资料的基础上，依据某些特征，计算各个类别的概率，从而实现分类。 二、朴素贝叶斯分类器的公式 假设某个体有n项特征（Feature），分别为F1、F2、...、F n。现有m个类别（Category），分别为C1、C2、...、C m。贝叶斯分类器就是计算出概率最大的那个分类，也就是求下面这个算式的最大值： P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C) / P(F1F2...Fn) 由于 P(F1F2...Fn) 对于所有的类别都是相同的，可以省略，问题就变成了求 P(F1F2...Fn|C)P(C) 的最大值。
贝叶斯分类器 一、朴素贝叶斯分类器原理 目标： 计算(|)j P C t 。注：t 是一个多维的文本向量 分析： 由于数据t 是一个新的数据，(|)j P C t 无法在训练数据集中统计出来。因此需要转换。根据概率论中的贝叶斯定理 (|)()(|)() P B A P A P A B P B = 将(|)j P C t 的计算转换为： (|)() (|)()j j j P t C P C P C t P t = （1） 其中，()j P C 表示类C j 在整个数据空间中的出现概率，可以在训练集中统计出来（即用C j 在训练数据集中出现的频率()j F C 来作为概率()j P C 。但(|)j P t C 和()P t 仍然不能统计出来。 首先，对于(|)j P t C ，它表示在类j C 中出现数据t 的概率。根据“属性独立性假设”，即对于属于类j C 的所有数据，它们个各属性出现某个值的概率是相互独立的。如，判断一个干部是否是“好干部”（分类）时，其属性“生活作风＝好”的概率（P(生活作风＝好|好干部)）与“工作态度＝好”的概率（P(工作态度＝好|好干部)）是独立的，没有潜在的相互关联。换句话说，一个好干部，其生活作风的好坏与其工作态度的好坏完全无关。我们知道这并不能反映真实的情况，因而说是一种“假设”。使用该假设来分类的方法称为“朴素贝叶斯分类”。 根据上述假设，类j C 中出现数据t 的概率等于其中出现t 中各属性值的概率的乘积。即： (|)(|)j k j k P t C P t C =∏ （2） 其中，k t 是数据t 的第k 个属性值。
其次，对于公式（1）中的 ()P t ，即数据t 在整个数据空间中出现的概率，等于它在各分类中出现概率的总和，即： ()(|)j j P t P t C =∑ （3） 其中，各(|)j P t C 的计算就采用公式（2）。 这样，将（2）代入（1），并综合公式（3）后，我们得到： (|)()(|),(|)(|)(|) j j j j j j k j k P t C P C P C t P t C P t C P t C ?=????=??∑∏其中： （4） 公式（4）就是我们最终用于判断数据t 分类的方法。其依赖的条件是：从训练数据中统计出(|)k j P t C 和()j P C 。 当我们用这种方法判断一个数据的分类时，用公式（4）计算它属于各分类的概率，再取其中概率最大的作为分类的结果。 改进的P(t | C j )的计算方法： 摒弃t(t 1, t 2 , t 3,)中分量相互独立的假设， P(t 1, t 2 , t 3,| C j ) = P(t 1 | C j ) * P(t 2 | t 1, C j ) * P(t 3| t 1, t 2 ,C j ) 注意： P(t 3| t 1, t 2 ,C j )
朴素贝叶斯分类器 Naive Bayesian Classifier C语言实现 信息电气工程学院 计算本1102班 20112212465 马振磊
1.贝叶斯公式 通过贝叶斯公式，我们可以的知在属性F1-Fn成立的情况下，该样本属于分类C的概率。 而概率越大，说明样本属于分类C的可能性越大。 若某样本可以分为2种分类A，B。 要比较P(A | F1,F2......) 与P(B | F1,F2......)的大小只需比较，P(A)P(F1,F2......| A) ,与P(B)P(F1,F2......| B) 。因为两式分母一致。 而P(A)P(F1,F2......| A)可以采用缩放为P(A)P(F1|A)P(F2|A).......(Fn|A) 因此，在分类时，只需比较每个属性在分类下的概率累乘，再乘该分类的概率即可。 分类属性outlook 属性temperature 属性humidity 属性wind no sunny hot high weak no sunny hot high strong yes overcast hot high weak yes rain mild high weak yes rain cool normal weak no rain cool normal strong yes overcast cool normal strong no sunny mild high weak yes sunny cool normal weak yes rain mild normal weak yes sunny mild normal strong yes overcast mild high strong yes overcast hot normal weak no rain mild high strong 以上是根据天气的4种属性，某人外出活动的记录。 若要根据以上信息判断 (Outlook = sunny,Temprature = cool,Humidity = high,Wind = strong) 所属分类。 P(yes| sunny ,cool ,high ,strong )=P(yes)P(sunny|yes)P(cool |yes)P(high|yes)P(strong|yes)/K P(no| sunny ,cool ,high ,strong )=P(no)P(sunny|no)P(cool |no)P(high|no)P(strong|no)/K K为缩放因子，我们只需要知道两个概率哪个大，所以可以忽略K。 P(yes)=9/14 P(no)=5/14 P(sunny|yes)=2/9 P(cool|yes)=1/3 P(high|yes)=1/3 P(strong|yes)=1/3 P(sunny|no)=3/5 P(cool|no)=1/5 P(high|no)=4/5 P(strong|no)=3/5 P(yes| sunny ,cool ,high ,strong)=9/14*2/9*1/3*1/3*1/3=0.00529 P(no| sunny ,cool ,high ,strong )=5/14*3/5*1/5*4/5*3/5=0.20571 No的概率大，所以该样本实例属于no分类。
朴素贝叶斯算法详细总结 朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法，是经典的机器学习算法之一，处理很多问题时直接又高效，因此在很多领域有着广泛的应用，如垃圾邮件过滤、文本分类等。也是学习研究自然语言处理问题的一个很好的切入口。朴素贝叶斯原理简单，却有着坚实的数学理论基础，对于刚开始学习算法或者数学基础差的同学们来说，还是会遇到一些困难，花费一定的时间。比如小编刚准备学习的时候，看到贝叶斯公式还是有点小害怕的，也不知道自己能不能搞定。至此，人工智能头条特别为大家寻找并推荐一些文章，希望大家在看过学习后，不仅能消除心里的小恐惧，还能高效、容易理解的get到这个方法，从中获得启发没准还能追到一个女朋友，脱单我们是有技术的。贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。 ▌分类问题综述 对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你看到一个人，你的脑子下意识判断他是学生还是社会上的人；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱、”之类的话，其实这就是一种分类操作。 既然是贝叶斯分类算法，那么分类的数学描述又是什么呢？ 从数学角度来说，分类问题可做如下定义： 已知集合C=y1,y2,……,yn 和I=x1,x2,……,xn确定映射规则y=f()，使得任意xi∈I有且仅有一个yi∈C，使得yi∈f(xi)成立。 其中C叫做类别集合，其中每一个元素是一个类别，而I叫做项集合（特征集合），其中每一个元素是一个待分类项，f叫做分类器。分类算法的任务就是构造分类器f。 分类算法的内容是要求给定特征，让我们得出类别，这也是所有分类问题的关键。那么如何由指定特征，得到我们最终的类别，也是我们下面要讲的，每一个不同的分类算法，对
最近在面试中，除了基础& 算法& 项目之外，经常被问到或被要求介绍和描述下自己所知道的几种分类或聚类算法，而我向来恨对一个东西只知其皮毛而不得深入，故写一个有关聚类& 分类算法的系列文章以作为自己备试之用(尽管貌似已无多大必要，但还是觉得应该写下以备将来常常回顾思考)。行文杂乱，但侥幸若能对读者也起到一定帮助，则幸甚至哉。 本分类& 聚类算法系列借鉴和参考了两本书，一本是Tom M.Mitchhell所著的机器学习，一本是数据挖掘导论，这两本书皆分别是机器学习& 数据挖掘领域的开山or杠鼎之作，读者有继续深入下去的兴趣的话，不妨在阅读本文之后，课后细细研读这两本书。除此之外，还参考了网上不少牛人的作品(文末已注明参考文献或链接)，在此，皆一一表示感谢。 本分类& 聚类算法系列暂称之为Top 10 Algorithms in Data Mining，其中，各篇分别有以下具体内容： 1. 开篇：决策树学习Decision Tree，与贝叶斯分类算法(含隐马可夫模型HMM)； 2. 第二篇：支持向量机SVM(support vector machine)，与神经网络ANN； 3. 第三篇：待定... 说白了，一年多以前，我在本blog内写过一篇文章，叫做：数据挖掘领域十大经典算法初探(题外话：最初有个出版社的朋友便是因此文找到的我，尽管现在看来，我离出书日期仍是遥遥无期)。现在，我抽取其中几个最值得一写的几个算法每一个都写一遍，以期对其有个大致通透的了解。 OK，全系列任何一篇文章若有任何错误，漏洞，或不妥之处，还请读者们一定要随时不吝赐教& 指正，谢谢各位。 基础储备：分类与聚类 在讲具体的分类和聚类算法之前，有必要讲一下什么是分类，什么是聚类，都包含哪些具体算法或问题。 常见的分类与聚类算法 简单来说，自然语言处理中，我们经常提到的文本分类便就是一个分类问题，一般的模式分类方法都可用于文本分类研究。常用的分类算法包括：朴素的贝叶斯分类算法(native Bayesian classifier)、基于支持向量机(SVM)的分类器，k-最近邻法(k-nearest neighbor，
贝叶斯分类器工作原理原理 贝叶斯分类器是一种比较有潜力的数据挖掘工具，它本质上是一 种分类手段，但是它的优势不仅仅在于高分类准确率，更重要的是，它会通过训练集学习一个因果关系图（有向无环图）。如在医学领域，贝叶斯分类器可以辅助医生判断病情，并给出各症状影响关系，这样医生就可以有重点的分析病情给出更全面的诊断。进一步来说，在面对未知问题的情况下，可以从该因果关系图入手分析，而贝叶斯分类器此时充当的是一种辅助分析问题领域的工具。如果我们能够提出一种准确率很高的分类模型，那么无论是辅助诊疗还是辅助分析的作用都会非常大甚至起主导作用，可见贝叶斯分类器的研究是非常有意义的。 与五花八门的贝叶斯分类器构造方法相比，其工作原理就相对简 单很多。我们甚至可以把它归结为一个如下所示的公式： 其中实例用T{X0，X1，…，Xn-1}表示，类别用C 表示，AXi 表示Xi 的 父节点集合。 选取其中后验概率最大的c ，即分类结果，可用如下公式表示 () ()()() ()( ) 0011111 00011111 0|,, ,|,,, ,C c |,i i n n n i i X i n n n i i X i P C c X x X x X x P C c P X x A C c P X x X x X x P P X x A C c ---=---========= ===∝===∏∏()() 1 0arg max |A ,i n c C i i X i c P C c P X x C c -∈=====∏
上述公式本质上是由两部分构成的：贝叶斯分类模型和贝叶斯公式。下面介绍贝叶斯分类器工作流程： 1．学习训练集，存储计算条件概率所需的属性组合个数。 2．使用1中存储的数据，计算构造模型所需的互信息和条件互信息。 3．使用2种计算的互信息和条件互信息，按照定义的构造规则，逐步构建出贝叶斯分类模型。 4．传入测试实例 5．根据贝叶斯分类模型的结构和贝叶斯公式计算后验概率分布。6．选取其中后验概率最大的类c，即预测结果。 其流程图如下所示：
作业6 编程题实验报告 （一）实验内容： 编程实现朴素贝叶斯分类器，假设输入输出都是离散变量。用讲义提供的训练数据进行试验，观察分类器在 121.x x m ==时，输出如何。如果在分类器中加入Laplace 平滑（取?=1） ，结果是否改变。 （二）实验原理： 1）朴素贝叶斯分类器： 对于实验要求的朴素贝叶斯分类器问题，假设数据条件独立，于是可以通过下式计算出联合似然函数： 12(,,)()D i i p x x x y p x y =∏ 其中，()i p x y 可以有给出的样本数据计算出的经验分布估计。 在实验中，朴素贝叶斯分类器问题可以表示为下面的式子： ~1*arg max ()()D i y i y p y p x y ==∏ 其中，~ ()p y 是从给出的样本数据计算出的经验分布估计出的先验分布。 2）Laplace 平滑： 在分类器中加入Laplace 平滑目的在于，对于给定的训练数据中，有可能会出现不能完全覆盖到所有变量取值的数据，这对分类器的分类结果造成一定误差。 解决办法，就是在分类器工作前，再引入一部分先验知识，让每一种变量去只对应分类情况与统计的次数均加上Laplace 平滑参数?。依然采用最大后验概率准则。 （三）实验数据及程序： 1）实验数据处理： 在实验中，所用数据中变量2x 的取值，对应1,2,3s m I === 讲义中所用的两套数据，分别为cover all possible instances 和not cover all possible instances 两种情况，在实验中，分别作为训练样本，在给出测试样本时，输出不同的分类结果。 2）实验程序： 比较朴素贝叶斯分类器，在分类器中加入Laplace 平滑（取?=1）两种情况，在编写matlab 函数时，只需编写分类器中加入Laplace 平滑的函数，朴素贝叶斯分类器是?=0时，特定的Laplace 平滑情况。 实现函数：[kind] =N_Bayes_Lap(X1,X2,y,x1,x2,a) 输入参数：X1,X2，y 为已知的训练数据； x1,x2为测试样本值； a 为调整项，当a=0时，就是朴素贝叶斯分类器，a=1时，为分类器中加入Laplace 平滑。 输出结果：kind ，输出的分类结果。
朴素贝叶斯分类算法 一．贝叶斯分类的原理 贝叶斯分类器的分类原理是通过某对象的先验概率，利用贝叶斯公式计算出其后验概率，即该对象属于某一类的概率，选择具有最大后验概率的类作为该对象所属的类。也就是说，贝叶斯分类器是最小错误率意义上的优化。 贝叶斯分类器是用于分类的贝叶斯网络。该网络中应包含类结点C，其中C 的取值来自于类集合( c1 , c2 , ... , cm)，还包含一组结点X = ( X1 , X2 , ... , Xn)，表示用于分类的特征。对于贝叶斯网络分类器，若某一待分类的样本D，其分类特征值为x = ( x1 , x2 , ... , x n) ，则样本D 属于类别ci 的概率P( C = ci | X1 = x1 , X2 = x 2 , ... , Xn = x n) ，( i = 1 ,2 , ... , m) 应满足下式： P( C = ci | X = x) = Max{ P( C = c1 | X = x) , P( C = c2 | X = x ) , ... , P( C = cm | X = x ) } 贝叶斯公式： P( C = ci | X = x) = P( X = x | C = ci) * P( C = ci) / P( X = x) 其中，P( C = ci) 可由领域专家的经验得到,而P( X = x | C = ci) 和P( X = x) 的计算则较困难。 二．贝叶斯伪代码 整个算法可以分为两个部分，“建立模型”与“进行预测”，其建立模型的伪代码如下： numAttrValues 等简单的数据从本地数据结构中直接读取 构建几个关键的计数表 for(为每一个实例) { for( 每个属性 ){ 为 numClassAndAttr 中当前类，当前属性，当前取值的单元加 1 为 attFrequencies 中当前取值单元加 1 } } 预测的伪代码如下： for(每一个类别){ for(对每个属性 xj){ for(对每个属性 xi){
算法杂货铺——分类算法之贝叶斯网络(Bayesian networks) 2010-09-18 22:50 by EricZhang(T2噬菌体), 2561 visits, 网摘, 收藏, 编辑 2.1、摘要 在上一篇文章中我们讨论了朴素贝叶斯分类。朴素贝叶斯分类有一个限制条件，就是特征属性必须有条件独立或基本独立（实际上在现实应用中几乎不可能做到完全独立）。当这个条件成立时，朴素贝叶斯分类法的准确率是最高的，但不幸的是，现实中各个特征属性间往往并不条件独立，而是具有较强的相关性，这样就限制了朴素贝叶斯分类的能力。这一篇文章中，我们接着上一篇文章的例子，讨论贝叶斯分类中更高级、应用范围更广的一种算法——贝叶斯网络（又称贝叶斯信念网络或信念网络）。 2.2、重新考虑上一篇的例子 上一篇文章我们使用朴素贝叶斯分类实现了SNS社区中不真实账号的检测。在那个解决方案中，我做了如下假设： i、真实账号比非真实账号平均具有更大的日志密度、各大的好友密度以及更多的使用真实头像。 ii、日志密度、好友密度和是否使用真实头像在账号真实性给定的条件下是独立的。 但是，上述第二条假设很可能并不成立。一般来说，好友密度除了与账号是否真实有关，还与是否有真实头像有关，因为真实的头像会吸引更多人加其为好友。因此，我们为了获取更准确的分类，可以将假设修改如下： i、真实账号比非真实账号平均具有更大的日志密度、各大的好友密度以及更多的使用真实头像。 ii、日志密度与好友密度、日志密度与是否使用真实头像在账号真实性给定的条件下是独立的。 iii、使用真实头像的用户比使用非真实头像的用户平均有更大的好友密度。
基于朴素贝叶斯的文本分类算法 摘要：常用的文本分类方法有支持向量机、K-近邻算法和朴素贝叶斯。其中朴素贝叶斯具有容易实现，运行速度快的特点，被广泛使用。本文详细介绍了朴素贝叶斯的基本原理，讨论了两种常见模型：多项式模型（MM）和伯努利模型（BM），实现了可运行的代码，并进行了一些数据测试。 关键字：朴素贝叶斯；文本分类 Text Classification Algorithm Based on Naive Bayes Author: soulmachine Email：soulmachine@https://www.doczj.com/doc/e0178194.html, Blog：https://www.doczj.com/doc/e0178194.html, Abstract:Usually there are three methods for text classification: SVM、KNN and Na?ve Bayes. Na?ve Bayes is easy to implement and fast, so it is widely used. This article introduced the theory of Na?ve Bayes and discussed two popular models: multinomial model(MM) and Bernoulli model(BM) in details, implemented runnable code and performed some data tests. Keywords: na?ve bayes; text classification 第1章贝叶斯原理 1.1 贝叶斯公式 设A、B是两个事件，且P(A)>0，称 为在事件A发生的条件下事件B发生的条件概率。 乘法公式P(XYZ)=P(Z|XY)P(Y|X)P(X) 全概率公式P(X)=P(X|Y 1)+ P(X|Y 2 )+…+ P(X|Y n ) 贝叶斯公式 在此处，贝叶斯公式，我们要用到的是
机器学习实验报告 朴素贝叶斯学习和分类文本 (2015年度秋季学期) 一、实验内容 问题：通过朴素贝叶斯学习和分类文本 目标：可以通过训练好的贝叶斯分类器对文本正确分类二、实验设计
实验原理与设计： 在分类（classification）问题中，常常需要把一个事物分到某个类别。一个事物具有很多属性，把它的众多属性看做一个向量，即x=(x1,x2,x3,…,xn)，用x这个向量来代表这个事物。类别也是有很多种，用集合Y=y1,y2,…ym表示。如果x属于y1类别，就可以给x打上y1标签，意思是说x属于y1类别。 这就是所谓的分类(Classification)。x的集合记为X，称为属性集。一般X和Y 的关系是不确定的，你只能在某种程度上说x有多大可能性属于类y1，比如说x有80%的可能性属于类y1，这时可以把X和Y看做是随机变量，P(Y|X)称为Y的后验概率（posterior probability），与之相对的，P(Y)称为Y的先验概率（prior probability）1。在训练阶段，我们要根据从训练数据中收集的信息，对X和Y的每一种组合学习后验概率P(Y|X)。分类时，来了一个实例x，在刚才训练得到的一堆后验概率中找出所有的P(Y|x)，其中最大的那个y，即为x所属分类。根据贝叶斯公式，后验概率为 在比较不同Y值的后验概率时，分母P(X)总是常数，因此可以忽略。先验概率P(Y)可以通过计算训练集中属于每一个类的训练样本所占的比例容易地估计。 在文本分类中，假设我们有一个文档d∈X，X是文档向量空间(document space)，和一个固定的类集合C={c1,c2,…,cj}，类别又称为标签。显然，文档向量空间是一个高维度空间。我们把一堆打了标签的文档集合
实验报告 一． 实验目的 1、 掌握密度函数监督参数估计方法； 2、 掌握贝叶斯最小错误概率分类器设计方法。 二．实验内容 对于一个两类分类问题，设两类的先验概率相同，（12()()P P ωω=），两类的类条件概率密度函数服从二维正态分布，即 11(|)~(,)P N ω1x μΣ2(|)~(,)P N ω22x μΣ 其中，=[3,6]T 1μ，0.50=02???? ?? 1Σ，=[3,-2]T 2μ，20=02??????2Σ。 1） 随机产生两类样本； 2） 设计最大似然估计算法对两类类条件概率密度函数进行估计； 3） 用2）中估计的类条件概率密度函数设计最小错误概率贝叶斯分类器，实现对两类样本的分类。 三．实验原理 最大似然估计 1． 作用
在已知试验结果（即是样本）的情况下，用来估计满足这些样本分布的参数，把可能性最大的那个参数θ作为真实* θ的参数估计。 2. 离散型 设X 为离散型随机变量， 12=(,,...,)k θθθθ为多维参数向量，如果随机变量 1,...,n X X 相互独立且概率计算式为 {}1(;,...) i i i k P x p x θθX ==，则可得概率函数为 {}1111,...,(;,...)n n n i k i P x x p x θθ=X =X ==∏，在 12=(,,...,)k θθθθ固定时，上式表示11,...,n n x x X =X =的概率；当 11,...,n n x x X =X =已知的时候，它又变成 12=(,,...,)k θθθθ的函数，可以把它记为12111(,,...,)(;,...,)n k k i L p x θθθθθ==∏，称此函数为似然函数。似然函数值的大小意味着该样本值出现的可能性的大小，既然已经得到了样本值 11,...,n n x x X =X =，那么它出现的可能性应该是较大的，即似然 函数的值也应该是比较大的，因而最大似然估计就是选择使12(,,...,) k L θθθ达到最 大值的那个θ作为真实* θ的估计。 3. 连续型 设X 为连续型随机变量，其概率密度函数为1(;,...) i k f x θθ， 1,...n x x 为从该总体中 抽出的样本，同样的如果 1,...n x x 相互独立且同分布，于是样本的联合概率密度为12111(,,...,)(;,...,) n k k i L f x θθθθθ==∏。大致过程同离散型一样。 最大后验概率判决准则 先验概率 1() P ω和 2() P ω，类条件概率密度 1(|) P X ω和 2(|) P X ω，根据贝叶斯公 式1 (|)() (|)(|)() i i i c j j j p x P P X p X P ωωωωω== ∑，当 12(|)(|) P P ωω>x x 则可以下结论，在x 条件 下，事件 1ω出现的可能性大，将x 判定为1ω类。
实验二 朴素贝叶斯分类 一、实验目的 通过实验，加深对统计判决与概率密度估计基本思想、方法的认识，了解影响Bayes 分类器性能的因素，掌握基于Bayes 决策理论的随机模式分类的原理和方法。 二、实验内容 设计Bayes 决策理论的随机模式分类器，用matlab 实现。 三、方法手段 Bayes 分类器的基本思想是依据类的概率、概密，按照某种准则使分类结果从统计上讲是最佳的。换言之，根据类的概率、概密将模式空间划分成若干个子空间，在此基础上形成模式分类的判决规则。准则函数不同，所导出的判决规则就不同，分类结果也不同。使用哪种准则或方法应根据具体问题来确定。 四、Bayes 算法 朴素贝叶斯分类或简单贝叶斯分类的工作过程如下： （1）每个数据样本用一个n 维特征向量{}12,,...n X x x x =表示，分别描述对n 个属性A 1,A 2,…A n 样本的n 个度量。 （2）假定有m 个类C 1,C 2,…C m 。给定一个未知的数据样本X （即没有类标号），分类法将预测X 属于具有最高后验概率（条件X 下）的类。即是说，朴素贝叶斯分类将未知的样本分配给类C i ，当且仅当 》 ()(),1,i j P C X P C X j m j i >≤≤≠ （） 这样，最大化()i P C X 。其()i P C X 最大的类C i 称为最大后验假定。根据贝叶斯定理 ()()()P X H P H P H X P X = ， ()()() () i i i P X C P C P C X P X = （） （3）由于P(X)对于所有类为常数，只需要()()i i P X C P C 最大即可。如果类的先验概率未知，则通常假定这些类是等概率的，即P(C 1)=P(C 2)=…=P(C m )。并据此只对()i P X 最大化。否则，最大化()()i i P X C P C 。注意，类的先验概率可以用()i i P C s s =计算其中 s i 是类C i 中的训练样本数，而s 是训练样本总数。 （4）给定具有许多属性的数据集，计算()i P X 的开销可能非常大。为降低计算 ()i P X 的开销，可以做类条件独立的朴素假定。给定样本的类标号，假定属性值相互条件