[贝叶斯四]之贝叶斯分类器设计

这一小节我们将简单的阐述一般贝叶斯分类器设计的方法。分类器流程如下所示。

• 输入：d-dim 特征向量
• 计算决策函数值(针对每个类别)
• 选取最大的值
• 做出决策
• 输出结果

如下图可以清楚的表达整个分类器工作的流程。

借用《算法杂货铺——分类算法之朴素贝叶斯分类(Naive Bayesian classification)》的一张图来表示整个设计的流程。

下面我们将以两个小例子来贯穿贝叶斯分类器设计的整个流程。

一、MNIST手写体识别

1.0 数据集简介

MNIST是一个0-9的手写数字数据库。MNIST数据集中包含60000张手写数字图片，10,000 张测试图片。每张图片的大小为28*28，包含一个手写数字。如下图所示。数据集链接：http://yann.lecun.com/exdb/MNIST/。

数据集中包含四个文件。

1.  train-images-idx3-ubyte.gz:  training set images (9912422 bytes)   
2.  train-labels-idx1-ubyte.gz:  training set labels (28881 bytes)   
3.  t10k-images-idx3-ubyte.gz:   test set images (1648877 bytes)   
4.  t10k-labels-idx1-ubyte.gz:   test set labels (4542 bytes)  

整理一下MNIST数据集。

• 四个文件。train_image，train_label，test_image，test_label
• 图像数据。28*28的图像尺寸的灰度图像，所以每张图像为28*28*1
• 标签。针对每个数据给出0-9中一个数字作为类别。

1.1、特征向量准备

搞个三部曲：

• 数据准备
• 模型设计
• 模型训练

贝叶斯决策论也不例外，首要的，我们需要将原始数据经过一系列清洗得到输入的特征向量。

咋输入数据？

MNIST数据集四个文件是用二进制进行编写，详细的格式如下图所示，展示image file 和 label file。

数据的预处理可以分为两部分：第一部分就是读入数据，第二部分就是提取成想要的特征向量。
（1）读入数据。实验中我们采用MATLAB编写，利用文件指针逐个字节读取，得到一个mat，然后reshape到784*N的数据形式，注意这里得到的都是0-255像素。对于label也是同理得到N*1的数据形式。
（2）提取特征向量。 最后我们需要对读入的数据进行处理得到我们想要的特征向量。这里实验做法十分暴力，直接将图像变成二值化(将0-255 resize到0、1)，然后向量长度不变。所以得到的形式是784*N的二值化的矩阵。Label不做任何处理。

这里主要是阐述整个设计流程，所以直接用最简单的方式提取特征。感兴趣的同学可以尝试用PCA等特征生成的方式将输入的图像做特征提取。

1.2、决策函数设计

接下来是分类器设计的主要步骤：决策函数设计。首先我们从最顶层开始往下进行推导。贝叶斯分类的核心就是找到最大的后验概率，也就是给出一个样本 x x ，它属于yj y j 的概率最大，那么我们就认为样本 x x 是属于第j j 类的。由此我们的分类器设计的目标就是计算概率值 p(yj|xi) p ( y j | x i ) .

下面我们先给出形式化的定义。

• D=x(i)，y(i),i=1,2,3,4……n D = x ( i ) ， y ( i ) , i = 1 , 2 , 3 , 4 … … n 表示我们的数据集；
• x(i) x ( i ) 是784维的向量，表示第 i i 个样本；
• y(i) y ( i ) 是标注的第 i i 个样本的类别，取值范围是0-9；
• xk(i) x k ( i ) 表示第 i i 个样本的第k k 维。

决策函数定义
一般情况下，贝叶斯都是采用了最小错分准则，这里也是如此。由此我们可以得到我们的目标决策函数。

p(y=j|x) p ( y = j | x )

也就是说对于一个样本 x x ，我们只需要计算出它们属于每一类的后验概率，并将样本x x 判定给后验概率大的那一类 j j . 接下来我们就此解释该如何计算出这个后验概率，也就是模型的建立过程。

1.2.1 模型建立

根据最小错分原则，所以我们的目标就是求解最大的后验概率，由此得到结果类别。写成公式如下。

target=argmaxjp(y=j|x) t a r g e t = a r g m a x j p ( y = j | x )

对于一个784维的样本 x x ，它的每一维出现是相互独立的（属性之间相互独立，也被称为朴素贝叶斯）。由此我们可以将我们目标后验概率写成如下公式。

p(y=j|x)=∏kp(y=j|xk) p ( y = j | x ) = ∏ k p ( y = j | x k )

其中：

• xk x k 表示样本 x x 的第k k 个元素

