贝叶斯分类

贝叶斯分类
1、定义：依据贝叶斯准则(两组间最大分离原则)建立的判别函数集进行的图像
分类。

贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。

2、贝叶斯定理：
(|)() (|)
()
P A B P B p B A
P A
说明：(|)
p A B表示事件B发生的前提下，事件A发生的概率；()
p A表示事件A发生的概率；()
p B事件B发生的概率。

则可以求得事件A发生的前提下，事件B 发生的概率。

贝叶斯定理给出了最小化误差的最优解决方法，可用于分类和预测。

将前面贝叶斯公式变化如下：
上述公式中，C代表类别，X代表特征，很明显，我们做出预测肯定是利用当前的特征，来判断输出的类别。

当然这里也可以很明显的看到贝叶斯公式先验与后验概率之间的转换，很明显，P(c|x)在我们的定义里面是后验概率，也是我们想要得到的东西。

而P(x)、P(c) 以及P(x|c)都是先验概率，它们分别X特征出现的概率，C类出现的概率，C类中，出现X的概率。

而第一项对于多类分类来说，都是一样，都是当前观察到的特征，所以此项可以略去。

那最终的结果就是计算P(x|c)*P(c)这一项，P（c）是可以通过观察来解决的。

重点也就全部落在了P(x|c)上，上面对于此项的解释是在C类中，X特征出现的概率，其实简单来讲，就是X的概率密度。

3、特点
1）。

贝叶斯分类并不是把一个对象绝对地指派给某一类，而是通过计算得出属于某一类的概率。

具有最大概率的类便是该对象所属的类。

2）。

一般情况下在贝叶斯分类中所有的属性都潜在的起作用，即并不是一个或几个属性决定分类，而是所有的属性都参与分类。

3）贝叶斯分类的属性可以是离散的、连续的、也可以是混合的。

4、分类：(1) 朴素贝叶斯算法。

(2) TAN算法
1)朴素贝叶斯算法成立的前提是各属性之间互相独立。

当数据集满足这种独立性假设时,分类的准确度较高，否则可能较低。

另外，该算法没有分类规则输出。

设每个数据样本用一个n维特征向量来描述n个属性的值，即：X={x1，x2，…，xn}，假定有m个类，分别用C1, C2,…，Cm表示。

给定一个未知的数据样本X（即没有类标号），若朴素贝叶斯分类法将未知的样本X分配给类Ci，则一定是
P(Ci|X)>P(Cj|X) 1≤j≤m，j≠i
根据贝叶斯定理
由于P(X)对于所有类为常数，最大化后验概率P(Ci|X)可转化为最大化先验概率
P(X|Ci)P(Ci)。

如果训练数据集有许多属性和元组，计算P(X|Ci)的开销可能非常大，为此，通常假设各属性的取值互相独立，这样
先验概率P(x1|Ci)，P(x2|Ci)，…，P(xn|Ci)可以从训练数据集求得。

根据此方法，对一个未知类别的样本X，可以先分别计算出X属于每一个类别Ci的概率P(X|Ci)P(Ci)，然后选择其中概率最大的类别作为其类别。

2）整个朴素贝叶斯分类的三个阶段：
第一阶段—准备工作阶段，这个阶段的任务是为朴素贝叶斯分类作必要的准备，主要的工作是根据具体情况确定特征属性，并对每个属性进行适当划分，然后由人工对一部分分类项进行分类，形成训练样本集合。

这一阶段的输入是所有带分类数据，输出是特征属性和训练样本。

第二阶段—分类器训练阶段，这个阶段的任务是生成分类器，主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计，并将结果记录。

其输入是特征属性和训练样本，输出是分类器。

第三阶段—应用阶段，这个阶段的任务是使用分类器对待分类项进行分类，期输入是分类器和待分类项，输出是待分类项和类别的映射关系。

(2) TAN算法
TAN算法通过发现属性对之间的依赖关系来降低NB中任意属性之间独立的假设。

它是在NB网络结构的基础上增加属性对之间的关联(边)来实现的。

实现方法是：用结点表示属性，用有向边表示属性之间的依赖关系，把类别属性作为根结点，其余所有属性都作为它的子节点。

通常，用虚线代表NB所需的边，用实线代表新增的边。

属性Ai与Aj之间的边意味着属性Ai对类别变量C的影响还取决于属性Aj的取值。

这些增加的边需满足下列条件：类别变量没有双亲结点，每个属性有一个类别变量双亲结点和最多另外一个属性作为其双亲结点。

找到这组关联边之后，就可以计算一组随机变量的联合概率分布如下：
其中ΠAi代表的是Ai的双亲结点。

