人工智能实验三朴素贝叶斯分类实验.docx

实验三：分类算法实验
智能1402 201408070221 李帅玲
目录
实验三：分类算法实验 1
一．实验目的 1
二．实验的硬件、软件平台 2
三．实验内容及步骤 2
四、思考题： 2
五．实验报告 2
（一）算法的基本原理 2
（二）实验框架与结果 4
1.汽车评估数据集 4
2.程序框架 6
3.实验结果 6
（三）实验分析和思考题 6
（四）实验源代码 7

一．实验目的
1. 了解朴素贝叶斯算法和决策树算法的基本原理；
2. 能够使用朴素贝叶斯算法或者决策树算法对数据进行分类
3. 学会对于分类器的性能评估方法
二．实验的硬件、软件平台
硬件：计算机
软件：操作系统：WINDOWS 8.1
应用软件：Java
三．实验内容及步骤
（一）实验内容：
利用贝叶斯算法或者决策树算法进行数据分类操作
数据集：汽车评估数据集(见附录)
（二）实验步骤：
1．仔细阅读并了解实验数据集；
2．使用任何一种熟悉的计算机语言(比如C,Java或者matlab)实现朴素贝叶斯算法或者决策树算法；
3．利用朴素贝叶斯算法或者决策树算法在训练数据上学习分类器,训练数据的大小分别设置为：前100个数据，前200个数据，前500个数据，前700个数据，前1000个数据，前1350个数据；
4．利用测试数据对学习的分类器进行性能评估；
5．统计分析实验结果并上交实验报告；
四、思考题：
1. 两种算法在训练数据集和测试数据集上的性能一致吗？哪个比较好？
2. 提出一种提高分类器性能的方法并通过实验验证。
五．实验报告
（一）算法的基本原理
贝叶斯定理：
表示事件X已经发生的前提下，事件Y发生的概率，叫做事件X发生下事件Y的条件概率，其基本求解公式为：

朴素贝叶斯分类器：

朴素贝叶斯的思想基础是这样的：对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。
朴素贝叶斯分类的正式定义如下：
1、设 为一个待分类项，而每个a为x的一个特征属性。
2、有类别集合 。
3、计算 。
4、如果 ，则 。
那么现在的关键就是如何计算第3步中的各个条件概率。我们可以这么做：
1、找到一个已知分类的待分类项集合，这个集合叫做训练样本集。
2、统计得到在各类别下各个特征属性的条件概率估计。即

3、如果各个特征属性是条件独立的，则根据贝叶斯定理有如下推导：

因为分母对于所有类别为常数，因为我们只要将分子最大化皆可。又因为各特征属性是条件独立的，所以有：
整个朴素贝叶斯分类分为三个阶段：
第一阶段: 准备工作阶段，这个阶段的任务是为朴素贝叶斯分类做必要的准备，主要工作是根据具体情况确定特征属性，并对每个特征属性进行适当划分，然后由人工对一部分待分类项进行分类，形成训练样本集合。这一阶段的输入是所有待分类数据，输出是特征属性和训练样本。这一阶段是整个朴素贝叶斯分类中唯一需要人工完成的阶段，其质量对整个过程将有重要影响，分类器的质量很大程度上由特征属性、特征属性划分及训练样本质量决定。
第二阶段: 分类器训练阶段，这个阶段的任务就是生成分类器，主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计，并将结果记录。其输入是特征属性和训练样本，输出是分类器。这一阶段是机械性阶段，根据前面讨论的公式可以由程序自动计算完成。
第三阶段: 应用阶段。这个阶段的任务是使用分类器对待分类项进行分类，其输入是分类器和待分类项，输出是待分类项与类别的映射关系。这一阶段也是机械性阶段，由程序完成。

决策树：
决策树是一个类似于流程图的树结构，其中每个内部结点表示在一个属性上的测试，每个分支代表一个测试输入，而每个树叶结点代表类或类分布。数的最顶层结点是根结点。一棵典型的决策树如图所示。它表示概念buys_computer，它预测顾客是否可能购买计算机。内部结点用矩形表示，而树叶结点用椭圆表示。为了对未知的样本分类，样本的属性值在决策树上测试。决策树从根到叶结点的一条路径就对应着一条合取规则，因此决策树容易转化成分类规则。

（二）实验框架与结果
1.汽车评估数据集
汽车评估数据集包含1728个数据，其中训练数据1350，测试数据 个。每个数据包含6个属性，所有的数据分为4类：
Class Values: unacc, acc, good, vgood 
Attributes: 
buying: vhigh, high, med, low. 
maint: vhigh, high, med, low. 
doors: 2, 3, 4, 5more. 
persons: 2, 4, more. 
lug_boot: small, med, big. 
safety: low, med, high. 
部分训练集截图：

