特征向量和分类方法
分类与聚类的区别
机器学习中有常见的两类大问题，一个是分类，一个是聚类。
分类与聚类的比较
1. 聚类分析是研究如何在没有训练的条件下把样本划分为若干类。
2. 在分类中，已知存在哪些类，即对于目标数据库中存在哪些类是知道的，要做的就是将每一条记录分别属于哪一类标记出来。
3. 聚类需要解决的问题是将已给定的若干无标记的模式聚集起来使之成为有意义的聚类，聚类是在预先不知道目标数据库到底有多少类的情况下，希望将所有的记录组成不同的类或者说聚类，并且使得在这种分类情况下，以某种度量（例如：距离）为标准的相似性，在同一聚类之间最小化，而在不同聚类之间最大化。
4. 与分类不同，无监督学习不依赖预先定义的类或带类标记的训练实例，需要由聚类学习算法自动确定标记，而分类学习的实例或数据样本有类别标记。
分类算法的局限
分类作为一种监督学习方法，要求必须事先明确知道各个类别的信息，并且断言所有待分类项都有一个类别与之对应。但是很多时候上述条件得不到满足，尤其是在处理海量数据的时候，如果通过预处理使得数据满足分类算法的要求，则代价非常大，这时候可以考虑使用聚类算法。
聚类
聚类的相关的一些概念如下
而聚类指事先并不知道任何样本的类别标号，希望通过某种算法来把一组未知类别的样本划分成若干类别，聚类的时候，我们并不关心某一类是什么，我们需要实现的目标只是把相似的东西聚到一起，这在机器学习中被称作 unsupervised learning （无监督学习）
通常，人们根据样本间的某种距离或者相似性来定义聚类，即把相似的（或距离近的）样本聚为同一类，而把不相似的（或距离远的）样本归在其他类。
聚类的目标：组内的对象相互之间时相似的（相关的），而不同组中的对象是不同的（不相关的）。组内的相似性越大，组间差别越大，聚类就越好。
欧式距离和马氏距离
聚类算法
聚类算法分类
1.基于划分
给定一个有N个元组或者纪录的数据集，分裂法将构造K个分组，每一个分组就代表一个聚类，K<N。
特点：计算量大。很适合发现中小规模的数据库中小规模的数据库中的球状簇。
算法：K-MEANS算法、K-MEDOIDS算法、CLARANS算法
2.基于层次
对给定的数据集进行层次似的分解，直到某种条件满足为止。具体又可分为“自底向上”和“自顶向下”两种方案。
特点：较小的计算开销。然而这种技术不能更正错误的决定。
算法：BIRCH算法、CURE算法、CHAMELEON算法
3.基于密度
只要一个区域中的点的密度大过某个阈值，就把它加到与之相近的聚类中去。
特点：能克服基于距离的算法只能发现“类圆形”的聚类的缺点。
算法：DBSCAN算法、OPTICS算法、DENCLUE算法
4.基于网格
将数据空间划分成为有限个单元（cell）的网格结构,所有的处理都是以单个的单元为对象的。
特点：处理速度很快，通常这是与目标数据库中记录的个数无关的，只与把数据空间分为多少个单元有关。
算法：STING算法、CLIQUE算法、WAVE-CLUSTER算法
K-Means聚类算法
**步骤如下**
1. 初始化。输入基因表达矩阵作为对象集X，输入指定聚类类数N，并在X中随机选取N个对象作为初始聚类中心。设定迭代中止条件，比如最大循环次数或者聚类中心收敛误差容限。
2. 进行迭代。根据相似度准则将数据对象分配到最接近的聚类中心，从而形成一类。初始化隶属度矩阵。
3. 更新聚类中心。然后以每一类的平均向量作为新的聚类中心，重新分配数据对象。
4. 反复执行第二步和第三步直至满足中止条件。
图示：
(a)选取聚类中心，可以任意选取，也可以通过直方图进行选取。我们选择三个聚类中心，并将数据样本聚到离它最近的中心；
(b)数据中心移动到它所在类别的中心；
©数据点根据最邻近规则重新聚到聚类中心；
(d)再次更新聚类中心；不断重复上述过程直到评价标准不再变化
评价函数
%随机获取150个点
X = [randn(50,2)+ones(50,2);randn(50,2)-ones(50,2);randn(50,2)+[ones(50,1),-ones(50,1)]];
opts = statset('Display','final');
%调用Kmeans函数
%此处p=2
%X N*P的数据矩阵
%Idx N*1的向量,存储的是每个点的聚类标号
%Ctrs K*P的矩阵,存储的是K个聚类质心位置
%SumD 1*K的和向量,存储的是类间所有点与该类质心点距离之和
%D N*K的矩阵，存储的是每个点与所有质心的距离;
[Idx,Ctrs,SumD,D] = kmeans(X,3,'Replicates',3,'Options',opts);
%画出聚类为1的点。X(Idx==1,1),为第一类的样本的第一个坐标；X(Idx==1,2)为第二类的样本的第二个坐标
plot(X(Idx==1,1),X(Idx==1,2),'r.','MarkerSize',14)
hold on
plot(X(Idx==2,1),X(Idx==2,2),'b.','MarkerSize',14)
hold on
plot(X(Idx==3,1),X(Idx==3,2),'g.','MarkerSize',14)
%绘出聚类中心点,kx表示是圆形
plot(Ctrs(:,1),Ctrs(:,2),'kx','MarkerSize',14,'LineWidth',4)
plot(Ctrs(:,1),Ctrs(:,2),'kx','MarkerSize',14,'LineWidth',4)
plot(Ctrs(:,1),Ctrs(:,2),'kx','MarkerSize',14,'LineWidth',4)
legend('Cluster 1','Cluster 2','Cluster 3','Centroids','Location','NW')
Ctrs
SumD
%K-means聚类
clc,clear;
load tyVector;
X=tyVector'; %列向量变成行向量,209*180矩阵
[x,y]=size(X);
opts = statset('Display','final');
K=11; %将X划分为K类
repN=50; %迭代次数
%K-mean聚类
[Idx,Ctrs,SumD,D] = kmeans(X,K,'Replicates',repN,'Options',opts);
%Idx N*1的向量,存储的是每个点的聚类标号
%打印结果
fprintf('划分成%d类的结果如下：\n',K)
for i=1:K
tm=find(Idx==i); %求第i类的对象
tm=reshape(tm,1,length(tm)); %变成行向量
fprintf('第%d类共%d个分别是%s\n',i,length(tm),int2str(tm)); %显示分类结果
end
分类算法
1.KNN算法介绍
KNN 是什么？
KNN(K-Nearest Neighbor)是最简单的机器学习算法之一，可以用于分类和回归，是一种监督学习算法。它的思路是这样，如果一个样本在特征空间中的K个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。也就是说，该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
KNN用于分类
如上图所示，图中的正方形和三角形是打好了label的数据，分别代表不同的标签，那个绿色的圆形是我们待分类的数据。
如果选K=3，那么离绿色点最近K个点中有2个三角形和1个正方形，这3个点投票，三角形的比例占2/3，于是绿色的这个待分类点属于三角形类别。
如果选K=5，那么离绿色点最近K个点中有2个三角形和3个正方形，这5个点投票，蓝色的比例占3/5，于是绿色的这个待分类点属于正方形类别。
从上述例子看到，KNN本质是基于一种数据统计的方法，其实很多机器学习算法也是基于数据统计的。同时， KNN是一种instance-based learning，属于lazy learning， 即它没有明显的前期训练过程，而是程序开始运行时，把数据集加载到内存后，就可以直接开始分类。其中，每次判断一个未知的样本点时，就在该样本点附近找K个最近的点进行投票，这就是KNN中K的意义，通常K是不大于20的奇数。
KNN分类算法的计算过程：
1）计算待分类点与已知类别的点之间的距离
2）按照距离递增次序排序
3）选取与待分类点距离最小的K个点
4）确定前K个点所在类别的出现次数
5）返回前K个点出现次数最高的类别作为待分类点的预测分类
KNN算法要注意什么问题？
参数分为：模型参数和超参数
超参数：就相当于一个开关：告诉模型启用不同的训练方式；
（1）把一个物体表示成向量/矩阵；
（2）标记号每个物体的标签；
（2）计算两个物体之间的距离/相似度；距离度量，特征空间中样本点的距离是样本点间相似程度的反映
（3）选择合适的 K
其中，K值的选择和设置距离度量是最应该注意的几个问题;
数据预处理代码
% %atten：
% 要修改的位置有两个
%1.文件名字数组
filename=["sample1.csv","sample2.csv","sample3.csv","sample4.csv","sample5.csv","sample6.csv","sample7.csv","sample8.csv","sample9.csv","sample10.csv","sample11.csv","sample12.csv","sample13.csv","sample14.csv"];
for i=1:14
train = xlsread(filename(i));
trainData=train(:,1:2);%前两列为指纹的特征
% 行
len=size(train,1);
%归一化处理
maxV=max(trainData);
minV=min(trainData);
range=maxV-minV;
trainData=(trainData-repmat(minV,[len,1]))./(repmat(range,[len,1]));
train(:,1:2)=trainData;%显示归一化的结果
%2.C:\Users\Gary\Desktop\csv\为你要输出的位置
saveplace=['C:\Users\Gary\Desktop\csv\',char(filename(i))];
csvwrite(saveplace,train);
end
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 8 23:00:23 2020
@author: Gary
"""
import numpy as np
import pandas as pd
txt = np.loadtxt('file.txt')
txtDF = pd.DataFrame(txt)
txtDF.to_csv('file.csv',index=False)
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 8 23:11:38 2020
@author: Gary
"""
"""在csv文件中第一行添加索引字段"""
def write_raw_index(file):
filename = file
with open(filename, 'r+', encoding='utf-8') as f:
content = f.read()
f.seek(0, 0)
#mid, text, source, uid
text = 'x' + ',' + 'y'
f.write(text + '\n' + content)
write_raw_index('file.csv')
for k=1:14
test = csvread(['test',num2str(k),'.csv'],1,0);
x=test(:,1);
y=test(:,2);
figure(k)
plot(x,y,'.','Color','b');shading interp
title(['test',num2str(k)])
print('-dpng','-r1080',['test',num2str(k)]);
end
实现：
clear all;
clc;
%%
% 1、计算已知类别数据集合汇总的点与当前点的距离
% 2、按照距离递增次序排序
% 3、选取与当前点距离最近的K个点
% 4、确定距离最近的前K个点所在类别的出现频率
% 5、返回距离最近的前K个点中频率最高的类别作为当前点的预测分类
%
%%
train = xlsread('train.xlsx');
trainData=train(:,1:2);%前两列为指纹的特征
trainClass=train(:,3);%label 类别
% 行
len=size(train,1);
%归一化处理
maxV=max(trainData);
minV=min(trainData);
range=maxV-minV;
trainData=(trainData-repmat(minV,[len,1]))./(repmat(range,[len,1]));
train(:,1:2)=trainData;%显示归一化的结果
xlswrite('normalization.xlsx',train)
%生成测试的数据
testLen=size(train,1)*0.1;%10的测试数据
len=len-testLen;
A=randsample(size(train,1),testLen,false);%选取任意行无重复
test=train(A,:);%生成测试数据集
train(A,:)=[];%抽取测试数据集
trainData=train(:,1:2);%前两列为指纹的特征
trainClass=train(:,3);%label 类别
testData=test(:,1:2);
testClass=zeros(1,testLen);%定义数组待定分类
correct=test(:,3)';%正确的结果
%main
k=13;
row=size(trainData,1);
col=size(trainData,2);
%for
for i=1:testLen
itest=testData(i,:);%找出一个测试集
itestrep=repmat(itest,row,1);%将测试数据复制为一个和训练集大小相同的矩阵，为方便后面的循环计算
dis=zeros(1,row);
%采用欧式距离
for j=1:row
diff=0;
for t=1:col
diff=diff+((itestrep(j,t)-trainData(j,t)).^2);
end
dis(1,j)=diff.^0.5;
end
%对距离进行排序
Class=trainClass';
joinClass=[dis;Class];
sortDis=sortrows(joinClass');
sortDisClass=sortDis';
%统计次数最高的类别
ksort=sortDisClass(2,1:k);
table=tabulate(ksort);
MaxPercent=max(table(:,3));
[r,c]=find(table==MaxPercent);% 找出最大概率所在的位置
MaxValue=table(r,1);
testClass(1,i) = MaxValue;
end
%显示结果
disp("最终结果为：");
for x=1:testLen
fprintf('%d\t',testClass(1,x));
end
fprintf('\n');
for x=1:testLen
fprintf('%d\t',correct(1,x));
end
fprintf('\n');
%计算正确率
count=0;
%错误发生率
cal=zeros(1,3);
for y=1:testLen
if(testClass(1,y)==correct(1,y))
count=count+1;
else
cal(testClass(1,y))=cal(testClass(1,y))+1;
end
end
disp('正确率为：');
fprintf('%.2f%%\n',count/testLen*100);
disp('A,B,C 错误占有率为:');
disp(cal./(testLen-count));
colo=zeros(2,3);
for i=1:len
if(trainClass(i)==1)
colo(1)=1;
colo(2)=i;
elseif(trainClass(i)==2)
colo(3)=colo(2)+1;
colo(4)=i;
else
colo(5)=colo(4)+1;
colo(6)=i;
end
end
plot(trainData(colo(1):colo(2),1),trainData(colo(1):colo(2),2),'o','Color','y');
hold on;
plot(trainData(colo(3):colo(4),1),trainData(colo(3):colo(4),2),'o','Color','b');
plot(trainData(colo(5):colo(6),1),trainData(colo(5):colo(6),2),'o','Color','k');
legend('A','B','C');
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 4 18:25:49 2020
@author: xuwenjin
"""
#K值
#由于算法原因，K值取值不可大于9
K=3
#读取部分
import csv
import random
file1=open('sample1.csv','r',)
reader1=csv.DictReader(file1)
datas1=[row for row in reader1]
file2=open('sample2.csv','r',)
reader2=csv.DictReader(file2)
datas2=[row for row in reader2]
file3=open('sample3.csv','r',)
reader3=csv.DictReader(file3)
datas3=[row for row in reader3]
file4=open('sample4.csv','r',)
reader4=csv.DictReader(file4)
datas4=[row for row in reader4]
count=1
while count<1499:
del datas4[random.randint(0,3749-count)]
count+=1
file5=open('sample5.csv','r',)
reader5=csv.DictReader(file5)
datas5=[row for row in reader5]
count=1
while count<1499:
del datas5[random.randint(0,3749-count)]
count+=1
file6=open('sample6.csv','r',)
reader6=csv.DictReader(file6)
datas6=[row for row in reader6]
count=1
while count<1499:
del datas6[random.randint(0,3749-count)]
count+=1
file7=open('sample7.csv','r',)
reader7=csv.DictReader(file7)
datas7=[row for row in reader7]
file8=open('sample8.csv','r',)
reader8=csv.DictReader(file8)
datas8=[row for row in reader8]
file9=open('sample9.csv','r',)
reader9=csv.DictReader(file9)
datas9=[row for row in reader9]
file10=open('sample10.csv','r',)
reader10=csv.DictReader(file10)
datas10=[row for row in reader10]
file11=open('sample11.csv','r',)
reader11=csv.DictReader(file11)
datas11=[row for row in reader11]
file12=open('sample12.csv','r',)
reader12=csv.DictReader(file12)
datas12=[row for row in reader12]
count=1
while count<1499:
del datas12[random.randint(0,3750-count)]
count+=1
file13=open('sample13.csv','r',)
reader13=csv.DictReader(file13)
datas13=[row for row in reader13]
count=1
while count<1499:
del datas13[random.randint(0,3750-count)]
count+=1
file14=open('sample14.csv','r',)
reader14=csv.DictReader(file14)
datas14=[row for row in reader14]
#欧式距离表达式
def distance(d1,d2):
res=0
for n in range(2250):
for key in ('x','y'):
res+=( eval(d1[n][key])-eval(d2[n][key]))**2
return res**0.5
#判断C类型
def knn(datas):
res=[{'result':'A','distance':distance(datas,datas1)},
{'result':'A','distance':distance(datas,datas2)},
{'result':'A','distance':distance(datas,datas3)},
{'result':'B','distance':distance(datas,datas4)},
{'result':'B','distance':distance(datas,datas5)},
{'result':'B','distance':distance(datas,datas6)},
{'result':'C','distance':distance(datas,datas7)},
{'result':'C','distance':distance(datas,datas8)},
{'result':'C','distance':distance(datas,datas9)}]
#排序
res=sorted(res,key=lambda x:x['distance'])
#取K个
select=res[:K]
#权重
result={'A':0,'B':0,'C':0}
#总距离
total=0
for s in select:
total+=s['distance']
#累计权重
for s1 in select:
result[s1['result']]+=1-s1['distance']/total
totalresult=result['A']+result["B"]+result['C']
#做判断
if max(result.values())==result['C']:
print('A的可能性是{}%，B的可能性是{}%，C的可能性是{}%'.format(result['A']*100/totalresult,result['B']*100/totalresult,result['C']*100/totalresult))
print('该指纹是C类型')
return True
#计算最大值对应的键
def maxkeys(datas):
res=[]
for n in range(2250):
for key in ('y'):
res+=[eval(datas[n][key])]
maxvalues=max(res)
for n1 in range(2250):
if eval(datas[n1]['y'])==maxvalues:
maxkeys=eval(datas[n1]['x'])#最大值对应的键
return maxkeys
#判断AB类型
def peak(datas):
alley1=[datas1,datas2,datas3]
alley2=[datas4,datas5,datas6]
res1=0
res2=0
for n in range(2):
res1+=abs(maxkeys(datas)-maxkeys(alley1[n]))
for n in range(2):
res2+=abs(maxkeys(datas)-maxkeys(alley2[n]))
total=res1+res2
if res1>res2:
print('A的可能性是{}%，B的可能性是{}%'.format(100-(res1*100/total),100-(res2*100/total)))
print('该指纹是B类型')
else:
print('A的可能性是{}%，B的可能性是{}%'.format(100-(res1*100/total),100-(res2*100/total)))
print('该指纹是A类型')
#主函数
def main(datas):
if knn(datas):
pass
else:
peak(datas)
#输出结果
print('Sample10\n')
main(datas10)
print('\n')
print('Sample11\n')
main(datas11)
print('\n')
print('Sample12\n')
main(datas12)
print('\n')
print('Sample13\n')
main(datas13)
print('\n')
print('Sample14\n')
main(datas14)
print('\n')
代码实现：
- 调用KNN函数来实现分类¶
数据采用的是经典的iris数据，是三分类问题
# 读取相应的库
from sklearn import datasets # 使用sklearn 自带的数据集；
from sklearn.model_selection import train_test_split # 把数据分为训练 和 测试数据
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
# 读取数据 X, y
iris = datasets.load_iris() # UCI dataset；3类描述；
X = iris.data #特征：矩阵： N*D N：#OF
y = iris.target #label ：标签（0，1，2），向量；
print (X, y)
-------------------------------------------------------
[[ 5.1 3.5 1.4 0.2]
[ 4.9 3. 1.4 0.2]
[ 4.7 3.2 1.3 0.2]
[ 4.6 3.1 1.5 0.2]
[ 5. 3.6 1.4 0.2]
[ 5.4 3.9 1.7 0.4]
[ 4.6 3.4 1.4 0.3]
[ 5. 3.4 1.5 0.2]
[ 4.4 2.9 1.4 0.2]
[ 4.9 3.1 1.5 0.1]
......
# 把数据分成训练数据和测试数据
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2003)
# 构建KNN模型， K值为3、 并做训练
clf = KNeighborsClassifier(n_neighbors=3) #指定K值
clf.fit(X_train, y_train) #训练
# 计算准确率
from sklearn.metrics import accuracy_score
correct = np.count_nonzero((clf.predict(X_test)==y_test)==True)
#accuracy_score(y_test, clf.predict(X_test))
print ("Accuracy is: %.3f" %(correct/len(X_test)))
------------------------------------
Accuracy is: 0.921
2. 从零开始自己写一个KNN算法
from sklearn import datasets
from collections import Counter # 为了做投票
from sklearn.model_selection import train_test_split
import numpy as np
# 导入iris数据
iris = datasets.load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2003)
def euc_dis(instance1, instance2):
"""
计算两个样本instance1和instance2之间的欧式距离
instance1: 第一个样本， array型
instance2: 第二个样本， array型
"""
# TODO
dist = np.sqrt(sum((instance1 - instance2)**2))
return dist
def knn_classify(X, y, testInstance, k):
"""
给定一个测试数据testInstance, 通过KNN算法来预测它的标签。
X: 训练数据的特征
y: 训练数据的标签
testInstance: 测试数据，这里假定一个测试数据 array型
k: 选择多少个neighbors?
"""
# TODO 返回testInstance的预测标签 = {0,1,2}
distances = [euc_dis(x, testInstance) for x in X]
kneighbors = np.argsort(distances)[:k]
count = Counter(y[kneighbors])
return count.most_common()[0][0]
# 预测结果；
predictions = [knn_classify(X_train, y_train, data, 3) for data in X_test]
correct = np.count_nonzero((predictions==y_test)==True)
#accuracy_score(y_test, clf.predict(X_test))
print ("Accuracy is: %.3f" %(correct/len(X_test)))
-------------------------------------------------------------
Accuracy is: 0.921
3. KNN的决策边界
import matplotlib.pyplot as plt
import numpy as np
from itertools import product
from sklearn.neighbors import KNeighborsClassifier
# 生成一些随机样本
n_points = 100
X1 = np.random.multivariate_normal([1,50], [[1,0],[0,10]], n_points)
X2 = np.random.multivariate_normal([2,50], [[1,0],[0,10]], n_points)
X = np.concatenate([X1,X2])
y = np.array([0]*n_points + [1]*n_points)
print (X.shape, y.shape)
# KNN模型的训练过程
clfs = []
neighbors = [1,3,5,9,11,13,15,17,19]
for i in range(len(neighbors)):
clfs.append(KNeighborsClassifier(n_neighbors=neighbors[i]).fit(X,y))
# 可视化结果
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
np.arange(y_min, y_max, 0.1))
f, axarr = plt.subplots(3,3, sharex='col', sharey='row', figsize=(15, 12))
for idx, clf, tt in zip(product([0, 1, 2], [0, 1, 2]),
clfs,
['KNN (k=%d)'%k for k in neighbors]):
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
axarr[idx[0], idx[1]].contourf(xx, yy, Z, alpha=0.4)
axarr[idx[0], idx[1]].scatter(X[:, 0], X[:, 1], c=y,
s=20, edgecolor='k')
axarr[idx[0], idx[1]].set_title(tt)
plt.show()
Fisher分类
可见课本蠓虫分类的拓展阅读部分
Bayes判别法
课本p342页蠓虫分类 Bayes+马氏距离
% 9.6节：蠓虫程序（加注释）
clc; clear all;
% 原始数据散点图
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96]; %Apf蠓虫数据
Af=[1.24,1.72;;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08]; %Af蠓虫数据
x=[1.24,1.80;1.29,1.81;1.43,2.03]; %待判蠓虫数据
figure(1); %画原始数据散点图1
plot(Apf(:,1),Apf(:,2),'*',Af(:,1),Af(:,2),'or',x(:,1),x(:,2),'p')
xlabel('触角长')
ylabel('翅长')
legend('Apf','Af','x','Location','southeast')
% Box M检验
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96];
Af=[1.24,1.72; ;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08];
n1=size(Apf,1) %Apf蠓虫样本容量
n2=size(Af,1) %Af蠓虫样本容量
p=2
f=p*(p+1)/2 %统计量自由度
s1=cov(Apf) %Apf蠓虫协方差矩阵
s2=cov(Af) %Af蠓虫协方差矩阵
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2) %混合协方差矩阵
c=(2*p^2+3*p-1)/(6*(p+1))*(1/(n1-1)+1/(n2-1)-1/(n1+n2-2))
M=(n1+n2-2)*log(det(s))-(n1-1)*log(det(s1))-(n2-1)*log(det(s2)) %计算检验中的M值
M0=(1-c)*M
p0=1-chi2cdf(M0,f) %卡方分布概率（p值）
%距离判别
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96];
Af=[1.24,1.72; ;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08];
x=[1.24,1.80;1.29,1.81;1.43,2.03]; %输入原始数据
n1=size(Apf,1)
n2=size(Af,1) %样本容量
m1=mean(Apf)
m2=mean(Af) %计算均值向量
s1=cov(Apf)
s2=cov(Af) %计算协方差矩阵
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2) %计算混合样本协方差矩阵
a=(m1-m2)*inv(s) %计算判别函数的系数
wc=-1/2*(m1+m2)*a' %计算判别函数的常数项
for i=1:3
W(i)=(x(i,:)-1/2*(m1+m2))*inv(s)*(m1-m2)'; %计算判别函数值
end
figure(2);
plot(Apf(:,1),Apf(:,2),'*',Af(:,1),Af(:,2),'or',x(:,1),x(:,2),'p')
hold on
ezplot(@(x1,x2)(-58.2364*x1+38.0587*x2+5.8715),[1.1,1.6],[1.5,2.3])
legend('Apf','Af','x','Location','southeast')
hold off %画图2
%回代误判率
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96];
Af=[1.24,1.72; ;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08]; %输入原始数据
n1=size(Apf,1) ;
n2=size(Af,1) ; %样本容量
s1=cov(Apf)
s2=cov(Af) %计算协方差矩阵
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2) %计算混合样本协方差矩阵
for i=1:n1
d1(i)=(Apf(i,:)-mean(Apf))*inv(s)*(Apf(i,:)-mean(Apf))'-(Apf(i,:)-mean(Af))*inv(s)*(Apf(i,:)-mean(Af))';
end %Apf样品到两总体的距离平方差
for i=1:n2
d2(i)=(Af(i,:)-mean(Af))*inv(s)*(Af(i,:)-mean(Af))'-(Af(i,:)-mean(Apf))*inv(s)*(Af(i,:)-mean(Apf))';
end %Af样品到两总体的距离平方差
n12=length(find(d1>0)) %Apf回代误判的样品个数
n21=length(find(d2>0)) %Af回代误判的样品个数
p1=(n12+n21)/(n1+n2) %回代误判率
%交叉验证误判率
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96];
Af=[1.24,1.72; ;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08];
for i=1:n1
Apf1=Apf([1:i-1,i+1:n1],:); %剔除第i个Apf样品并进行判别
n1=length(Apf1(:,1));
n2=length(Af(:,1));
s1=cov(Apf1);
s2=cov(Af);
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2);
D1(i)=(Apf(i,:)-mean(Apf1))*inv(s)*(Apf(i,:)-mean(Apf1))'-(Apf(i,:)-mean(Af))*inv(s)*(Apf(i,:)-mean(Af))';
end
for i=1:n2
Af1=Af([1:i-1,i+1:n2],:);
n1=length(Apf(:,1));
n2=length(Af1(:,1));
s1=cov(Apf1);
s2=cov(Af1);
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2);
D2(i)=(Af(i,:)-mean(Af1))*inv(s)*(Af(i,:)-mean(Af1))'-(Af(i,:)-mean(Apf))*inv(s)*(Af(i,:)-mean(Apf))';
end %剔除第i个Apf样品并进行判别
N1=length(find(D1>0)) %Apf交叉误判的样品个数
N2=length(find(D2>0)) %Af交叉误判的样品个数
p2=(N1+N2)/(n1+n2) %交叉误判率
% 表3结果
Apf=[1.14,1.78;1.18,1.96;1.20,1.86;1.26,2.00;1.28,2.00;1.30,1.96];
Af=[1.24,1.72; ;1.36, 1.74; 1.38,1.64;1.38, 1.90; 1.40, 1.70; 1.48, 1.82;1.38,1.82;1.54,1.82; 1.56, 2.08];
x=[1.24,1.80;1.29,1.81;1.43,2.03]; %输入原始数据
n1=size(Apf,1)
n2=size(Af,1) %样本容量
m1=mean(Apf)
m2=mean(Af) %计算均值向量
s1=cov(Apf)
s2=cov(Af) %计算协方差矩阵
s=((n1-1)*s1+(n2-1)*s2)/(n1+n2-2) %计算混合样本协方差矩阵
a=1.5 %取损失比Alpha=1.5
for i=1:3
Wb(i)=(x(i,:)-1/2*(m1+m2))*inv(s)*(m1-m2)'-log(1.5/a); %计算判别函数值减去阈值
end
SVM（支持向量机）
神经网络
%读取训练数据
[f1,f2,f3,f4,class] = textread('trainData.txt' , '%f%f%f%f%f',150);
%特征值归一化
[input,minI,maxI] = premnmx( [f1 , f2 , f3 , f4 ]') ;
%构造输出矩阵
s = length( class) ;
output = zeros( s , 3 ) ;
for i = 1 : s
output( i , class( i ) ) = 1 ;
end
%创建神经网络
net = newff( minmax(input) , [10 3] , { 'logsig' 'purelin' } , 'traingdx' ) ;
%设置训练参数
net.trainparam.show = 50 ;
net.trainparam.epochs = 500 ;
net.trainparam.goal = 0.01 ;
net.trainParam.lr = 0.01 ;
%开始训练
net = train( net, input , output' ) ;
%读取测试数据
[t1 t2 t3 t4 c] = textread('testData.txt' , '%f%f%f%f%f',150);
%测试数据归一化
testInput = tramnmx ( [t1,t2,t3,t4]' , minI, maxI ) ;
%仿真
Y = sim( net , testInput )
%统计识别正确率
[s1 , s2] = size( Y ) ;
hitNum = 0 ;
for i = 1 : s2
[m , Index] = max( Y( : , i ) ) ;
if( Index == c(i) )
hitNum = hitNum + 1 ;
end
end
sprintf('识别率是 %3.3f%%',100 * hitNum / s2 )
%% I. 清空环境变量
clear all
clc
%% II. 训练集/测试集产生
%%
% 1. 导入数据
load spectra_data.mat
%%
% 2. 随机产生训练集和测试集
temp = randperm(size(NIR,1));
% 训练集——50个样本
P_train = NIR(temp(1:50),:)';
T_train = octane(temp(1:50),:)';
% 测试集——10个样本
P_test = NIR(temp(51:end),:)';
T_test = octane(temp(51:end),:)';
N = size(P_test,2);
%% III. 数据归一化
[p_train, ps_input] = mapminmax(P_train,0,1);
p_test = mapminmax('apply',P_test,ps_input);
[t_train, ps_output] = mapminmax(T_train,0,1);
%% IV. BP神经网络创建、训练及仿真测试
%%
% 1. 创建网络
net = newff(p_train,t_train,9);
%%
% 2. 设置训练参数
net.trainParam.epochs = 1000;
net.trainParam.goal = 1e-3;
net.trainParam.lr = 0.01;
%%
% 3. 训练网络
net = train(net,p_train,t_train);
%%
% 4. 仿真测试
t_sim = sim(net,p_test);
%%
% 5. 数据反归一化
T_sim = mapminmax('reverse',t_sim,ps_output);
%% V. 性能评价
%%
% 1. 相对误差error
error = abs(T_sim - T_test)./T_test;
%%
% 2. 决定系数R^2
R2 = (N * sum(T_sim .* T_test) - sum(T_sim) * sum(T_test))^2 / ((N * sum((T_sim).^2) - (sum(T_sim))^2) * (N * sum((T_test).^2) - (sum(T_test))^2));
%%
% 3. 结果对比
result = [T_test' T_sim' error']
%% VI. 绘图
figure
plot(1:N,T_test,'b:*',1:N,T_sim,'r-o')
legend('真实值','预测值')
xlabel('预测样本')
ylabel('辛烷值')
string = {'测试集辛烷值含量预测结果对比';['R^2=' num2str(R2)]};
title(string)
1059
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