接下来转换目标为求解每个像素点的相应后验概率（也就是样本每个元素的后验概率）。根据贝叶斯公式，我们得到一个设计模型。该式子的意义为：针对一个样本 x x 的第k k 个元素出现，属于第 j j 类样本的概率。

p(y=j|xk)=p(xk|y=j)p(y=j)p(xk) p ( y = j | x k ) = p ( x k | y = j ) p ( y = j ) p ( x k )

这个模型非常好理解。我们要求的就是已知样本第 k k 个元素(像素)情况下，这个样本是属于第j类的概率。这个概率就可以用贝叶斯得到。由此我们通过训练样本可以得到如下概率值(因为我们的特征向量元素取值为0或者1)。

p(xk=1)=#图片中第k个像素为1的个数#所有图片的个数，n p ( x k = 1 ) = # 图 片 中 第 k 个 像 素 为 1 的 个 数 # 所 有 图 片 的 个 数 ， n

p(y=j)=#属于第j类的图像数#所有图片的个数，n p ( y = j ) = # 属 于 第 j 类 的 图 像 数 # 所 有 图 片 的 个 数 ， n

p(xk=1|y=j)=#属于第j类的图像而且第k个像素为1的图像数量#属于第j类图像的个数(1)(2) (1) p ( x k = 1 | y = j ) = (2) # 属 于 第 j 类 的 图 像 而 且 第 k 个 像 素 为 1 的 图 像 数 量 # 属 于 第 j 类 图 像 的 个 数

因为每个像素只可能为0或者1，所以我们直接计算的是像素为1的情况。由此我们的模型就已经建立了。Model中就是这三个根据训练数据得到概率值，接下来我们将讨论如何根据这个模型判断某个样本的类别。

1.2.2 模型测试

根据给出的训练数据集，我们能计算出如上的 p(xk=1) p ( x k = 1 ) 、 p(y=j) p ( y = j ) 和 p(xk=1|y=j) p ( x k = 1 | y = j ) . 根据这几个结果，我们得到了后验概率 p(y=j|xk) p ( y = j | x k ) .

问题是，针对测试样本，我们该如何计算？这是该贝叶斯分类器设计中的核心，很多人觉得在这里很绕。之前我们是根据给出的训练数据计算出的一个模型，换句话有点像最大似然估计法：用有限的观测数据来估计一个未知参数的模型。比如对于一个抛硬币测试，我们想知道硬币正反出现的概率模型，那么我们经过大量的实验，然后计算最大似然。由此得到一个模型参数。这里也是一样，我们得到的是叫做贝叶斯模型。根据这个模型，然后加上输入的测试样本，我们计算出最大的后验概率。

假设这个时候来了一个样本 x x ，对于这个样本的第k k 个元素显然是服从二分布的，要不为1，要不为0。所以我们根据之前的模型计算中的后验概率计算方法，首先计算出这个样本低 k k 个元素的出现概率。

p(xk)=p(xk=1)x(1−p(xk=1))1−x p ( x k ) = p ( x k = 1 ) x ( 1 − p ( x k = 1 ) ) 1 − x

p(xk=i)=⎧⎩⎨⎪⎪#图片中第k个像素为1的个数#所有图片的个数n#图片中第k个像素为0的个数#所有图片的个数nif i is 1if i is 0 p ( x k = i ) = { # 图 片 中 第 k 个 像 素 为 1 的 个 数 # 所 有 图 片 的 个 数 n if  i  is 1 # 图 片 中 第 k 个 像 素 为 0 的 个 数 # 所 有 图 片 的 个 数 n if  i  is 0

同理，对于第 j j 类情况下，样本x x 的第 k k 个元素也是服从二分布的。由此我们可以得到如下的式子。

p(xk|y=j)=p(xk=1|y=j)xk(1−p(xk=1|y=j)(1−xk))(3) (3) p ( x k | y = j ) = p ( x k = 1 | y = j ) x k ( 1 − p ( x k = 1 | y = j ) ( 1 − x k ) )

同理，用通俗易懂的式子描述如下。

p(xk=i|y=j)=⎧⎩⎨⎪⎪#属于第j类的图像而且第k个像素为1的图像数量#属于第j类图像的个数#属于第j类的图像而且第k个像素为0的图像数量#属于第j类图像的个数if i is 1if i is 0 p ( x k = i | y = j ) = { # 属 于 第 j 类 的 图 像 而 且 第 k 个 像 素 为 1 的 图 像 数 量 # 属 于 第 j 类 图 像 的 个 数 if  i  is 1 # 属 于 第 j 类 的 图 像 而 且 第 k 个 像 素 为 0 的 图 像 数 量 # 属 于 第 j 类 图 像 的 个 数 if  i  is 0

整理后，我们得到样本 x x 出现的后验概率为(这里采用贝叶斯定理即可得到)。

