贝叶斯实验报告.docx
《贝叶斯实验报告.docx》由会员分享，可在线阅读，更多相关《贝叶斯实验报告.docx（17页珍藏版）》请在冰点文库上搜索。
贝叶斯实验报告
HUNANUNIVERSITY
人工智能实验报告
题目实验三：
分类算法实验
学生匿名
学生学号2013080702xx
专业班级智能科学与技术1302班
指导老师袁进
一．实验目的
1.了解朴素贝叶斯算法的基本原理；
2.能够使用朴素贝叶斯算法对数据进行分类
3.了解最小错误概率贝叶斯分类器和最小风险概率贝叶斯分类器
4.学会对于分类器的性能评估方法
二、实验的硬件、软件平台
硬件：
电脑
软件：
操作系统：
WINDOWS 10
应用软件：
C,Java或者Matlab
相关知识点:
贝叶斯定理：
表示事件B已经发生的前提下，事件A发生的概率，叫做事件B发生下事件A的条件概率，其基本求解公式为：
贝叶斯定理打通了从P（A|B）获得P（B|A）的道路。
直接给出贝叶斯定理：
朴素贝叶斯分类是一种十分简单的分类算法，叫它朴素贝叶斯分类是因为这种方法的思想真的很朴素，朴素贝叶斯的思想基础是这样的：
对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。
朴素贝叶斯分类的正式定义如下：
1、设
为一个待分类项，而每个a为x的一个特征属性。
2、有类别集合
。
3、计算
。
4、如果
，则
。
那么现在的关键就是如何计算第3步中的各个条件概率。
我们可以这么做：
1、找到一个已知分类的待分类项集合，这个集合叫做训练样本集。
2、统计得到在各类别下各个特征属性的条件概率估计。
即
3、如果各个特征属性是条件独立的，则根据贝叶斯定理有如下推导：
因为分母对于所有类别为常数，因为我们只要将分子最大化皆可。
又因为各特征属性是条件独立的，所以有：
整个朴素贝叶斯分类分为三个阶段：
第一阶段:
准备工作阶段，这个阶段的任务是为朴素贝叶斯分类做必要的准备，主要工作是根据具体情况确定特征属性，并对每个特征属性进行适当划分，然后由人工对一部分待分类项进行分类，形成训练样本集合。
这一阶段的输入是所有待分类数据，输出是特征属性和训练样本。
这一阶段是整个朴素贝叶斯分类中唯一需要人工完成的阶段，其质量对整个过程将有重要影响，分类器的质量很大程度上由特征属性、特征属性划分及训练样本质量决定。
第二阶段:
分类器训练阶段，这个阶段的任务就是生成分类器，主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计，并将结果记录。
其输入是特征属性和训练样本，输出是分类器。
这一阶段是机械性阶段，根据前面讨论的公式可以由程序自动计算完成。
第三阶段:
应用阶段。
这个阶段的任务是使用分类器对待分类项进行分类，其输入是分类器和待分类项，输出是待分类项与类别的映射关系。
这一阶段也是机械性阶段，由程序完成。
三、实验内容及步骤
实验内容：
A.利用贝叶斯算法进行数据分类操作，并统计其预测正确率,数据集：
汽车评估数据集〔learn作为学习集，test作为测试集合〕
〔维数设为二维〕，要求正样本：
均值为[1;3]，方差为[20;02]；负样本：
均值为[10;20]，方差为[100;010].先验概率按样本量设定为1/3和2/3.分别利用最小错误概率贝叶斯分类器和最小风险概率贝叶斯分类器对其分类。
〔假设风险程度正样本分错风险系数为0.6，负样本分错风险为0.4，该设定仅用于最小风险分析〕
相关概念:
贝叶斯法则,先验概率,后验概率,最大后验概率
机器学习的任务：
在给定训练数据D时，确定假设空间H中的最正确假设。
最正确假设：
一种方法是把它定义为在给定数据D以及H中不同假设的先验概率的有关知识下的最可能假设。
贝叶斯理论提供了一种计算假设概率的方法，基于假设的先验概率、给定假设下观察到不同数据的概率以及观察到的数据本身。
2.先验概率和后验概率
用P（h）表示在没有训练数据前假设h拥有的初始概率。
P（h）被称为h的先验概率。
先验概率反映了关于h是一正确假设的时机的背景知识如果没有这一先验知识，可以简单地将每一候选假设赋予相同的先验概率。
类似地，P（D）表示训练数据D的先验概率，P（D|h）表示假设h成立时D的概率。
机器学习中，我们关心的是P（h|D），即给定D时h的成立的概率，称为h的后验概率。
3.贝叶斯公式
贝叶斯公式提供了从先验概率P（h）、P（D）和P（D|h）计算后验概率P（h|D）的方法
p（h|D）=P（D|H）*P（H）/P（D）
P（h|D）随着P（h）和P（D|h）的增长而增长，随着P（D）的增长而减少，即如果D独立于h时被观察到的可能性越大，那么D对h的支持度越小。
4.极大后验假设
学习器在候选假设集合H中寻找给定数据D时可能性最大的假设h，h被称为极大后验假设〔MAP〕确定MAP的方法是用贝叶斯公式计算每个候选假设的后验概率，计算式如下:
h_map=argmaxP（h|D）=argmax（P（D|h）*P（h））/P（D）=argmaxP（D|h）*p（h）（h属于集合H）
C.编写一个贝叶斯分类器。
输入为：
均指向量、先验概率、协方差矩阵、输入学习数据X,测试数据类别XLABEL,测试数据Y.输出为Y对应的类别。
〔选做〕。
四、实验步骤：
1．仔细阅读并了解实验数据集；
2．使用任何一种熟悉的电脑语言（比方C,Java或者matlab）实现朴素贝叶斯算法；
3．利用朴素贝叶斯算法在训练数据上学习分类器,训练数据的大小分别设置为：
前100个数据，前200个数据，前500个数据，前700个数据，前1000个数据，前1350个数据；
4．利用测试数据对学习的分类器进行性能评估；
5．统计分析实验结果并上交实验报告；
A源代码:
packageBayes;
importjava.io.BufferedReader;
import;
import;
importjava.io.FileReader;
importjava.io.IOException;
import;
importjava.util.Vector;
import;
publicclassNaiveBayesTool{
/*
*申明全局变量//前面是自己的属性，后面是value的属性
**/
inttestTotal=0;//训练样本数量
intpredictTotal=0;//测试样本的数据
intpredictSucess=0;//预测成功的数量
//存储数量
publicint[][]buy=newint[4][4];//vhigh,high,med,low
publicint[][]maint=newint[4][4];//vhigh,high,med,low
publicint[][]door=newint[4][4];//2,3,4,5more
publicint[][]person=newint[3][4];//2,4,more
publicint[][]lug_boot=newint[3][4];//small,med,big
publicint[][]safe=newint[3][4];//low,med,high
publicint[]ClassValues=newint[4];//unacc,acc,good,vgood
String[]ClassValueName={"unacc","acc","good","vgood"};
//存储概率
float[]ClassValue_gl=newfloat[4];//unacc-0acc-1good-2vgood-3
float[][]buy_Vlaue_gl=newfloat[4][4];//前面是自己的属性，后面是value的属性
float[][]maint_Value_gl=newfloat[4][4];
float[][]door_Value_gl=newfloat[4][4];
float[][]person_Value_gl=newfloat[3][4];
float[][]lugboot_Value_gl=newfloat[3][4];
float[][]safe_Value_gl=newfloat[3][4];
/**
*主函数
*/
publicstaticvoidmain（String[]args）throwsIOException{
NaiveBayesToolNBayes=newNaiveBayesTool（）;
NBayes.ReadFile（"learn.txt"）;//获取训练样本
NBayes.Calculated_probability（）;//计算概率
NBayes.TestData（）;//导入测试样本数据
NBayes.show（）;//输出结果
}
/*汽车属性类
**/
publicclassProperty{//汽车有6个属性，每个属性都有几种类别，根据这6个属性来判断汽车的性价比Classvalue如何，
publicStringbuying;//vhigh,high,med,low
publicStringmaint;//vhigh,high,med,low
publicStringdoors;//2,3,4,5more
publicStringpersons;//2,4,more
publicStringlug_boot;//small,med,big
publicStringsafety;//low,med,high
publicStringClassValues;//unacc,acc,good,vgood
publicString[]PredictResult=newString[5];//记录预测结果
publicProperty（Stringb,Stringm,Stringd,Stringp,Stringl,Strings,Stringc）{
buying=b;maint=m;doors=d;
persons=p;lug_boot=l;safety=s;
ClassValues=c;
}
};
VectorData=newVector（）;//存储数据
VectorDataTest=newVector（）;//存储测试数据
/*
*文件读写获取训练样本
**/
publicvoidReadFile（Stringfilename）throwsIOException
{
BufferedReaderbr=newBufferedReader（newFileReader（filename））;
Stringtemp=null;
temp=br.readLine（）;
String[]str=null;
PropertyTempClass=null;
while（temp!
=null）{
str=temp.split（","）;
TempClass=newProperty（str[0],str[1],str[2],str[3],str[4],str[5],str[6]）;
Statistics（TempClass）;//统计个数
testTotal++;
temp=br.readLine（）;
}
br.close（）;
}
/*
*统计每一项的个数vhigh,vhigh,2,2,small,low,unacc
**/
publicvoidStatistics（Propertycar）{
for（inti=0;i<4;i++）{
if（car.ClassValues.equals（ClassValueName[i]））{
ClassValues[i]++;
//vhigh,high,med,low
if（car.buying.equals（"vhigh"））buy[0][i]++;
elseif（car.buying.equals（"high"））buy[1][i]++;
elseif（car.buying.equals（"med"））buy[2][i]++;
elsebuy[3][i]++;
//vhigh,high,med,low
if（car.maint.equals（"vhigh"））maint[0][i]++;
elseif（car.maint.equals（"high"））maint[1][i]++;
elseif（car.maint.equals（"med"））maint[2][i]++;
elsemaint[3][i]++;
//2,3,4,5more
if（car.doors.equals（"2"））door[0][i]++;
elseif（car.doors.equals（"3"））door[1][i]++;
elseif（car.doors.equals（"4"））door[2][i]++;
elsedoor[3][i]++;
//2,4,more
if（car.persons.equals（"2"））person[0][i]++;
elseif（car.persons.equals（"4"））person[1][i]++;
elseperson[2][i]++;
//small,med,big
if（car.lug_boot.equals（"small"））lug_boot[0][i]++;
elseif（car.lug_boot.equals（"med"））lug_boot[1][i]++;
elselug_boot[2][i]++;
//low,med,high
if（car.safety.equals（"low"））safe[0][i]++;
elseif（car.safety.equals（"med"））safe[1][i]++;
elsesafe[2][i]++;
}
}
}/*
*计算概率
*/
publicvoidCalculated_probability（）{
for（inti=0;iClassValue_gl[i]=（float）ClassValues[i]/testTotal;
for（inti=0;ifor（intj=0;jbuy_Vlaue_gl[i][j]=（float）buy[i][j]/ClassValues[j];
maint_Value_gl[i][j]=（float）maint[i][j]/ClassValues[j];
door_Value_gl[i][j]=（float）door[i][j]/ClassValues[j];
}
for（inti=0;ifor（intj=0;jperson_Value_gl[i][j]=（float）person[i][j]/ClassValues[j];
lugboot_Value_gl[i][j]=（float）lug_boot[i][j]/ClassValues[j];
safe_Value_gl[i][j]=（float）safe[i][j]/ClassValues[j];
}
}
/*
*获取测试数据
**/
publicvoidTestData（）throwsIOException
{
BufferedReaderbr=newBufferedReader（newFileReader（"test.txt"））;
Stringtemp;
temp=br.readLine（）;
String[]str=null;
PropertyCar=null;
while（temp!
=null）{
str=temp.split（","）;
Car=newProperty（str[0],str[1],str[2],str[3],str[4],str[5],str[6]）;
predictTotal++;
Data.addElement（Car）;
calculate（Car）;
temp=br.readLine（）;
}
}
/**
*对分类器进行性能测试，判断其成功率为多少
*@paramcar
*/
publicvoidcalculate（Propertycar）{
//unacc,acc,good,vgood,P（yi）--ClassValueTotal_gl、P（x|yi）=low,vhigh,4,2,small,low,unacc第一条
floatitemGl;//每一条的概率
intb,m,d,p,l,s;
b=m=d=p=l=s=-1;
floatMaxGl=0;
if（car.buying.equals（"vhigh"））b=0;
elseif（car.buying.equals（"high"））b=1;
elseif（car.buying.equals（"med"））b=2;
elseb=3;
if（car.maint.equals（"vhigh"））m=0;
elseif（car.maint.equals（"high"））m=1;
elseif（car.maint.equals（"med"））m=2;
elsem=3;
if（car.doors.equals（"2"））d=0;
elseif（car.doors.equals（"3"））d=1;
elseif（car.doors.equals（"4"））d=2;
elsed=3;
if（car.persons.equals（"2"））p=0;
elseif（car.persons.equals（"4"））p=1;
elsep=2;
if（car.lug_boot.equals（"small"））l=0;
elseif（car.lug_boot.equals（"med"））l=1;
elsel=2;
if（car.safety.equals（"low"））s=0;
elseif（car.safety.equals（"med"））s=1;
elses=2;
intt=0;//记录最大概率的下标
inti;
for（i=0;iitemGl=0;
BigDecimal[]bigDecimal={
newBigDecimal（Float.toString（ClassValue_gl[i]））,
newBigDecimal（Float.toString（buy_Vlaue_gl[b][i]））,
newBigDecimal（Float.toString（maint_Value_gl[m][i]））,
newBigDecimal（Float.toString（door_Value_gl[d][i]））,
newBigDecimal（Float.toString（person_Value_gl[p][i]））,
newBigDecimal（Float.toString（lugboot_Value_gl[l][i]））,
newBigDecimal（Float.toString（safe_Value_gl[s][i]））,
};
for（intj=1;ja.add（b）;除:
a.divide（b,2）;//2为精度取值
bigDecimal[0]=bigDecimal[0].multiply（bigDecimal[j]）;//multiply乘
itemGl=bigDecimal[0].floatValue（）;
car.PredictResult[i]=itemGl+"\t";
if（MaxGlMaxGl=itemGl;
t=i;
}
}
//判断结果是否正确
if（car.ClassValues.equals（ClassValueName[t]））{//预测结果和开始给定的结果相等
car.PredictResult[i]="true";
predictSucess++;
}else
car.PredictResult[i]="false";
}
publicvoidshow（）
{
for（inti=0;iPropertyc=Data.get（i）;
for（intj=0;jSystem.out.print（c.PredictResult[j]+"\t"）;
System.out.println（）;
}
//分类器的准确率
floatt=（float）predictSuces
升级会员 