由于在TAN算法中考虑了n个属性中(n-1)个两两属性之间的关联性，该算法对属性之间独立性的假设有了一定程度的降低，但是属性之间可能存
在更多其它的关联性仍没有考虑，因此其适用范围仍然受到限制。

5、关于贝叶斯分类：
贝叶斯分类器的分类原理是通过某类的先验概率，利用贝叶斯公式计算出其后验概率（即该对象属于某一类的概率）。

选择具有最大后验概率的类作为该对象所属的类。

贝叶斯决策就是在不完全情的情况下，对部分未知的状态用主观概率估计，然后用贝叶斯公式对发生概率进行修正，最后在利用期望值和修正概率做出最优决策。

6、代码朴素贝叶斯分类代码 matlab
2010-04-07 15:54
classdef NaiveBayesClassifier
%只进行所有属性是分类属性的分类情形
properties(SetAccess = private, GetAccess = private )
%diff_cls_values 和 cls_percent 是一一对应关系。

diff_cls_values; %标签值（列）
cls_percent; %标签值对应的百分比（列）
cls_atr_value; %元组代表第i类别中第j属性的所有值
cls_atr_perc; %元组代表第i类别中第j属性中不同值的百分比
end
methods
function obj = train_classifier(obj, training_set)
% training set: [x11 x12 ... x1n c11; ... ; xm1 xm2 ...xmn cmn] % 为数值型矩阵（使用前先进行转换）类别标签属性放在最后一维
%获得训练集,为数值形式表示,其中类别
disp('start to training ...');
[train_r, training_c] = size(training_set);
%自动统计所有的类别标签对应的个数，以及百分比，i.e.计算P(Ci)
Table = tabulate(training_set(:,end));
obj.diff_cls_values = Table(:, 1);
% cls_count = Table(:, 2);
obj.cls_percent = Table(:, 3);
%为每一个类别建立一个训练子集，以提高速度
dif_cls_val_num = size(obj.diff_cls_values, 1);
cou_cls = zeros(dif_cls_val_num, 1);
for j = 1 : dif_cls_val_num
cou_cls(j, 1) = 1;
end
for i = 1 : train_r
for j = 1 : dif_cls_val_num %类别
if obj.diff_cls_values(j, 1) == training_set(i, end)
subdataset_for_cls{j}(cou_cls(j, 1), : ) =
training_set(i, :);
cou_cls(j, 1) = cou_cls(j, 1) + 1;
end
end
end
%下面计算P(xi | Ci)
for i = 1 : dif_cls_val_num; % 每个类别
for j = 1 : training_c - 1 %每个属性
RET= tabulate(subdataset_for_cls{i}(:,j));
obj.cls_atr_value{i,j} = RET(:, 1); % 列
obj.cls_atr_perc{i,j} = RET(:, 3); % 列(百分比)
end
end
disp('finish training.');
end
function correct_ratio = classify_data(obj, test_set)
%test set: [x11 x12 ... x1n c11; ... ; xm1 xm2 ...xmn cmn]
%类别标签属性放在最后一维
disp('start to classify ...');
[test_r, test_c] = size(test_set);
correct_num = 0;
for i = 1 : test_r %每个测试元组
pred_label = obj.diff_cls_values(1,1);
great_prob = 0;
for j = 1 : size(obj.diff_cls_values, 1) % 每个类别
prob = 1;
for k = 1 : test_c - 1 %对于每个属性
valu_ind = 0;
for t = 1 : size(obj.cls_atr_value{j,k}, 1) %每个值
if obj.cls_atr_value{j,k}(t, 1) == test_set(i, k) valu_ind = t;
break;
end
end
if valu_ind == 0
prob = 0;
break;
end
prob = prob * obj.cls_atr_perc{j,k}(valu_ind, 1);
end
prob = prob * obj.cls_percent(j, 1);
if prob > great_prob
great_prob = prob;
pred_label = obj.diff_cls_values(j, 1);
end
end
if pred_label == test_set(i, end)
correct_num = correct_num + 1;
end
end
correct_ratio = correct_num / test_r;
disp('correct raion');
disp(correct_ratio);
disp('finish the classify task');
end
end
end
基于面向对象的matlab编程，使用举例：
%
clear;
clc;
% trainFilePath = 'trans_abalone_train.txt';
trainFilePath = 'coll_abalone_mush_0.1_2.txt';
testFilePath = 'trans_abalone_test.txt';
training_set = dlmread(trainFilePath);
test_set = dlmread(testFilePath);
NaiveClassifier = NaiveBayesClassifier();
NaiveClassifier = NaiveClassifier.train_classifier(training_set); correctRatio = NaiveClassifier.classify_data(test_set);
disp(correctRatio);
代码：：
朴素贝叶斯分类代码(适用于离散和连续属性) matlab
classdef NaiveBayesClassifierCC %可以处理属性为连续属性与离散属性混合的情形
properties(SetAccess = private, GetAccess = private)
attr_type; %用于记录属性的类型：连续（1）或离散（0）（行）
diff_cls_values; %训练集中所有类别标签值（列）
cls_percent; %标签值对应的百分比（列）
%连续属性表
conti_attr_means; %均值 (如果该维不是连续数属性，则设为系统默认值)(类别数*维数)
conti_attr_deviation; %标准差
%离散属性表 (如果该维不是离散属性，则设为系统默认值)
cls_atr_value; %元组代表第i类别中第j属性的所有值
cls_atr_perc; %元组代表第i类别中第j属性中不同值的百分比
end
methods
function obj = train_classifier(obj, training_set, attr_type)
disp('start to training ...');
[train_r, training_c] = size(training_set);
obj.attr_type = attr_type;
cate_count = 1;
cont_count = 1;
%自动统计所有的类别标签对应的个数，以及百分比，i.e.计算P(Ci) Table = tabulate(training_set(:,end));
obj.diff_cls_values = Table(:, 1);
% cls_count = Table(:, 2);
obj.cls_percent = Table(:, 3);
%为每一个类别建立一个训练子集，以提高速度(以便于求离散属性对应的百分比)
dif_cls_val_num = size(obj.diff_cls_values, 1); %不同类别个数值 cou_cls = ones(dif_cls_val_num, 1);
for i = 1 : train_r
for j = 1 : dif_cls_val_num %类别
if obj.diff_cls_values(j, 1) == training_set(i, end) subdataset_for_cls{j}(cou_cls(j, 1), : ) =
training_set(i, :);
cou_cls(j, 1) = cou_cls(j, 1) + 1;
end
end
end
conti_attr_means = zeros(dif_cls_val_num, training_c-1);
conti_attr_deviation = zeros(dif_cls_val_num, training_c-1); %下面计算P(xi | Ci) 或者均值与方差
for i = 1 : dif_cls_val_num; % 每个类别
for j = 1 : training_c - 1 %每个属性
if attr_type(1, j) %连续属性
conti_attr_means(i, j) =
mean(subdataset_for_cls{i}(:,j)); %均值
conti_attr_deviation(i, j) =
std(subdataset_for_cls{i}(:,j)); %标准差
else % 离散属性
RET= tabulate(subdataset_for_cls{i}(:,j));
obj.cls_atr_value{i,j} = RET(:, 1); % 列
obj.cls_atr_perc{i,j} = RET(:, 3); % 列(百分比) end
end
end
obj.conti_attr_means = conti_attr_means;
obj.conti_attr_deviation = conti_attr_deviation;
disp('finish training.');
end
function correct_ratio = classify_data(obj, test_set)
%test set: [x11 x12 ... x1n c11; ... ; xm1 xm2 ...xmn cmn]
%类别标签属性放在最后一维
disp('start to classify ...');
[test_r, test_c] = size(test_set);
correct_num = 0;
for i = 1 : test_r %每个测试元组
pred_label = obj.diff_cls_values(1,1);
great_prob = 0;
for j = 1 : size(obj.diff_cls_values, 1) % 每个类别
prob = 1;
for k = 1 : test_c - 1 %对于每个属性
if obj.attr_type(1,k) %连续属性
mean_ = obj.conti_attr_means(j, k);
std_dev = obj.conti_attr_deviation(j, k);
value_ = test_set(i, k);
prob = prob * obj.get_prob(value_, mean_,
std_dev);
else %离散属性
valu_ind = 0;
for t = 1 : size(obj.cls_atr_value{j,k}, 1) %每个值
if obj.cls_atr_value{j,k}(t, 1) ==
test_set(i, k)
valu_ind = t;
break;
end
end
if valu_ind == 0
prob = 0;
break;
end
prob = prob * obj.cls_atr_perc{j,k}(valu_ind, 1); end
end
prob = prob * obj.cls_percent(j, 1);
if prob > great_prob
great_prob = prob;
pred_label = obj.diff_cls_values(j, 1);
end
end
if pred_label == test_set(i, end)
correct_num = correct_num + 1;
end
end
correct_ratio = correct_num / test_r;
disp('correct raion');
disp(correct_ratio);
disp('finish the classify task');
end
function prob = get_prob(obj, value, mean_v, std_dev)
%std_dev: 标准差 mean: 均值
denominator = (2*pi)^0.5 * std_dev;
expont = - (value-mean_v)^2/(2*std_dev^2);
prob = exp(expont) / denominator;
end
end
end。