贝叶斯实验报告

　 HUNAN

　UNIVERSITY

　 人工智能实验报告

　 题

　目

　实验三：分类算法实验

　学生姓名

　 匿名

　学生学号

　2013080702xx

　 专业班级

　智能科学与技术 1302 班

　 指导老师

　袁进

　一．实验目的 1. 了解朴素贝叶斯算法的基本原理；

　 2. 能够使用朴素贝叶斯算法对数据进行分类

　 3. 了解最小错误概率贝叶斯分类 器和最小风险概率贝叶斯分类器

　 4. 学会对于分类器的性能评估方法

　 二、实验的硬件、软件平台 硬件：计算机

　 软件：操作系统：

　WINDOWS

　10

　应用软件：a C,Java 或者 Matlab

　 相关知识点: :

　 贝叶斯定理：

　 表示事件 B 已经发生的前提下，事件 A 发生的概率，叫做事件 B 发生下事件 A 的条件概率，其基本求解公式为：

　贝叶斯定理打通了从 P(A|B)获得 P(B|A)的道路。

　 直接给出贝叶斯定理：

　 朴素贝叶斯分类是一种十分简单的分类算法，叫它朴素贝叶斯分类是因为这种方法的思想真的很朴素，朴素贝叶斯的思想基础是这样的：对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。

　朴素贝叶斯分类的正式定义如下：

　 1、设 为一个待分类项，而每个 a 为 x 的一个特征属性。

　2、有类别集合 。

　3、计算 。

　4、如果 ，则 。

　那么现在的关键就是如何计算第3步中的各个条件概率。我们可以这么做：

　1、找到一个已知分类的待分类项集合，这个集合叫做训练样本集。

　2、统计得到在各类别下各个特征属性的条件概率估计。即

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

　因为分母对于所有类别为常数，因为我们只要将分子最大化皆可。又因为各特征属性是条件独立的，所以有：

　整个朴素贝叶斯分类分为三个阶段：

　第一阶段: 准备工作阶段，这个阶段的任务是为朴素贝叶斯分类做必要的准备，主要工作是根据具体情况确定特征属性，并对每个特征属性进行适当划分，然后由人工对一部分待分类项进行分类，形成训练样本集合。这一阶段的输入是所有待分类数据，输出是特征属性和训练样本。这一阶段是整个朴素贝叶斯分类中唯一需要人工完成的阶段，其质量对整个过程将有重要影响，分类器的质量很大程度上由特征属性、特征属性划分及训练样本质量决定。

　第二阶段: 分类器训练阶段，这个阶段的任务就是生成分类器，主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计，并将结果记录。其输入是特征属性和训练样本，输出是分类器。这一阶段是机械性阶段，根据前面讨论的公式可以由程序自动计算完成。

　第三阶段: 应用阶段。这个阶段的任务是使用分类器对待分类项进行分类，其输入是分类器和待分类项，输出是待分类项与类别的映射关系。这一阶段也是机械性阶段，由程序完成。

　三、实验内容及步骤 实验内容：

　 A. 利用贝叶斯算法进行数据分类操作，并统计其预测正确率, , 数据集：汽车评估数据集（n learn 作为学习集，t test 作为测试集合）

　 B. 随机产生 10000 组正样本和 20000 负样本高斯分布的数据集合（维数设为二维），要求正样本：均值为 [1;3] ，方差为 [2 0;0 2] ；负样本：均值为 [10;20] ，方差为 [10 0;0 10]. 先验概率按样本量设定为 1/3 和 2/3. 分别利用最小错误概 率贝叶斯分类器和最小风险概率贝叶斯分类器对其分类。（假设风险程度正样本分错风险系数为 0.6 ，负样本分错风险为 0.4 ，该设定仅用于最小风险分析）

　 相关概念: :

　 贝叶斯法则, , 先验概率, , 后验概率, , 最大后验概率

　1.贝叶斯法则 机器学习的任务：在给定训练数据 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=argmax P(h|D)=argmax (P(D|h)*P(h))/P(D)=argmax P(D|h)*p(h) (h 属于集合H)

　C. 编写一个贝叶斯分类器。输入为：均指向量、先验概率、协方差矩阵、输入

　学习数据 X, 测试数据类别 XLABEL, 测试数据 Y. 输出为 Y Y 对应的类别。（选做）。

　 四、实验步骤：

　1 1 ．仔细阅读并了解实验数据集；