p(y=j|x)=∏kp(y=j|xk)=∏kp(xk|y=j)p(y=j)p(xk)(4)(3) (4) p ( y = j | x ) = ∏ k p ( y = j | x k ) (3) = ∏ k p ( x k | y = j ) p ( y = j ) p ( x k )

对于输入的测试样本 x x ，我们已知了每个元素的值xk=i，i∈{0,1} x k = i ， i ∈ { 0 , 1 } ，那么我们将该值带入到上式进行计算就好了。比如我们可以得到。

p(xk=i|y=j)p(y=j)p(xk=i) p ( x k = i | y = j ) p ( y = j ) p ( x k = i )

由此就能计算出 target=argmaxjp(y=j|x) t a r g e t = a r g m a x j p ( y = j | x ) 。
到此为止，我们决策函数的分析彻底结束。接下来就是模型的训练。

1.3 模型训练

这一部分主要就是工程问题，首先根据输入的训练数据，计算出上述的模型(也就是train文件)。然后写一个输入样本得到预测结果的文件(也就是test文件)。

二、字母分类设计

接下来，趁热打铁，我们接着撸一个类似的例子。同学们可以根据需求，自己先推一边。过程是一模一样的。

数据集来自于UCI： UCI字母分类数据集链接

2.0 数据集分析

老套路，我们对数据集先做个简单的分析，主要是知道数据集的数据形式，便于写程序进行读取和预处理。

这个数据集原始数据一共包含20000张图像(一般取前16000张图像作为训练，后4000张图像作为测试)，每张图像经过作者处理后得到了一个16维的特征(特征值是一个0-15的整数)，标签就是所代表的字母A-Z。数据形式如下：

1.   lettr   capital letter  (26 values from A to Z)  
2.   x-box   horizontal position of box  (integer)  
3.   y-box   vertical position of box    (integer)  
4.   width   width of box            (integer)  
5.   high    height of box           (integer)  
6.   onpix   total # on pixels       (integer)  
7.   x-bar   mean x of on pixels in box  (integer)  
8.   y-bar   mean y of on pixels in box  (integer)  
9.   x2bar   mean x variance         (integer)  
10.  y2bar   mean y variance         (integer)  
11.  xybar   mean x y correlation        (integer)  
12.  x2ybr   mean of x * x * y       (integer)  
13.  xy2br   mean of x * y * y       (integer)  
14.  x-ege   mean edge count left to right   (integer)  
15.  xegvy   correlation of x-ege with y (integer)  
16.  y-ege   mean edge count bottom to top   (integer)  
17.  yegvx   correlation of y-ege with x (integer)

其中20000张图像的分布如下：

1.  789 A      766 B     736 C     805 D     768 E     775 F     773 G  
2.  734 H      755 I     747 J     739 K     761 L     792 M     783 N  
3.  753 O      803 P     783 Q     758 R     748 S     796 T     813 U  
4.  764 V      752 W     787 X     786 Y     734 Z

整理一下这个数据集。

• 一个文件。共20000条数据，我们将前16000条数据作为训练数据，后4000条数据作为测试数据。
• 数据格式。16维的特征向量，一个A-Z的label

2.1 特征向量生成

由第1章问题的描述中我们可以知道，字母数据集已经帮我们做好了特征向量提取的工作。数据形式如下所示。

由此我们只需要经过简单的处理就能得到我们想要的数据。

• Image数据。上图所示每行16维向量，每个特征值取值为0-15的整数。形式为16*N。
• Label。上图中每行第1列，A-Z。

Step1：数据读入(loadData.m)

% load data from file, start --start line, end --end line
function [labels, features] = loadData(filename,start,endl)

[data1,data2,data3,data4,data5,data6,data7,data8,data9,data10,data11,data12,data13,data14,data15,data16,data17] = textread(filename, '%c%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d','delimiter',',');

labels  = data1(start:endl,1);
features = [data2,data3,data4,data5,data6,data7,data8,data9,data10,data11,data12,data13,data14,data15,data16,data17];
features = features(start:endl,:);

%labels = labels.';
features = features.' + 1;
% 注意：这里的下标是0~15

end

2.2 决策函数

2.2.1 模型建立

我们需要训练的模型跟上述数字手写体分类一样，目标如下。

p(y=j|x)=∏kp(y=j|xk) p ( y = j | x ) = ∏ k p ( y = j | x k )

物理解释是：针对每个输入测试样本，我们需要求解一个它属于j类的后验概率，这个后验概率等于16维特征属于j类的后验概率。 p(y=j|xk) p ( y = j | x k ) 是代表：给出样本 x x 的第k k 的元素，那么这个元素属于第 j j 类中实例的概率。因为我们认为每个样本特征之间是相互独立的，所以采用乘法。