部分测试集截图：

2.程序框架
1.获取训练样本
2.对每个类别进行统计（Class Values: unacc, acc, good, vgood）
3.对每个属性进行统计（buying: vhigh, high, med, low. maint: vhigh, high, med, low. doors: 2, 3, 4, 5more. persons: 2, 4, more. lug_boot: small, med, big. safety: low, med, high.）
4.计算并存储每个属性在类别中的条件概率，例如P(buing:vhigh | class value:unacc) =（buing中vhigh的数量）除以 （classValue中unacc的数量）
5.获取测试集样本，将测试数据放入训练集
6.根据每一条测试数据的前六项，每一项在训练集的每个类别中都分别有一个概率值，将每一类别中六个概率值相乘，可得四个评估概率。例如，对于测试数据（low,vhigh,4,2,small,low,unacc）
评价结果V1=p(low| unacc)* p(vhigh | unacc) * p(4 | unacc) * p(2 | unacc)* p(small | unacc)* p(low,| unacc)
V2=p(low| acc)* p(vhigh | acc) * p(4 | acc) * p(2 | acc)* p(small | acc)* p(low,| acc)
V3=p(low| good)* p(vhigh | good) * p(4 | good) * p(2 | good)* p(small | good)* p(low,| good)
V4=p(low| vgood)* p(vhigh | vgood) * p(4 | vgood) * p(2 | vgood)* p(small | vgood)* p(low,| vgood)
比较VI、V2、V3、V4中概率最大的评价，可得评价结果
7，对评估概率进行比价，可得最大概率，最大概率指向的类别即为测试结果
8.测试结果与测试数据最后一项进行比对，若相同表示测试正确，返回true，反之，若不相同，则返回false。
9.统计true的数量，除以测试样本数量，可得分类器的准确率。

3.实验结果
部分截图：

得知：此种训练集下得到的样本测试准确率为68.78%左右。朴素贝叶斯的测试性能与训练集有关，训练集好则准确率高。
（三）实验分析和思考题
1. 两种算法在训练数据集和测试数据集上的性能一致吗？哪个比较好？
决策树有比较好的准确率和相对较好的标准误差，但是在这背后，很有可能是以较大错误率作为代价，这点可以从训练混淆矩阵中得到印证；而朴素贝叶斯分类算法的准确率相对较低，而标准误差也较高。
朴素贝叶斯算法
时间复杂度：O(n3)
决策树算法
时间复杂度： O(n*|S|*log|S|) 其中log以2为底，n为属性的个数，|S|为训练样本的个数
而且朴素贝叶斯可能存在0概率问题
存在准确度问题，朴素贝叶斯分类器是基于样本属性条件独立的假设的前提下的,但是实际情况可能并不成立，这样也就缺失准确性了.
解决朴素贝叶斯准确性问题提出的一种方法叫做：贝叶斯网络（Bayesian Belief Networks ）
2. 提出一种提高分类器性能的方法并通过实验验证。
Adaboost：基于错误提升分类器的性能
Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器，即弱分类器，然后把这些弱分类器集合起来，构造一个更强的最终分类器，比起弱分类器，这个“强”分类器的错误率会低很多。
Adaboost算法本身是改变数据分布实现的，它根据每次训练集之中的每个样本的分类是否正确，以及上次的总体分类的准确率，来确定每个样本的权值。将修改权值的新数据送给下层分类器进行训练，然后将每次训练得到的分类器融合起来，作为最后的决策分类器。以下给出 Adaboost算法的运行过程：
1. 训练数据中的每个样本，并赋予其一个权重，这些权重构成向量D，一开始时权重D初始化为相等的值；
2. 先在训练样本上训练得到第一个弱分类器并计算分类器的错误率 ；
3. 在同一数据集上再次训练弱分类器，在分类器的二次训练中，会重新调整每个样本的权重，其中第一次分类正确的样本的权重将会降低，而分类错误的样本权重将会提高 ；
4. 为了从所有弱分类器中得到最终的分类结果，Adaboost为每个分类器都分配了一个权重值alpha，这一组值是基于每个弱分类器的错误率进行计算的。
其中，错误率由以下公式定义：

（四）实验源代码
package rgzn;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import .URL;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Vector;

