西北工业大学智能计算课程考试.docx
《西北工业大学智能计算课程考试.docx》由会员分享，可在线阅读，更多相关《西北工业大学智能计算课程考试.docx（41页珍藏版）》请在冰豆网上搜索。
西北工业大学智能计算课程考试
题目1：
使用神经网络对三叶草分类问题进行仿真
答：
1.分类问题描述：
已知三种类型的三叶草：
白三叶，红三叶，杂三叶，将其记为类型1、2、3，现有它们的4种特征数据，要求根据三叶草的特征数据，对其进行分类。
2.数据集描述：
数据集共包含150组数据，挑选其中的75组作为训练数据，其余75组作为测试数据，数据集的每行的前4个数据为三叶草特征数据，最后1个数据为三叶草种类。
（详细数据见，最后部分打印）
3.前馈神经网络设计：
利用MATLAB中newff（），函数创建神经网络，神经网络结构如下：
图1-1神经网络结构图
输入层：
4输入（分别对应4个特征）
隐含层：
10
输出层：
3输出（分别对应该样本属于某一品种的可能性大小），输出节点中可能性最大的节点，对应测试样本的种类；
隐含层激活函数为：
对数S形转移函数
输出层激活函数为：
线性函数f（x）=x
数据处理归一化函数为：
y=（x-min）/（max-min）,其中min,max为x的最小、最大值。
神经网络参数：
目标误差为0.01，最大迭代次数1000次，学习率0.01.
4.仿真结果展示及分析：
（1）由仿真性能图1-2可以看出处，在迭代次数达到200次左右，网络的训练趋于收敛；
（2）训练后的网络对于的识别率稳定在95%以上；10次测试结果如下：
次数
1
2
3
4
5
6
7
8
9
10
识别率
95.03%
95.86%
96.42%
97.21%
96.44%
96.54%
98.01%
97.71%
95.58%
94.32
（3）通过仿真结果可以看出，对于上述线性分类问题，可以训练神经网络得到较好的分类效果。
但是，当遇到非线性或特征数据维度更高的分类问题时，神经网络将会变得非常庞大，网络各层的权值等参数的调试，也会变得复杂。
同时，耗费在网络训练上的时间也会更高，相应的准确率也会降低。
图1-2三叶草分类神经网络，仿真结果展示图
=============================代码实现===============================
%读取训练数据
fid=fopen（'trainData.txt'）;
trainData=textscan（fid,'%f%f%f%f%f'）;
fclose（fid）;
[f1,f2,f3,f4,class]=trainData{:
};
[input,minI,maxI]=premnmx（[f1,f2,f3,f4]'）;%对训练数据进行归一化
len=length（class）;%构造输出矩阵
output=zeros（len,3）;
fori=1:
len
output（i,class（i））=1;
end
%创建神经网络
net=newff（minmax（input）,[103],{'logsig''purelin'},'traingdx'）;
%设置训练参数
net.trainparam.show=50;
net.trainparam.epochs=1000;
net.trainparam.goal=0.01;
net.trainParam.lr=0.01;
%开始训练
net=train（net,input,output'）;
%读取测试数据
fid=fopen（'testData.txt'）;
testData=textscan（fid,'%f%f%f%f%f'）;
fclose（fid）;
[t1,t2,t3,t4,c]=testData{:
};
%测试数据归一化
testInput=tramnmx（[t1,t2,t3,t4]',minI,maxI）;
%进行仿真
Y=sim（net,testInput）;
%统计识别正确率
[s1,s2]=size（Y）;
hitNum=0;
fori=1:
s2
[m,Index]=max（Y（:
i））;
if（Index==c（i））
hitNum=hitNum+1;
end
end
sprintf（'识别率是%3.3f%%',100*hitNum/s2）
=============================训练数据集===============================
5.13.51.40.21
4.931.40.21
4.73.21.30.21
4.63.11.50.21
53.61.40.21
5.43.91.70.41
4.63.41.40.31
53.41.50.21
4.42.91.40.21
4.93.11.50.11
5.43.71.50.21
4.83.41.60.21
4.831.40.11
4.331.10.11
5.841.20.21
5.74.41.50.41
5.43.91.30.41
5.13.51.40.31
5.73.81.70.31
5.13.81.50.31
5.43.41.70.21
5.13.71.50.41
4.63.610.21
5.13.31.70.51
4.83.41.90.21
73.24.71.42
6.43.24.51.52
6.93.14.91.52
5.52.341.32
6.52.84.61.52
5.72.84.51.32
6.33.34.71.62
4.92.43.312
6.62.94.61.32
5.22.73.91.42
523.512
5.934.21.52
62.2412
6.12.94.71.42
5.62.93.61.32
6.73.14.41.42
5.634.51.52
5.82.74.112
6.22.24.51.52
5.62.53.91.12
5.93.24.81.82
6.12.841.32
6.32.54.91.52
6.12.84.71.22
6.42.94.31.32
6.33.362.53
5.82.75.11.93
7.135.92.13
6.32.95.61.83
6.535.82.23
7.636.62.13
4.92.54.51.73
7.32.96.31.83
6.72.55.81.83
7.23.66.12.53
6.53.25.123
6.42.75.31.93
6.835.52.13
5.72.5523
5.82.85.12.43
6.43.25.32.33
6.535.51.83
7.73.86.72.23
7.72.66.92.33
62.251.53
6.93.25.72.33
5.62.84.923
7.72.86.723
6.32.74.91.83
6.73.35.72.13
=============================测试数据集===============================
531.60.21
53.41.60.41
5.23.51.50.21
5.23.41.40.21
4.73.21.60.21
4.83.11.60.21
5.43.41.50.41
5.24.11.50.11
5.54.21.40.21
4.93.11.50.21
53.21.20.21
5.53.51.30.21
4.93.61.40.11
4.431.30.21
5.13.41.50.21
53.51.30.31
4.52.31.30.31
4.43.21.30.21
53.51.60.61
5.13.81.90.41
4.831.40.31
5.13.81.60.21
4.63.21.40.21
5.33.71.50.21
53.31.40.21
6.634.41.42
6.82.84.81.42
6.7351.72
62.94.51.52
5.72.63.512
5.52.43.81.12
5.52.43.712
5.82.73.91.22
62.75.11.62
5.434.51.52
63.44.51.62
6.73.14.71.52
6.32.34.41.32
5.634.11.32
5.52.541.32
5.52.64.41.22
6.134.61.42
5.82.641.22
52.33.312
5.62.74.21.32
5.734.21.22
5.72.94.21.32
6.22.94.31.32
5.12.531.12
5.72.84.11.32
7.23.261.83
6.22.84.81.83
6.134.91.83
6.42.85.62.13
7.235.81.63
7.42.86.11.93
7.93.86.423
6.42.85.62.23
6.32.85.11.53
6.12.65.61.43
7.736.12.33
6.33.45.62.43
6.43.15.51.83
634.81.83
6.93.15.42.13
6.73.15.62.43
6.93.15.12.33
5.82.75.11.93
6.83.25.92.33
6.73.35.72.53
6.735.22.33
6.32.551.93
6.535.223
6.23.45.42.33
5.935.11.83
题目2:
使用遗传算法解决TSP问题
答：
1.TSP问题描述：
TSP（TravelingSalesmanProblem,“旅行商问题”）可简单描述为:
一位销售商从n个城市中的某一城市出发，不重复地走完其余n-1个城市并回到原出发点，在所有可能路径中求出路径长度最短的一条.
2.TSP数据规模：
本问题中共包含51个城市，其x坐标和y坐标分别为：
city_x=[37495220402117315251,...
4231512365227171357,...
624216872730435858,...
3738466162633245595,...
1021530393225254856,...
30];
city_y=[52496426304763623321,...
41322542164123331358,...
42575752386848674827,...
6946103363692235156,...
17106415103932552837,...
40];
3.遗传算法的设计：
遗传算法的流程图如下，具体各部分的实现见下部分详细说明。
图2-1遗传算法流程图
a种群个体的编码。
本遗传算法实现中，种群中的个体采用实数编码。
每个个体为51个城市编号的排列，表示一条贯通全部城市的路径环。
b种群的初始化。
初始种群的规模M=50，染色体基因个数N=51，迭代次数C=2000次，遗传交叉概率pc=0.9,变异概率pmutation=0.1。
c适应度函数。
在本问题中，使用环游路径的总距离的倒数作为适应度函数。
在TSP问题中，任意两个城市之间的距离D（i,j）已知，每个染色体（即n个城市的随机排列）可计算出总距离，因此可将一个随机全排列的总距离的倒数作为适应度函数，即距离越短，个体的适应度值越高，则表示该路径越优良。
d遗传选择的实现。
通过设定适应度选择比例，个体的适应度越高则被选择的概率越大，同时在选择中保存适应度最高的个体。
e遗传交叉的实现。
本程序中对于个体，随机选择两个个体，在对应位置交换若干个基因片段，同时保证每个个体依然是1-n的随机排列，防止进入局部收敛。
交叉的操作图如下，（以8城市的TSP为例），如随机选取得到的两个父代个体为：
（12345678）和（24687531），随机选择两个交叉的点，假如第一个点为位置3，第二个交叉点为位置5，那么在两个点之间的位置将进行交叉。
然后从第二个交叉点开始，将原来相应的父代按照顺序进行填充，如果选择的元素已经存在在该子代中，跳过该元素，选择下一个元素，这种过程反复进行，知道所有的城市都被选择一次。
在此实例中，第一个父代个体中345被选中，第二个父代个体中，687被选中。
匹配过程和如下图所示。
图2-2遗传交叉操作示意图
f遗传变异的实现。
本实现中对于变异操作，从父代中随机选取个体，同时随机选取个体的两个基因进行交换以实现变异操作。
如下图所示,以8城市TSP为例:
图2-3遗传变异操作示意图
4.结果展示及分析：
本TSP程序的结果图如下图2-4所示。
图2-4TSP最佳路线图
最佳路线如下：
35->5->32->40->19->42->44->49->12->37->17->51->47->4->10->34->2->20->36->28->8->22->23->6->21->38->29->11->7->43->24->14->13->41->18->25->3->27->48->1->26->31->46->30->33->45->15->39->9->50->16
最短距离：
921.32（数据集给出的最优解为426）
根据如下遗传算法迭代过程中TSP路线距离曲线图，可以看出，迭代达到近200次时候，程序趋于收敛，并在迭代至1700次时，TSP路线距离达到最小值。
图2-5遗传算法迭代过程中TSP路线距离曲线图
同网上他人给出的最优解426相比，显然遗传算法的实现陷入了局部最优解，且无法跳出。
通常陷入局部最优，这是由于实现中遗传交叉和遗传突变算法不合理造成的。
解决遗传算法陷入局部最优解，可采用的方法有：
（1）增加变异率和交叉率；
（2）采用多种变异和交叉方法，当一种算法跳入局部最优时候，可以借助其他变异和交叉方法，跳出局部最优。
可以在后续的学习中，通过这些方法改进本实现。
=============================实现代码===============================
%%=================主程序=================
clear;
clc;
%输入参数
N=51;%城市的个数
M=50;%种群的个数
C=2000;%迭代次数
m=2;
Pc=0.9;
Pmutation=0.1;
%%51个城市的坐标（x，y）
city_x=[37495220402117315251,...
4231512365227171357,...
624216872730435858,...
3738466162633245595,...
1021530393225254856,...
30];
city_y=[52496426304763623321,...
41322542164123331358,...
42575752386848674827,...
6946103363692235156,...
17106415103932552837,...
40];
pos=[city_x;city_y]';
min_data=min（pos）;
max_data=max（pos）;
%%生成城市之间距离矩阵
D=zeros（N,N）;
fori=1:
N
forj=i+1:
N
dis=（pos（i,1）-pos（j,1））.^2+（pos（i,2）-pos（j,2））.^2;
D（i,j）=dis^（0.5）;
D（j,i）=D（i,j）;
end
end
%%生成初始群体
popm=zeros（M,N）;
fori=1:
M
popm（i,:
）=randperm（N）;
end
%%随机选择一个种群
R=popm（1,:
）;
%画出种群各城市的位置
figure
（1）;
scatter（pos（:
1）,pos（:
2）,'rx'）;
axis（[min_data
（1）max_data
（1）min_data
（2）max_data
（2）]）;
%%初始化种群及其适应函数
%fitness=zeros（M,1）;
len=zeros（M,1）;
fori=1:
M
len（i,1）=myLength（D,popm（i,:
））;
end
maxlen=max（len）;
minlen=min（len）;
fitness=fit（len,m,maxlen,minlen）;
rr=find（len==minlen）;
R=popm（rr（1,1）,:
）;
fori=1:
N
fprintf（'%d',R（i））;
end
fprintf（'\n'）;
fitness=fitness/sum（fitness）;
distance_min=zeros（C+1,1）;%%各次迭代的最小的种群的距离
whileC>=0
fprintf（'迭代第%d次\n',C）;
%%选择操作
nn=0;
fori=1:
size（popm,1）
len_1（i,1）=myLength（D,popm（i,:
））;
jc=rand*0.3;
forj=1:
size（popm,1）
iffitness（j,1）>=jc
nn=nn+1;
popm_sel（nn,:
）=popm（j,:
）;
break;
end
end
end
%%每次选择都保存最优的种群
popm_sel=popm_sel（1:
nn,:
）;
[len_mlen_index]=min（len_1）;
popm_sel=[popm_sel;popm（len_index,:
）];
%%交叉操作
nnper=randperm（nn）;
A=popm_sel（nnper
（1）,:
）;
B=popm_sel（nnper
（2）,:
）;
fori=1:
nn*Pc
[A,B]=cross（A,B）;
popm_sel（nnper
（1）,:
）=A;
popm_sel（nnper
（2）,:
）=B;
end
%%变异操作
fori=1:
nn
pick=rand;
whilepick==0
pick=rand;
end
ifpick<=Pmutation
popm_sel（i,:
）=mutation（popm_sel（i,:
））;
end
end
%%求适应度函数
NN=size（popm_sel,1）;
len=zeros（NN,1）;
fori=1:
NN
len（i,1）=myLength（D,popm_sel（i,:
））;
end
maxlen=max（len）;
minlen=min（len）;
distance_min（C+1,1）=minlen;
fitness=fit（len,m,maxlen,minlen）;
rr=find（len==minlen）;
fprintf（'minlen=%d\n',minlen）;
R=popm_sel（rr（1,1）,:
）;
fori=1:
N
fprintf（'%d',R（i））;
end
fprintf（'\n'）;
popm=popm_sel;
C=C-1;
end
figure
（2）
plot_route（pos,R）;
axis（[min_data
（1）max_data
（1）min_data
（2）max_data
（2）]）;
%%=================个体距离计算函数=================
functionlen=myLength（D,p）
[N,~]=size（D）;
len=D（p（1,N）,p（1,1））;
fori=1:
（N-1）
len=len+D（p（1,i）,p（1,i+1））;
end
end
%%=================个体适应度计算函数=================
functionfitness=fit（len,m,maxlen,minlen）
fitness=len;
fori=1:
length（len）
fitness（i,1）=（1-（len（i,1）-minlen）/（maxlen-minlen+0.0001））.^m;
end
%%=================遗传交叉操作函数=================
function[A,B]=cross（A,B）
L=length（A）;
ifL<10
W=L;
elseif（（L/10）-floor（L/10））>=rand&&L>10
W=ceil（L/10）+8;
else
W=floor（L/10）+8;
end
p=unidrnd（L-W+1）;
fprintf（'p=%d',p）;
fori=1:
W
x=find（A==B（1,p+i-1））;
y=find（B==A（1,p+i-1））;
[A（1,p+i-1）,B（1,p+i-1）]=exchange（A（1,p+i-1）,B（1
升级会员 