由此我们的目标就变成了如何计算这个样本第k k 个元素值属于第 j j 类的后验概率问题。

p(y=j|xk)=p(xk|y=j)p(y=j)p(xk) p ( y = j | x k ) = p ( x k | y = j ) p ( y = j ) p ( x k )

其中：

• p(y=j) p ( y = j ) 表示类别 j j 出现的概率
• p(xk=j) p ( x k = j ) 表示样本第 k k 个元素为i i 的概率
  p(xk=i)=#样本中第k个元素为i的样本数#样本总数 p ( x k = i ) = # 样 本 中 第 k 个 元 素 为 i 的 样 本 数 # 样 本 总 数
• p(xk=i|y=j) p ( x k = i | y = j ) 表示样本属于第 j j 类情况下第k k 个元素的值为 i i 的概率
  p(xk=i|y=j)=#第j类样本中第k个元素为i的样本数#第j类样本总数 p ( x k = i | y = j ) = # 第 j 类 样 本 中 第 k 个 元 素 为 i 的 样 本 数 # 第 j 类 样 本 总 数

这个就是我们需要训练的模型。

Step2: 训练模型(bc_train.m)

function [model] = bc_train(x, y, J)

[K,N] = size(x);     %K为维度，N为样本数

% p(w): 类别 i 出现的概率
py = zeros(J,1);
for i=1:J
    py(i,:) = sum(y == i)/N;
end

% p(x_k_i): 样本中第k个元素为i的个数 / 样本总数
pki = zeros(16,16);
for k=1:16
    for i=1:16
        pki(k,i) = sum(x(k,:) == i)/N;  
    end
end

% p(x_k_i | j): 第j类样本中第k个元素为i的样本数 / 第j类样本总数
pkij = zeros(16,16,J);
for j=1:J
    for k=1:16
        xj = x(:,y==j);  %属于第j类的样本
        for i=1:16
            pkij(k,i,j) = sum(xj(k,:)==i)/size(xj,2);
        end
    end
end

model.pki = pki;
model.py = py;
model.pkij = pkij;

end

2.2.2 模型测试

假定给出一个样本 x x ，我们可以根据每个特征的值计算出属于第j j 类的后验概率。

p(y=j|xk=i)=p(xk=i|y=j)p(y=j)p(xk=i) p ( y = j | x k = i ) = p ( x k = i | y = j ) p ( y = j ) p ( x k = i )

上式中，给出的测试样本 x x 显然是确定的，所以xk=i x k = i 中$i$值是一个确定值。根据上述得到的model，我们就能计算出属于第j类的后验概率了。最后将特征值的后验概率相乘，取最大值所在的类，就是我们计算得到的类别。

其中，runChar.m文件为主程序，代码如下：

经测试，模型在测试集上的分类正确率为：73.43%。

Step3: 测试数据(bc_predict.m)

function [yp] = bc_predict(model,x,J)

[K,N] = size(x);

pki = model.pki;
py = model.py;
pkij = model.pkij;

% p(y_j|i): 样本第i个元素为 x(:,i) 情况下，类别为j的概率
pyji = zeros(J,16,N);
for j=1:J
    for i = 1:16
        for n=1:N
            pyji(j,i,n) = pkij(i,x(i,n),j) * py(j) / pki(i,x(i,n)); 
        end
    end
end

result = prod(pyji,2);
yp = zeros(N,1);
for i=1:N
    [m,yp(i,:)] = max(result(:,:,i));
end

Step4: 主程序(runChar.m)

clear
clc
%% Step1: read data

[train_labels,train_char] = loadData('./char/letter-recognition.data.txt',1,16000);
[test_labels,test_char] = loadData('./char/letter-recognition.data.txt',16001,20000);

%% Step2: train model

train_labels = train_labels - 'A' + 1;
model = bc_train(train_char, train_labels, 26);

%% Step3: predict

test_labels = test_labels - 'A' + 1;
yp = bc_predict(model,test_char,26);
accuary_test = sum(yp == test_labels) / length(test_labels);

四、 参考文献

[1] MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges. 下载链接
[2] UCI Machine Learning Repository: Letter Recognition Data Set. 下载链接
[3] Using the MNIST Dataset. 下载链接
[4] 周志华. 《机器学习》[M]. 清华大学出版社, 2016.
[5] 李航. 《统计学习方法》[M].清华大学出版社,2013.
[6] 机器学习之贝叶斯分类器
[7] 机器学习通俗入门-朴素贝叶斯分类器

---

其它平台只是信息转发(留言可能看不到)，欢迎同学们到个人blog交流：https://faiculty.com/

PS： 如需数据和代码请上faiculty留言