　 2 2 ．使用任何一种熟悉的计算机语言( ( 比如 a C,Java 或者 matlab) 实现朴素贝叶斯算法；

　 3 3 ．利用朴素贝叶斯算法在训练数据上学习分类器, , 训练数据的大小分别设置为：前 100 个数据，前 200 个数据，前 500 个数据，前 700 个数据，前 1000 个数据，前1350 个数据；

　 4 4 ．利用测试数据对学习的分类器进行性能评估；

　 5 5 ．统计分析实验结果并上交实验报告；

　 A 源代码: package Bayes;

　import java.io.BufferedReader;

　import java.io.;

　import java.io.;

　import java.io.;

　import java.io.IOException;

　import java.math.BigDecimal;

　import java.util.Vector;

　import Bayes.NaiveBayesTool.Property;

　public class NaiveBayesTool {

　 /*

　* 申明全局变量 // 前面是自己的属性，后面是value的属性

　* */

　 int testTotal = 0;// 训练样本数量

　 int predictTotal = 0;// 测试样本的数据

　 int predictSucess = 0;// 预测成功的数量

　 //存储数量

　 public int[][] buy= new int[4][4];//vhigh,high,med,low

　 public int[][] maint= new int[4][4];//vhigh,high,med,low

　 public int[][] door= new int[4][4];//2,3,4,5more

　 public int[][] person= new int[3][4];//2,4,more

　 public int[][] lug_boot= new int[3][4];//small ,med,big

　 public int[][] safe= new int[3][4];//low,med,high

　 public int[] ClassValues= new int t[4];//unacc,acc, good,vgood

　 String[] ClassValueName = { "unacc", "acc", "good", "vgood" };

　 //存储概率

　 float[] ClassValue_gl = new float[4];// unacc-0 acc-1 good-2 vgood-3

　 float[][] buy_Vlaue_gl = new float[4][4]; //前面是自己的属性，后面是value的属性

　 float[][] maint_Value_gl = new float[4][4];

　 float[][] door_Value_gl = new float[4][4];

　 float[][] person_Value_gl = new float[3][4];

　 float[][] lugboot_Value_gl = new float[3][4];

　 float[][] safe_Value_gl = new float[3][4];

　 /**

　* 主函数

　*/

　 public static void main(String[] args) throws IOException {

　NaiveBayesTool NBayes= new NaiveBayesTool();

　NBayes.ReadFile("learn.txt");//获取训练样本

　NBayes.Calculated_probability();//计算概率

　NBayes.TestData();//导入测试样本数据

　NBayes.show();//输出结果

　 }

　 /*汽车属性类

　* */

　 public class Property{//汽车有6个属性，每个属性都有几种类别，根据这6个属性来判断汽车的性价比Classvalue如何，

　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 Property(String b,String m,String d,String p,String l,String s,String c){

　 buying=b;maint=m;doors=d;

　 persons=p;lug_boot=l;safety=s;

　 ClassValues=c;

　}

　 };

　 Vector<Property> Data= new Vector();//存储数据

　 Vector<Property> DataTest= new Vector();//存储测试数据

　 /*

　* 文件读写

　获取训练样本

　* */

　 public void Read ) throws IOException

　 {

　 BufferedReader br= new BufferedReader( new ());

　 String temp= null;

　 temp=br.readLine();

　 String []str = null;

　 Property TempClass = null;

　 while(temp!= null){

　str=temp.split(",");

　TempClass= new Property(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

　* */

　 public void Statistics(Property car){

　for( int i=0;i<4;i++){

　 if(car.ClassValues.equals(ClassValueName[i])){

　 ClassValues[i]++;

　//vhigh,high,med,low

　if(car.buying.equals("vhigh")) buy[0][i]++;

　else if(car.buying.equals("high")) buy[1][i]++;

　else if(car.buying.equals("med")) buy[2][i]++;

　else buy[3][i]++;

　//vhigh,high,med,low

　if(car.maint.equals("vhigh")) maint[0][i]++;

　else if(car.maint.equals("high")) maint[1][i]++;

　else if(car.maint.equals("med")) maint[2][i]++;

　else maint[3][i]++;

　//2,3,4,5more

　if(car.doors.equals("2")) door[0][i]++;

　else if(car.doors.equals("3")) door[1][i]++;

　else if(car.doors.equals("4")) door[2][i]++;

　else door[3][i]++;

　//2,4,more

　if(car.persons.equals("2")) person[0][i]++;

　else if(car.persons.equals("4")) person[1][i]++;

　else person[2][i]++;

　//small ,med,big

　if(car.lug_boot.equals("small")) lug_boot[0][i]++;

　else if(car.lug_boot.equals("med")) lug_boot[1][i]++;

　else lug_boot[2][i]++;

　// low,med,high

　if(car.safety.equals("low")) safe[0][i]++;

　else if(car.safety.equals("med")) safe[1][i]++;

　else safe[2][i]++;

　 }

　}

　 }/*

　 *计算概率

　 */

　 public void Calculated_probability(){

　for( int i=0;i<ClassValues.length;i++)

　 ClassValue_gl[i]=( float)ClassValues[i]/testTotal;

　for( int i=0;i<buy_Vlaue_gl.length;i++)

　 for( int j=0;j<buy_Vlaue_gl[0].length;j++){

　buy_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( int i=0;i<person_Value_gl.length;i++)

　 for( int j=0;j<person_Value_gl[0].length;j++){

　person_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];

　 }

　 }

　 /*

　* 获取测试数据

　* */

　 public void TestData() throws IOException

　 {

　BufferedReader br= new BufferedReader( new ("test.txt"));

　String temp;

　temp=br.readLine();

　String []str = null;

　Property Car = null;

　while(temp!= null){

　 str=temp.split(",");

　 Car= new Property(str[0],str[1],str[2],str[3],str[4],str[5],str[6]);

　 predictTotal++;

　 Data.addElement(Car);

　 calculate(Car);

　 temp=br.readLine();

　}

　 }

　 /**

　* 对分类器进行性能测试，判断其成功率为多少

　* @param car

　*/

　 public void calculate(Property 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;

　for (i = 0; i < ClassValue_gl.length; i++) {// 计算在unacc,acc,good,vgood下的概率

　 itemGl = 0;

　 BigDecimal[] bigDecimal = {

　 new BigDecimal(Float. toString (ClassValue_gl[i])),

　 new BigDecimal(Float. toString (buy_Vlaue_gl[b][i])),

　 new BigDecimal(Float. toString (maint_Value_gl[m][i])),

　 new BigDecimal(Float. toString (door_Value_gl[d][i])),

　 new BigDecimal(Float. toString (person_Value_gl[p][i])),

　 new BigDecimal(Float. toString (lugboot_Value_gl[l][i])),

　 new BigDecimal(Float. toString (safe_Value_gl[s][i])),

　 };

　 for ( int j = 1; j < bigDecimal.length; j++) //加:a.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 (MaxGl < itemGl) {

　MaxGl = itemGl;

　t = i;

　 }

　}

　// 判断结果是否正确

　if (car.ClassValues.equals(ClassValueName[t])) {// 预测结果和开始给定

　的结果相等

　 car.PredictResult[i] = "true";

　 predictSucess++;

　} else

　 car.PredictResult[i] = "false";

　 }

　 public void show()

　 {

　for ( int i =0; i < predictTotal; i++) {

　 Property c = Data.get(i);

　 for ( int j = 0; j < c.PredictResult.length; j++)

　System. out .print(c.PredictResult[j] + "\t");

　 System. out .println();

　}

　// 分类器的准确率

　float t = ( float) predictSucess / predictTotal;

　t=t*10000/100;

　System. out .println("\n分类器的准确率为：" + t+ "%");

　 }

　}

　 四、思考题 1. 实验 A A 中的分类器的优缺点。

　 可能存在0概率问题

　存在准确度问题，朴素贝叶斯分类器是基于样本属性条件独立的假设的前提下的,但是实际情况可能并不成立，这样也就缺失准确性了.

　解决朴素贝叶斯准确性问题提出的一种方法叫做：贝叶斯网络（Bayesian Belief Networks ）

　2. 评价最小错误概率贝叶斯分类器和最小风险概率贝叶斯分类器

　 基于最小错误率的贝叶斯决策

　 实质: : 通过观察 x x 把状态的先验概率 P(wi) 转化为后验概率

　 判别错误率的问题

　 基于最小风险的贝叶斯决策考虑到各种错误照成的损失不同而提出的一种决策规则

　最小风险的贝叶斯决策的计算方法：

　1)根据贝叶斯公式，计算出后验概率 2)利用后验概率和决策表，计算出条件风险 3)比较2中的计算结果，找出使条件风险最小的决策 Ak，则它就是最小风险的贝叶斯决策 两者之间的关系：基于最小错误率的决策是基于最小风险决策的一个特例