/**
* 朴素贝叶斯
*
* @author Dyl
*
*/
//汽车属性
class Car {
public String buying;// vhigh,high,med,low
public String maint;// vhigh,high,med,low
public String doors;// 2,3,4,5more
public String persons;// 2,4,more
public String lug_boot;// small ,med,big
public String safety;// low,med,high
public String ClassValues;// unacc,acc, good,vgood
public String[] predictResult = new String[5];// 记录预测结果
}
public class NavieBayes {
Vector<Car> vector;
int testTotal = 0;// 训练样本数量
int predictTotal = 0;// 测试样本的数据
int predictSucess = 0;// 预测成功的数量
String[] ClassValueName = { "unacc", "acc", "good", "vgood" };
// 存储数量
int[] ClassValueTotal = new int[4];// unacc-0 acc-1 good-2 vgood-3
int[][] buying_Vlaue = new int[4][4]; // 前面是自己的属性，后面是value的属性
int[][] maint_Value = new int[4][4];
int[][] doors_Value = new int[4][4];
int[][] persons_Value = new int[3][4];
int[][] lugboot_Value = new int[3][4];
int[][] safety_Value = new int[3][4];

// 存储概率
float[] ClassValueTotal_gl = new float[4];// unacc-0 acc-1 good-2 vgood-3
float[][] buying_Vlaue_gl = new float[4][4]; // 前面是自己的属性，后面是value的属性
float[][] maint_Value_gl = new float[4][4];
float[][] doors_Value_gl = new float[4][4];
float[][] persons_Value_gl = new float[3][4];
float[][] lugboot_Value_gl = new float[3][4];
float[][] safety_Value_gl = new float[3][4];

public NavieBayes() {
vector = new Vector<Car>();//存储数据
}
/**
* 主函数
*/
public static void main(String[] args) throws Exception {
NavieBayes pSbys = new NavieBayes();
pSbys.getData();// 获取训练样本
pSbys.dataTest();//传入测试样本数据，检测其分类器的性能
pSbys.showGL();// 展示结果
}

/**
* 统计数量，为计算概率做准备
*/
private void dataTongJi(Car car) {
for(int i=0;i<4;i++){
if(car.ClassValues.equals(ClassValueName[i])){
ClassValueTotal[i]++;
//buying:vhigh,high,med,low
if(car.buying.equals("vhigh")) buying_Vlaue[0][i]++;
else if(car.buying.equals("high"))buying_Vlaue[1][i]++;
else if(car.buying.equals("med")) buying_Vlaue[2][i]++;
else buying_Vlaue[3][i]++;
//maint_Value:vhigh,high,med,low
if(car.maint.equals("vhigh")) maint_Value[0][i]++;
else if(car.maint.equals("high")) maint_Value[1][i]++;
else if(car.maint.equals("med")) maint_Value[2][i]++;
else maint_Value[3][i]++;
//doors_Value:2,3,4,5more
if(car.doors.equals("2")) doors_Value[0][i]++;
else if(car.doors.equals("3")) doors_Value[1][i]++;
else if(car.doors.equals("4")) doors_Value[2][i]++;
else doors_Value[3][i]++;
//persons_Value:2,4,more
if(car.persons.equals("2")) persons_Value[0][i]++;
else if(car.persons.equals("4")) persons_Value[1][i]++;
else persons_Value[2][i]++;
//lugboot_Value:small ,med,big
if(car.lug_boot.equals("small")) lugboot_Value[0][i]++;
else if(car.lug_boot.equals("med")) lugboot_Value[1][i]++;
else lugboot_Value[2][i]++;
//safety_Value:low,med,high
if(car.safety.equals("low")) safety_Value[0][i]++;
else if(car.safety.equals("med")) safety_Value[1][i]++;
else safety_Value[2][i]++;
}
}
}
/**
* 学习过程获取训练样本,统计个数，计算概率
*
* @param url
*/
private void getData() throws Exception {
InputStreamReader in = new InputStreamReader(getClass()
.getResourceAsStream("learn.txt"));
Scanner scanner = new Scanner(in);
while (scanner.hasNext()) {
testTotal++;
String[] temp = scanner.nextLine().split(",");
Car car = new Car();
car.buying = temp[0];
car.maint = temp[1];
car.doors = temp[2];
car.persons = temp[3];
car.lug_boot = temp[4];
car.safety = temp[5];
car.ClassValues = temp[6];
dataTongJi(car);// 统计数据的个数
}
gailvTongJi();// 统计概率
}

/**
* 概率统计
*/
private void gailvTongJi() {
for (int i = 0; i < ClassValueTotal.length; i++) {
ClassValueTotal_gl[i] = (float) ClassValueTotal[i] / testTotal;
}

for (int i = 0; i < buying_Vlaue_gl.length; i++) {
for (int j = 0; j < buying_Vlaue_gl[0].length; j++) {
buying_Vlaue_gl[i][j] = (float) buying_Vlaue[i][j]
/ ClassValueTotal[j];
maint_Value_gl[i][j] = (float) maint_Value[i][j]
/ ClassValueTotal[j];
doors_Value_gl[i][j] = (float) doors_Value[i][j]
/ ClassValueTotal[j];
}
}
for (int i = 0; i < persons_Value_gl.length; i++) {
for (int k = 0; k < persons_Value_gl[0].length; k++) {
persons_Value_gl[i][k] = (float) persons_Value[i][k]
/ ClassValueTotal[k];
lugboot_Value_gl[i][k] = (float) lugboot_Value[i][k]
/ ClassValueTotal[k];
safety_Value_gl[i][k] = (float) safety_Value[i][k]
/ ClassValueTotal[k];
}
}

}
//结果显示
//for (int j = 0; j < c.predictResult.length; j++) {
//System.out.print(c.predictResult[j] + "\t\t");
//}
private void showGL() {

for (int i = 0; i < predictTotal; i++) {
Car c = vector.get(i);
System.out.print(c.predictResult[c.predictResult.length-1] + "\t\t");
System.out.println();
}
// 分类器的准确率
float t = (float) predictSucess / predictTotal;
t = (t * 1000) / 10;
System.out.println("\n分类器的准确率为：" + t + "%");
}

/**
* 给定测试样本，测试其分类器性能如何
* 读取数据
* @throws FileNotFoundException
*/
private void dataTest() throws FileNotFoundException {
InputStreamReader in = new InputStreamReader(getClass()
.getResourceAsStream("test.txt"));
Scanner scanner = new Scanner(in);
while (scanner.hasNext()) {
predictTotal++;
String[] temp = scanner.nextLine().split(",");
Car car = new Car();
car.buying = temp[0];
car.maint = temp[1];
car.doors = temp[2];
car.persons = temp[3];
car.lug_boot = temp[4];
car.safety = temp[5];
car.ClassValues = temp[6];
vector.add(car);
xingnengTest(car);// 性能测试
}
}

/**
* 对分类器进行性能测试，判断其成功率为多少
*
* @param car
*/
private void xingnengTest(Car car) {
// unacc,acc,good,vgood, P(yi)--ClassValueTotal_gl 、 P(x|yi)=
// low,vhigh,4,2,small,low,unacc 第一条
float itemGl;// 每一条的概率
int b, m, d, p, l, s;
b = m = d = p = l = s = -1;
float MaxGl = 0;// 临时概率
if (car.buying.equals("vhigh")) {
b = 0;
} else if (car.buying.equals("high")) {
b = 1;
} else if (car.buying.equals("med")) {
b = 2;
} else {
b = 3;
}

if (car.maint.equals("vhigh")) {
m = 0;
} else if (car.maint.equals("high")) {
m = 1;
} else if (car.maint.equals("med")) {
m = 2;
} else {
m = 3;
}

if (car.doors.equals("2")) {
d = 0;
} else if (car.doors.equals("3")) {
d = 1;
} else if (car.doors.equals("4")) {
d = 2;
} else {
d = 3;
}

if (car.persons.equals("2")) {
p = 0;
} else if (car.persons.equals("4")) {
p = 1;
} else {
p = 2;
}

if (car.lug_boot.equals("small")) {
l = 0;
} else if (car.lug_boot.equals("med")) {
l = 1;
} else {
l = 2;
}

if (car.safety.equals("low")) {
s = 0;
} else if (car.safety.equals("med")) {
s = 1;
} else {
s = 2;
}
int t = 0;// 记录最大概率的下标
int i;

// 如：
// unacc
// low(0.038),vhigh(0.329),4(0.2323),2(0.4545),small(0.3737),low(0.4545),unacc()
for (i = 0; i < ClassValueTotal_gl.length; i++) {// 计算在unacc,acc,good,vgood下的概率
itemGl = 0;

BigDecimal[] bigDecimal = {
new BigDecimal(Float.toString(ClassValueTotal_gl[i])),
new BigDecimal(Float.toString(buying_Vlaue_gl[b][i])),
new BigDecimal(Float.toString(maint_Value_gl[m][i])),
new BigDecimal(Float.toString(doors_Value_gl[d][i])),
new BigDecimal(Float.toString(persons_Value_gl[p][i])),
new BigDecimal(Float.toString(lugboot_Value_gl[l][i])),
new BigDecimal(Float.toString(safety_Value_gl[s][i])), };

for (int j = 1; j < bigDecimal.length; j++) {//除:a.divide(b,2);//2为精度取值
bigDecimal[0] = bigDecimal[0].multiply(bigDecimal[j]);//multiply乘
}
itemGl = bigDecimal[0].floatValue();
car.predictResult[i] = itemGl + " ";
if (MaxGl < itemGl) {
MaxGl = itemGl;
t = i;
}
}
// 判断结果是否正确
if (car.ClassValues.equals(ClassValueName[t])) {// 预测结果和开始给定的结果相等
car.predictResult[i] = "true";
predictSucess++;
} else {
car.predictResult[i] = "false";
}
}
}