机器学习作业：数据分类
1 数据集
1.1 数据来源
Sonar数据集来源于UCI数据库，UCI是加州大学欧文分校(University of CaliforniaIrvine)提出的用于机器学习的数据库。其官网地址如下：http://archive.ics.uci.edu/ml/index.php
1.2 数据介绍
声纳数据集（Sonar Dataset ）涉及预测根据给定声纳从不同角度返回的强度预测目标物体是岩石还是矿井。数据集一共有208个观察值，60个特征，2个类别（M为矿井，R为岩石），每个类的观察值数量不均等。在该数据集上所做的预测最普遍类的基准性能是约 53％ 的分类准确率，最佳结果达到约 88% 的分类准确率。
如图1所示，本文使用的是经过数据预处理转化为.mat格式的Sonar数据集
2 分类算法
2.1 Logistic回归算法
2.11 算法介绍
logistic回归与分类是一种简单的分类算法。在分类的过程中只需要找到一个划分不同类的权重向量即可，对新的数据只需要乘上这个向量并比较就可以得到分类。logistic回归可以解决二分类问题甚至是多分类问题的，但是二分类的更为常用，也更加容易解释，所以本文主要用logistic回归解决二分类问题。
2.12 计算步骤
符号含义：h为权重，b为偏置、C为损失函数、a为预测标签，x为输入的特征，y为预测标签
（1）计算z
（2）z值用Sigmax映射到（0，1）区间，将标签换为0，1标签
（3）假设使用平方损失函数作为损失函数（损失函数是用来干啥的？用来求参数的！！！）
（4）计算权重h和偏置b的梯度
（5）更新权重（随机梯度下降法）
可使用的更新权重的方法具体参照：https://blog.csdn.net/suixinsuiyuan33/article/details/69525356
（6）当C的值达到指定小时，结束权重更新，得到的即为理想最优h、b
（7）将需要预测的数据特征利用得到的h、b计算预测标签达到分类的目的
参考：https://blog.csdn.net/u014595019/article/details/52554582?spm=1001.2014.3001.5506
2.2 贝叶斯分类
2.21 算法原理
对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。
2.22 算法流程
本文的代码是参考周志华老师的《西瓜书》写成的，所以这里引述周志华老师书中的朴素贝叶斯分类器及例子
书中例子
P(好瓜) = 8/17 = 0.471
P(坏瓜) = 9/17 = 0.529
参考：https://blog.csdn.net/kswkly/article/details/79545326?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161845450216780357296117%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161845450216780357296117&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2blogfirst_rank_v2~rank_v29-1-79545326.nonecase&utm_term=%E8%B4%9D%E5%8F%B6%E6%96%AF
2.3 高斯分布算法
2.31 算法原理
通过两个先验假设：一是样本数据的类别在给定的情况下服从伯努利分布，二是不同类别中的样本数据分别服从多元高斯分布。首先估计出先验概率以及多元高斯分布的均值和协方差矩阵，然后再由贝叶斯公式求出一个新样本分别属于两类别的概率，预测结果取概率值大者。
2.32 算法步骤
详细推导过程可查看（超推荐！！！感觉超好理解）
https://zhuanlan.zhihu.com/p/38269530
2.4 BP神经网络算法
2.41基本原理
BP神经网络是一种多层前馈神经网络，该网络的主要特点是信号前向传递，误差反向传播。在前向传播的过程中，输入信号从输入层经隐含层处理，直至输出层。每一层的神经元状态只影响下一层神经元状态。如果输出层得不到期望输出，则转入反向传播，根据预测误差调整网络权值和阈值，从而使BP神经网络预测输出不断逼近期望输出。
2.42 算法步骤
3 算法流程图
4.2 结果及分析
5 代码附录
% Logisti回归
clc
clear
close all
tic;%开始计时
load Sonar%加载数据集
data1=Sonar;
% 并将标签重新设置为0与1，方便sigmod函数应用
% 这里因为只分两类情况，所以挑选出两类数类，这里挑选的1，2类
%index = find((data1(:,61)==1)|(data1(:,61)==2));
%data1 = data1(index,:);
data1(:,61) = data1(:,61) - 1;
%选择训练样本个数
num_train = 156;
ac=[];%测试集正确率集
sc=[]%训练集正确率集
for k=1:20%计算20次
%构造随机选择序列
choose = randperm(size(data1,1));
train_data = data1(choose(1:num_train),:);%训练集
label_train = train_data(:,end);%训练集标签
test_data = data1(choose(num_train+1:end),:);%测试集
label_test = test_data(:,end);%测试集标签
data_D = size(train_data,2) - 1;%特征数量
% 初始化矩阵和偏置
weights = ones(1,data_D);
b= ones(1,data_D);
%% training data weights
% 随机梯度上升算法
for j=1:100%迭代伦次数，可根据准确率和自身需要设计
alpha = 0.1/j;%学习率，可根据准确率和自身需要设计，这里动态设计学习率，先用较大准确率提高效率，随轮数增加逐渐衰减，防止无法收敛
for i=1:size(train_data,1)
data = train_data(i,1:end-1);
h = 1.0/(1+exp(-(data*weights'+b)));%计算sigmod函数
error = label_train(i) - h;%真实值和预测值的误差
weights = weights + (alpha * error * data);%梯度上升算法更新权重，根据dJ/dW=error * data
b=b + (alpha * error);%梯度上升算法更新偏置
end
end
% 整体梯度算法-批量
% for j = 1:2000
% alpha = 0.1/j;
% data = train_data(:,1:end-1);
% h = 1./(1+exp(-(data*weights')));
% error = label_train - h;
% weights = weights + (alpha * data' * error)';
% end
%训练集预测结果
diff = zeros(2,size(train_data,1));%损失值矩阵，行数代表类别，列数代表个体数目
for i = 1:size(train_data,1)
data = train_data(i,1:end-1);
h = 1.0/(1+exp(-(data*weights')));
%计算损失矩阵
for j = 1:2
diff(j,i) = abs((j-1)-h);
end
end
[~,predict1] = min(diff);%返回预测标签
%计算准确率
accuracy = length(find(predict1'==(label_train+1)))/length(train_data);
sc=[sc accuracy];
%% predict the testing data
diff = zeros(2,size(test_data,1));
for i = 1:size(test_data,1)
data = test_data(i,1:end-1);
h = 1.0/(1+exp(-(data*weights')));
%compare to every label
for j = 1:2
diff(j,i) = abs((j-1)-h);
end
end
[~,predict] = min(diff);
accuracy = length(find(predict'==(label_test+1)))/length(test_data);
ac=[ac accuracy];
end
% 可视化结果
figure;
plot(label_train+1,'*')
hold on
plot(predict1,"or");
hold on
plot(abs(predict1'-(label_train+1)),'-g');
axis([0,size(train_data,1),0,3])
legend('实际类别类别','预测类别','误差曲线')
title(['基于Logistic算法对Sonar数据分类训练集平均准确率 :',num2str(sum(sc)/length(sc))]);
figure;
plot(label_test+1,'*')
hold on
plot(predict,'or');
hold on
plot(abs(predict'-(label_test+1)),'-g');
legend('实际类别类别','预测类别','误差曲线')
axis([0,length(test_data),0,3])
title(['基于Logistic算法对Sonar数据分类测试集平均准确率 :',num2str(sum(ac)/length(ac))]);
toc;%停止计时
%贝叶斯分类法
clc
clear all;
tic%计时开始
load Sonar%加载数据集
data1=Sonar;
% 这里因为只分两类情况，所以挑选出两类数类，这里挑选的1，2类，sonar数据集由于只有两类，所以可以省略
%index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选1，2类样本
data1 = data1(index,:);
num_train_train = 156;%训练样本个数
num_train_test=52;%测试样本个数
feature=60;%特征数量
ac=[];%测试集准确率集合
sc=[];%训练集准确率集合
for k=1:5%运行5轮
temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
%构造随机选择序列
choose = randperm(size(data1,1));
train=data1(choose(1:num_train_train),:);
train_data = train(:,1:end-1)
label_train = train(:,end);
test = data1(choose(num_train_train+1:end),:);
test_data=test(:,1:end-1);
label_test = test(:,end);
%计算出样本中各个属性的均值、方差和每个类的概率
pre1=[];%训练集类别概率矩阵
pre2=[];%测试集类别概率矩阵
predict1 = [];%训练集类别预测矩阵
predict=[]%测试集类别预测矩阵
PXY1=[];%训练集所有个体每个特征的条件概率密度
PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
PXY2=[];%测试集所有个体每个特征的条件概率密度
PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
X1 = [];%训练集中属于第一类的个体矩阵
X2 = []%训练集中属于第二类的个体矩阵
count = 0;%训练集中第一类的个体数
for j = 1:num_train
if label_train(j,1)==1
X1 = [X1;train_data(j,:)];
count = count + 1;
end
if label_train(j,1)==2
X2 = [X2;train_data(j,:)];
end
end
temp(1,:) = mean(X1,1);%计算第一类各特征的均值
temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
temp(3,:) = mean(X2,1);%计算第二类各特征的均值
temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
PX1 = count/num_train;%计算个体属于第一类的概率
PX2=1-PX1;%计算个体属于第二类的概率
%计算预测结果
%训练集上
for j = 1:size(train_data,1)
%由于Sonar各特征属性值为连续值，所以假设该属性值符合高斯分布，利用高斯分布计算概率密度
PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
PXY1=[];
for j = 1:size(train_data,1)
PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
%测试集上预测
for j = 1:size(test_data,1)
PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX1]
PXY2=[];
for j = 1:size(test_data,1)
PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX2]
%返回预测标签，个体属于哪一类的概率大，就判给哪一类
[~,predict1]=max(pre1');
accuracy = length(find(predict1'==label_train))/length(train_data);
sc=[sc accuracy];
[~,predict]=max(pre2');
accuracy = length(find(predict'==label_test))/length(test_data);
ac=[ac accuracy];
end
%可视化结果
figure;
plot(label_train,'*')
hold on
plot(predict1,"or");
hold on
plot(abs(predict1'-label_train),'-g');
axis([0,size(train_data,1),0,3])
legend('实际类别类别','预测类别','误差曲线')
title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
figure;
plot(label_test,'*')
hold on
plot(predict,'or');
hold on
plot(abs(predict'-label_test),'-g');
legend('实际类别类别','预测类别','误差曲线')
axis([0,length(test_data),0,3])
title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
toc%停止计时
clc
clear all;
tic%计时开始
load Sonar%加载数据集
data1=Sonar;
% 这里因为只分两类情况，所以挑选出两类数类，这里挑选的1，2类，sonar数据集由于只有两类，所以可以省略
%index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选1，2类样本
data1 = data1(index,:);
num_train_train = 156;%训练样本个数
num_train_test=52;%测试样本个数
feature=60;%特征数量
ac=[];%测试集准确率集合
sc=[];%训练集准确率集合
for k=1:5%运行5轮
temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
%构造随机选择序列
choose = randperm(size(data1,1));
train=data1(choose(1:num_train_train),:);
train_data = train(:,1:end-1)
label_train = train(:,end);
test = data1(choose(num_train_train+1:end),:);
test_data=test(:,1:end-1);
label_test = test(:,end);
%计算出样本中各个属性的均值、方差和每个类的概率
pre1=[];%训练集类别概率矩阵
pre2=[];%测试集类别概率矩阵
predict1 = [];%训练集类别预测矩阵
predict=[]%测试集类别预测矩阵
PXY1=[];%训练集所有个体每个特征的条件概率密度
PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
PXY2=[];%测试集所有个体每个特征的条件概率密度
PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
X1 = [];%训练集中属于第一类的个体矩阵
X2 = []%训练集中属于第二类的个体矩阵
count = 0;%训练集中第一类的个体数
for j = 1:num_train
if label_train(j,1)==1
X1 = [X1;train_data(j,:)];
count = count + 1;
end
if label_train(j,1)==2
X2 = [X2;train_data(j,:)];
end
end
temp(1,:) = mean(X1,1);%计算第一类各特征的均值
temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
temp(3,:) = mean(X2,1);%计算第二类各特征的均值
temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
PX1 = count/num_train;%计算个体属于第一类的概率
PX2=1-PX1;%计算个体属于第二类的概率
%计算预测结果
%训练集上
for j = 1:size(train_data,1)
%由于Sonar各特征属性值为连续值，所以假设该属性值符合高斯分布，利用高斯分布计算概率密度
PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
PXY1=[];
for j = 1:size(train_data,1)
PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
%测试集上预测
for j = 1:size(test_data,1)
PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX1]
PXY2=[];
for j = 1:size(test_data,1)
PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX2]
%返回预测标签，个体属于哪一类的概率大，就判给哪一类
[~,predict1]=max(pre1');
accuracy = length(find(predict1'==label_train))/length(train_data);
sc=[sc accuracy];
[~,predict]=max(pre2');
accuracy = length(find(predict'==label_test))/length(test_data);
ac=[ac accuracy];
end
%可视化结果
figure;
plot(label_train,'*')
hold on
plot(predict1,"or");
hold on
plot(abs(predict1'-label_train),'-g');
axis([0,size(train_data,1),0,3])
legend('实际类别类别','预测类别','误差曲线')
title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
figure;
plot(label_test,'*')
hold on
plot(predict,'or');
hold on
plot(abs(predict'-label_test),'-g');
legend('实际类别类别','预测类别','误差曲线')
axis([0,length(test_data),0,3])
title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
toc
clc
clear all;
tic%计时开始
load Sonar%加载数据集
data1=Sonar;
% 这里因为只分两类情况，所以挑选出两类数类，这里挑选的1，2类，sonar数据集由于只有两类，所以可以省略
%index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选1，2类样本
data1 = data1(index,:);
num_train_train = 156;%训练样本个数
num_train_test=52;%测试样本个数
feature=60;%特征数量
ac=[];%测试集准确率集合
sc=[];%训练集准确率集合
for k=1:5%运行5轮
temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
%构造随机选择序列
choose = randperm(size(data1,1));
train=data1(choose(1:num_train_train),:);
train_data = train(:,1:end-1)
label_train = train(:,end);
test = data1(choose(num_train_train+1:end),:);
test_data=test(:,1:end-1);
label_test = test(:,end);
%计算出样本中各个属性的均值、方差和每个类的概率
pre1=[];%训练集类别概率矩阵
pre2=[];%测试集类别概率矩阵
predict1 = [];%训练集类别预测矩阵
predict=[]%测试集类别预测矩阵
PXY1=[];%训练集所有个体每个特征的条件概率密度
PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
PXY2=[];%测试集所有个体每个特征的条件概率密度
PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
X1 = [];%训练集中属于第一类的个体矩阵
X2 = []%训练集中属于第二类的个体矩阵
count = 0;%训练集中第一类的个体数
for j = 1:num_train
if label_train(j,1)==1
X1 = [X1;train_data(j,:)];
count = count + 1;
end
if label_train(j,1)==2
X2 = [X2;train_data(j,:)];
end
end
temp(1,:) = mean(X1,1);%计算第一类各特征的均值
temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
temp(3,:) = mean(X2,1);%计算第二类各特征的均值
temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
PX1 = count/num_train;%计算个体属于第一类的概率
PX2=1-PX1;%计算个体属于第二类的概率
%计算预测结果
%训练集上
for j = 1:size(train_data,1)
%由于Sonar各特征属性值为连续值，所以假设该属性值符合高斯分布，利用高斯分布计算概率密度
PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
PXY1=[];
for j = 1:size(train_data,1)
PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
PXY1=[PXY1;PXYj1]
end
pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
%测试集上预测
for j = 1:size(test_data,1)
PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX1]
PXY2=[];
for j = 1:size(test_data,1)
PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
PXY2=[PXY2;PXYj2]
end
pre2 = [pre2 prod(PXY2,2).*PX2]
%返回预测标签，个体属于哪一类的概率大，就判给哪一类
[~,predict1]=max(pre1');
accuracy = length(find(predict1'==label_train))/length(train_data);
sc=[sc accuracy];
[~,predict]=max(pre2');
accuracy = length(find(predict'==label_test))/length(test_data);
ac=[ac accuracy];
end
%可视化结果
figure;
plot(label_train,'*')
hold on
plot(predict1,"or");
hold on
plot(abs(predict1'-label_train),'-g');
axis([0,size(train_data,1),0,3])
legend('实际类别类别','预测类别','误差曲线')
title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
figure;
plot(label_test,'*')
hold on
plot(predict,'or');
hold on
plot(abs(predict'-label_test),'-g');
legend('实际类别类别','预测类别','误差曲线')
axis([0,length(test_data),0,3])
title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
toc
%// GDA参数求解
% 高斯判别分析模型的参数估计
% x为样本特征，y为样本类别
%初始化，代码注释见logistic和贝叶斯代码
clc
clear all;
tic
load Sonar
data1=Sonar;
index = find((data1(:,61)==1)|(data1(:,61)==2));
data1 = data1(index,:);
data1(:,61) = data1(:,61) - 1;
%选择训练样本个数
num_train = 156;
num_test=52;
ac=[]
sc=[]
%构造随机选择序列
for k=1:20
choose = randperm(size(data1,1));
train=data1(choose(1:num_train),:);
train_data = train(:,1:end-1)
label_train = train(:,end);
test = data1(choose(num_train+1:end),:);
test_data=test(:,1:end-1);
label_test = test(:,end);
data_D = size(train,2) - 1;%特征数量
x=train_data ;
y=label_train;
m=size(x,1);% 记录样本总数
x_pos=[];% 样本正例，即标签为1的个体
x_neg=[];% 样本负例，即标签为0的个体
y_pos=[];%样本正标签
y_neg=[];%样本负例标签
y_pred1=zeros(num_train,1);%训练集预测结果
y_pred=zeros(num_test,1);%测试集预测结果
for i=1:size(x,1)
if y(i)==1
x_pos=[x_pos;x(i,:)];
y_pos=[y_pos;y(i)];
else
x_neg=[x_neg;x(i,:)];
y_neg=[y_neg;y(i)];
end
end
fi=size(y_pos,1)/m; %计算参数fi，即样本中正例所占的比例
Py1=fi^1*(1-fi)^0;%计算个体属于正例的概率
Py0=fi^0*(1-fi)^1%计算个体属于负例的概率
u_pos=sum(x_pos,1)./(size(y_pos,1));% 计算参数u1
u_neg=sum(x_neg,1)./(size(y_neg,1));% 计算参数u0
for i=1:m
if y(i)==1
xx=[xx;x(i,:)-u_pos];
else
xx=[xx;x(i,:)-u_neg];
end
end
sigma=(xx'*xx)./m;
% 类别判断
%训练集类别预测
for i=1:size(train_data,1)
diff1=train_data(i,:)-u_pos;
diff2=train_data(i,:)-u_neg;
n=size(train_data(i,:),2);
sigma=sigma+0.001;%保证矩阵行列式非零
x_pos=exp((diff1*inv(sigma)*diff1')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
x_neg=exp((diff2*inv(sigma)*diff2')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
if Py1*x_pos>x_neg*Py0
y_pred1(i)=1;
else
y_pred1(i)=0;
end
end
accuracy = length(find(y_pred1==label_train))/length(label_train);
sc=[sc accuracy]
%测试集类别预测
for i=1:size(test_data,1)
diff1=test_data(i,:)-u_pos;
diff2=test_data(i,:)-u_neg;
n=size(test_data(i,:),2);
%sigma=sigma+0.001;%保证矩阵行列式非零
x_pos=exp((diff1*inv(sigma)*diff1')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
x_neg=exp((diff2*inv(sigma)*diff2')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
if Py1*x_pos>x_neg*Py0
y_pred(i)=1;
else
y_pred(i)=0;
end
end
accuracy = length(find(y_pred==label_test))/length(label_test);
ac=[ac accuracy];
end
%结果可视化
figure
plot(label_test+1,'*')
hold on
plot(y_pred+1,'or');
hold on
plot(abs(y_pred-label_test),'-g');
axis([0,length(label_test),0,3])
legend('实际类别','预测类别','误差曲线')
title(['基于高斯判别的Sonar数据测试集平均分类准确率 :',num2str(sum(ac)/length(ac))]);
figure
plot(label_train+1,'*')
hold on
plot(y_pred1+1,'or');
hold on
plot(abs(y_pred1-label_train),'-g');
axis([0,length(label_train),0,3])
legend('实际类别','预测类别','误差曲线')
title(['基于高斯判别的Sonar数据训练集集平均分类准确率 :',num2str(sum(sc)/length(sc))]);
toc%结束计时
%% 清空环境变量
clc
clear all;
% 训练数据预测数据提取及归一化
tic
load Sonar;%载入数据
data=Sonar;
%输入输出数据
input=data(:,1:end-1);%特征
output1 =data(:,end);%标签
ac=[]%测试集准确率集合
sc=[]%训练集准确率集合
%把输出从1维变成2维，并且把标签变为0，1标签
output=zeros(208,2);
for i=1:208
switch output1(i)
case 1
output(i,:)=[1 0];
case 2
output(i,:)=[0 1];
end
end
%随机提取156个样本为训练样本，52个样本为预测样本
%选择训练样本个数
num_train = 156;
num_test=52;
%构造随机选择序列
for k=1:20
choose = randperm(size(data,1));
input_train=input(choose(1:num_train),:)';%测试集数据
output_train=output(choose(1:num_train),:)';%测试集标签
input_test=input(choose(num_train+1:end),:)';%训练集数据
output_test=output(choose(num_train+1:end),:)';%训练集标签
%输入数据归一化
[inputn,inputps]=mapminmax(input_train);
%% 网络结构初始化
innum=60;%输入层节点个数，即数据的特征数
midnum=18;%隐藏层节点个数，自己设计
outnum=2;%输出层节点个数，类别数目
%权值初始化
w1=rands(midnum,innum);
b1=rands(midnum,1);
w2=rands(midnum,outnum);
b2=rands(outnum,1);
w2_1=w2;
w2_2=w2_1;
w1_1=w1;
w1_2=w1_1;
b1_1=b1;
b1_2=b1_1;
b2_1=b2;
b2_2=b2_1;
%学习率
xite=0.1;
alfa=0.01;
loopNumber=10;
I=zeros(1,midnum);
Iout=zeros(1,midnum);
FI=zeros(1,midnum);
dw1=zeros(innum,midnum);
db1=zeros(1,midnum);
%% 网络训练
E=zeros(1,loopNumber);
for ii=1:loopNumber
E(ii)=0;
for i=1:1:156
%% 网络预测输出
x=inputn(:,i);
% 隐含层输出
for j=1:1:midnum
I(j)=inputn(:,i)'*w1(j,:)'+b1(j);
Iout(j)=1/(1+exp(-I(j)));
end
% 输出层输出
yn=w2'*Iout'+b2;
%% 权值阀值修正
%计算误差
e=output_train(:,i)-yn;
E(ii)=E(ii)+sum(abs(e));
%计算权值变化率
dw2=e*Iout;
db2=e';
for j=1:1:midnum
S=1/(1+exp(-I(j)));
FI(j)=S*(1-S);
end
for k=1:1:innum
for j=1:1:midnum
dw1(k,j)=FI(j)*x(k)*(e(1)*w2(j,1)+e(2)*w2(j,2));
db1(j)=FI(j)*(e(1)*w2(j,1)+e(2)*w2(j,2));
end
end
w1=w1_1+xite*dw1';
b1=b1_1+xite*db1';
w2=w2_1+xite*dw2';
b2=b2_1+xite*db2';
w1_2=w1_1;w1_1=w1;
w2_2=w2_1;w2_1=w2;
b1_2=b1_1;b1_1=b1;
b2_2=b2_1;b2_1=b2;
end
end
% 语音特征信号测试集分类
%训练集
inputn_train=mapminmax('apply',input_train,inputps);
fore=zeros(2,num_train);
for ii=1:1
for i=1:num_train
%隐含层输出
for j=1:1:midnum
I(j)=inputn_train(:,i)'*w1(j,:)'+b1(j);
Iout(j)=1/(1+exp(-I(j)));
end
fore(:,i)=w2'*Iout'+b2;
end
end
%% 结果分析
%根据网络输出找出数据属于哪类
output_fore1=zeros(1,num_train);
for i=1:num_train
output_fore1(i)=find(fore(:,i)==max(fore(:,i)));
end
%BP网络预测误差
outputfact1=output1(choose(1:num_train),:);
accuracy = length(find(output_fore1'==outputfact1))/length(outputfact1);
sc=[sc accuracy];
%测试集
inputn_test=mapminmax('apply',input_test,inputps);
fore=zeros(2,num_test);
for ii=1:1
for i=1:num_test%1500
%隐含层输出
for j=1:1:midnum
I(j)=inputn_test(:,i)'*w1(j,:)'+b1(j);
Iout(j)=1/(1+exp(-I(j)));
end
fore(:,i)=w2'*Iout'+b2;
end
end
%% 结果分析
%根据网络输出找出数据属于哪类
output_fore=zeros(1,num_test);
for i=1:num_test
output_fore(i)=find(fore(:,i)==max(fore(:,i)));
end
%BP网络预测误差
outputfact=output1(choose(num_train+1:end),:);
accuracy = length(find(output_fore'==outputfact))/length(outputfact);
ac=[ac accuracy];
end
figure
plot(outputfact1,'*')
hold on
plot(output_fore1,'or');
hold on
plot(abs((output_fore1'-outputfact1)),'-g');
axis([0,length(outputfact1),0,3])
legend('实际类别','预测类别','误差曲线')
title(['基于BP神经网络在Sonar数据训练集上分类的平均准确率为 :',num2str(sum(sc)/length(sc))]);
figure
plot(outputfact,'*')
hold on
plot(output_fore,'or');
hold on
plot(abs((output_fore'-outputfact)),'-g');
axis([0,length(outputfact),0,3])
legend('实际类别','预测类别','误差曲线')
title(['基于BP神经网络在Sonar数据测试集上分类的平均准确率为 :',num2str(sum(ac)/length(ac))]);
toc