　3.验 计算实验 B B 中叶斯分类器和最小风险概率贝叶斯分类器的分类临界值 [x1 x2] ，比较差别，并统计两种正确率。( ( 同上) )

　 4. 提出一种提高分类器性能的方法并通过实验验证。

　 Adaboost ：基于错误提升分类器的性能

　Adaboost 是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器，即弱分类器，然后把这些弱分类器集合起来，构造一个更强的最终分类器，比起弱分类器，这个“强”分类器的错误率会低很多。

　Adaboost 算法本身是改变数据分布实现的，它根据每次训练集之中的每个样本的分类是否正确，以及上次的总体分类的准确率，来确定每个样本的权值。将修改权值的新数据送给下层分类器进行训练，然后将每次训练得到的分类器融合起来，作为最后的决策分类器。以下给出 Adaboost 算法的运行过程：

　1. 训练数据中的每个样本，并赋予其一个权重，这些权重构成向量 D，一开始时权重 D 初始化为相等的值；

　2. 先在训练样本上训练得到第一个弱分类器并计算分类器的 错误率 ；

　3. 在同一数据集上再次训练弱分类器，在分类器的二次训练中，会重新调整每个样本的权重，其中第一次分类正确的样本的权重将会降低，而分类错误的样本权重将会提高 ；

　4. 为了从所有弱分类器中得到最终的分类结果，Adaboost 为每个分类器都分配了一个权重值 alpha，这一组值是基于每个弱分类器的 错误率进行计算的。

　其中， 错误率由以下公式定义：

　（学习的目的是增长知识，提高能力，相信一分耕耘一分收获，努力就一定可以获得应有的回报）

推荐访问:实验 报告 贝叶斯