自组织网络对样本数据进行分类
本例中待分类的样本数据是 100 个分布在 1/4 圆弧上的矢量点。样本数据 P 采用如下方式产生：
angles = 0: 0.5*pi/99: 0.5*pi;
P = [ cos(angles); sin(angles) ];
图1中绘出了样本数据的分布图。
利用 newsom 函数建立自组织网络：
net = newsom ([0 1; 0 1], [9]);
该网络的竞争层共有 9 个神经元，即数据的类别个数。自组织网络在训练时不需要目标输出，网络通过对数据分布特性的学习，自动地将数据划分为指定的类别数。下面是完整的 MATLAB 程序：
close all
clf reset
figure (gcf);
echo on
clc
% NEWSOM——创建自组织网络
% TRAIN——对自组织网络进行训练
% SIM——对自组织网络进行仿真
pause
clc
% 产生样本数据 P
angles = 0: 0.5*pi/99: 0.5*pi;
P = [ cos(angles); sin(angles) ];
pause
clc
% 画第一幅图：样本数据分布图
plot (P(1, :), P(2, :), '*');
axis ([0 1 0 1]);
title ('Input data');
pause
clc
% 建立自组织网络
% 欲将样本数据分为 9 类，因此网络的竞争层由 9 个神经元构成
net = newsom([0 1; 0 1],[9]);
pause
clc
% 对网络进行训练
net.trainParam.epochs = 10;
net = train (net, P);
pause
clc
% 画第二幅图：画出网络神经元权值，也就是每类样本数据的聚类中心
figure;
w = net.IW{1};
plotsom (net.IW{1,1},net.layers{1}.distances);
pause
clc
% 利用一组新的输入数据检验网络性能
a = sim (net, [0.6; 0.8])
echo off
自组织神经网络进行分类的设计
自组织竞争网络对给定的输入向量能够进行分类。如果只需要对输入向量进行分类，那么自组织竞争神经网络就能够很好地完成任务。为了将输入空间进行分类，这就需要更多神经元，特别是当输入向量的密度增大时，。
%产生指定类别的样本点，并在图中绘出
X = [0 1; 0 1]; % 限制类中心的范围
clusters = 5; % 指定类别数目
points = 10; % 指定每一类的点的数目
std_dev = 0.05; % 每一类的标准差
P = nngenc(X,clusters,points,std_dev);
plot(P(1,:),P(2,:),'+r');
title('输入样本向量');
xlabel('p(1)');
ylabel('p(2)');
%建立网络
net=newc([0 1;0 1],5,0.1); %因要区分的类别书目为5，故设置神经元数目为5，学习速率为0.1
%得到网络权值，并在图上绘出
figure;
plot(P(1,:),P(2,:),'+r');
w=net.iw{1}
hold on;
plot(w(:,1),w(:,2),'ob');
hold off;
title('输入样本向量及初始权值');
xlabel('p(1)');
ylabel('p(2)');
figure;
plot(P(1,:),P(2,:),'+r');
hold on;
%训练网络，最大训练步数为7
net.trainParam.epochs=7;
net=init(net);
net=train(net,P);
%得到训练后的网络权值，并在图上绘出
w=net.iw{1}
plot(w(:,1),w(:,2),'ob');
hold off;
title('输入样本向量及更新后的权值');
xlabel('p(1)');
ylabel('p(2)');
%使用sim函数来对其进行分类，并得出结果，这个结果指出了哪个神经元发生了响应，也就反映了这个输入属于哪个类别
a=0;
p = [0.6 ;0.8];
a=sim(net,p)
 二维自组织特征映射网络进行分类设计
自组织特征映射网络根据输入向量在输入空间的分布情况对他们进行分类。与自组织竞争网络不同的是，在自组织神经网络中邻近的神经元能够识别输入空间中邻近的部分。这样，自组织特征映射神经网络不但能够学习输入的分布情况（这点和自组织竞争网络一样），而且可以学习进行训练的输入向量的拓扑结构。
%随机生成1000个二维向量，作为样本，并绘出其分布
P = rands(2,1000);
plot(P(1,:),P(2,:),'+r')
title('初始随机样本点分布');
xlabel('P(1)');
ylabel('P(2)');
%建立网络，二维影射网络的神经元组织结构为5*6,我们希望每一个神经元对应矩形中某一个区域产生响应，邻近的神经元对应相邻的区域。
%每一个神经元用一个点表示，其坐标值为相应的权值，初始状态下这些神经元都拥有相同的权值
net=newsom([0 1; 0 1],[5 6]);
w1_init=net.iw{1,1}
%绘出初始权值分布图
figure;
plotsom(w1_init,net.layers{1}.distances)
%分别对不同的步长，训练网络，绘出相应的权值分布图
for i=10:30:100
net.trainParam.epochs=i;
net=train(net,P);
figure;
plotsom(net.iw{1,1},net.layers{1}.distances)
end
%对于训练好的网络，选择特定的输入向量，得到网络的输出结果
p=[0.5;0.3];
a=0;
a = sim(net,p)
可以看出，训练10步后，神经元就已经自组织的分布了，每个神经元开始能够区分输入空间的不同区域了。睡者训练步数的增加，神经元的权值分布更合理，但是当步数达到一定数目以后，这种改变旧非常不明显了。
%产生指定类别的样本点，并在图中绘出
X = [0 1; 0 1]; % 限制类中心的范围
clusters = 5; % 指定类别数目
points = 10; % 指定每一类的点的数目
std_dev = 0.05; % 每一类的标准差
P = nngenc(X,clusters,points,std_dev);
plot(P(1,:),P(2,:),'+r');
title('输入样本向量');
xlabel('p(1)');
ylabel('p(2)');
%建立网络
net=newc([0 1;0 1],5,0.1); %设置神经元数目为5
%得到网络权值，并在图上绘出
figure;
plot(P(1,:),P(2,:),'+r');
w=net.iw{1}
hold on;
plot(w(:,1),w(:,2),'ob');
hold off;
title('输入样本向量及初始权值');
xlabel('p(1)');
ylabel('p(2)');
figure;
plot(P(1,:),P(2,:),'+r');
hold on;
%训练网络
net.trainParam.epochs=7;
net=init(net);
net=train(net,P);
%得到训练后的网络权值，并在图上绘出
w=net.iw{1}
plot(w(:,1),w(:,2),'ob');
hold off;
title('输入样本向量及更新后的权值');
xlabel('p(1)');
ylabel('p(2)');
a=0;
p = [0.6 ;0.8];
a=sim(net,p)
－－－－－－－－－－－－－－－－－－－
example8_2
%随机生成1000个二维向量，作为样本，并绘出其分布
P = rands(2,1000);
plot(P(1,:),P(2,:),'+r')
title('初始随机样本点分布');
xlabel('P(1)');
ylabel('P(2)');
%建立网络，得到初始权值
net=newsom([0 1; 0 1],[5 6]);
w1_init=net.iw{1,1}
%绘出初始权值分布图
figure;
plotsom(w1_init,net.layers{1}.distances)
%分别对不同的步长，训练网络，绘出相应的权值分布图
for i=10:30:100
net.trainParam.epochs=i;
net=train(net,P);
figure;
plotsom(net.iw{1,1},net.layers{1}.distances)
end
%对于训练好的网络，选择特定的输入向量，得到网络的输出结果
p=[0.5;0.3];
a=0;
a = sim(net,p)
－－－－－－－－－－－－－－－－－－－－－－－－－－
example8_3
%指定输入二维向量及其类别
P = [-3 -2 -2 0 0 0 0 +2 +2 +3;
0 +1 -1 +2 +1 -1 -2 +1 -1 0];
C = [1 1 1 2 2 2 2 1 1 1];
%将这些类别转换成学习向量量化网络使用的目标向量
T = ind2vec(C)
%用不同的颜色，绘出这些输入向量
plotvec(P,C),
title('输入二维向量');
xlabel('P(1)');
ylabel('P(2)');
%建立网络
net = newlvq(minmax(P),4,[.6 .4],0.1);
%在同一幅图上绘出输入向量及初始权重向量
figure;
plotvec(P,C)
hold on
W1=net.iw{1};
plot(W1(1,1),W1(1,2),'ow')
title('输入以及权重向量');
xlabel('P(1), W(1)');
ylabel('P(2), W(2)');
hold off;
%训练网络，并再次绘出权重向量
figure;
plotvec(P,C);
hold on;
net.trainParam.epochs=150;
net.trainParam.show=Inf;
net=train(net,P,T);
plotvec(net.iw{1}',vec2ind(net.lw{2}),'o');
%对于一个特定的点，得到网络的输出
p = [0.8; 0.3];
a = vec2ind(sim(net,p))
车间大小(5m*5m),放置5台设备,工件在各设备间的传输次数表如下
m1 m2 m3 m4 m5
m1 0 572 1559 157 0
m2 15 0 26 0 2
m3 6 54 0 64 36
m4 0 14 37 0 38
m5 7 4 0 22 0
设备的尺寸表如下
m1 m2 m3 m4 m5
3*3 1*0.8 1.5*0.8 1.5*0.8 0.8*0.7
dxij=0.8 dyij=0.5
分析
车间设备布局最优设计应使得各设备间的运输距离最短,即
另外,各设备在车间中均需占有一定面积,设备间还需要为操作人员留有一定的活动空间,因此在车间设备布局设计中还需要考虑一些约束条件.
间距约束:设备间应保持一定的间距,即
边界约束:设备在X,Y方向的布置不应超过车间的长度尺寸,即
分别表示车间在X,Y方向上的宽度
h,g
遗传算法参数设置:选择实数编码,种群中的个体数目为10,最大代数为100,交叉概率为0.9,变异概率为0.04
适应值函数如下
function [sol,eval]=f554(sol,options)
x(1:5)=sol(1:5);
y(1:5)=sol(6:10);
%传输次数矩阵
a=[0 572 1559 157 0;
15 0 26 0 2;
6 54 0 64 36;
0 14 37 0 38;
7 4 0 22 0];
%x方向尺寸向量
S=[3 1 1.5 1.5 0.8];
%y方向尺寸向量
L=[3 0.8 0.8 0.8 0.7];
%设备x,y在x方向上的最小间距
dxijmin=0.8;
%设备x,y在y方向上的最小间距
dyijmin=0.5;
%车间尺寸
H=5;
G=5;
for i=1:5
for j=1:5
delta1(i,j)=abs(x(i)-x(j))-(S(i)+S(j))/2-dxijmin;
delta2(i,j)=abs(y(i)-y(j))-(L(i)+L(j))/2-dyijmin;
%设备i，j之间的距离
d(i,j)=sqrt((x(i)-x(j)).^2+(y(i)-y(j)).^2);
end
end
%约束1
delta11=min(min(delta1));
%约束2
delta22=min(min(delta2));
summ1=0;
for i=1:4
summ1=summ1+abs(abs(x(i)-x(i+1))+(S(i)+S(i+1))/2);
end
%约束3
summ11=H-summ1;
summ2=0;
for i=1:4
summ2=summ2+abs(abs(y(i)-y(i+1))+(L(i)+L(i+1))/2);
end
%约束4
summ22=G-summ2;
if ((delta11>=0)&(delta22>=0)&(summ11>=0)&(summ22>=0))
fsum=0;
for i=1:5
for j=1:5
fsum=fsum+a(i,j)*d(i,j);
end
end
eval=fsum;
else
%惩罚项
eval=-500;
end
eval=-eval;
求解过程如下
%维数n=5
%车间尺寸
H=5;
G=5;
%x方向尺寸向量
S=[3 1 1.5 1.5 0.8];
smin=min(S)/2;
%y方向尺寸向量
L=[3 0.8 0.8 0.8 0.7];
lmin=min(L)/2;
%设备x,y在x方向上的最小间距
dxijmin=0.8;
%设备x,y在y方向上的最小间距
dyijmin=0.5;
%设置参数边界
bounds =[smin H;smin H;smin H;smin H;smin H;
lmin G;lmin G;lmin G;lmin G;lmin G];
% 生成初始种群，大小为10，且满足约束条件
flag=0;
while flag<11
init=initializega(1,bounds,'f554');
x(1:5)=init(1:5);
y(1:5)=init(6:10);
for i=1:5
for j=1:5
delta1(i,j)=abs(x(i)-x(j))-(S(i)+S(j))/2-dxijmin;
delta2(i,j)=abs(y(i)-y(j))-(L(i)+L(j))/2-dyijmin;
end
end
%约束1
delta11=min(min(delta1));
%约束2
delta22=min(min(delta2));
summ1=0;
for i=1:4
summ1=summ1+abs(x(i)-x(i+1))+(S(i)+S(i+1))/2;
end
%约束3
summ11=H-summ1;
summ2=0;
for i=1:4
summ2=summ2+abs(y(i)-y(i+1))+(L(i)+L(i+1))/2;
end
%约束4
summ22=G-summ2;
if ((delta11>=0)&(delta22>=0)&(summ11>=0)&(summ22>=0))
flag=flag+1;
initPop(flag,:)=init;
else
continue;
end
end
% 调用遗传函数
[p endPop bpop trace] = ga(bounds,'f554',[],initPop,[1e-5 1 1],'maxGenTerm',100,...
'normGeomSelect',[0.08],['arithXover'], [20], 'nonUnifMutation',[2 1 3]);
已知n个城市之间的相互距离，现有一个推销员必须遍访这n个城市，并且每个城市只能访问一次，最后又必须返回出发城市。如何安排他对这些城市的访问次序，可使其旅行路线的总长度最短？ 用图论的术语来说，假设有一个图g=(v,e)，其中v是顶点集，e是边集，设d=(dij)是由顶点i和顶点j之间的距离所组成的距离矩阵，旅行商问题就是求出一条通过所有顶点且每个顶点只通过一次的具有最短距离的回路。 这个问题可分为对称旅行商问题(dij=dji,,任意i,j=1,2,3，…,n)和非对称旅行商问题(dij≠dji,,任意i,j=1,2,3，…,n)。 若对于城市v={v1,v2,v3,…,vn}的一个访问顺序为t=(t1,t2,t3,…,ti,…,tn),其中ti∈v(i=1,2,3,…,n)，且记tn+1= t1，则旅行商问题的数学模型为： min l=σd(t(i),t(i+1)) （i=1,…,n） 旅行商问题是一个典型的组合优化问题，并且是一个np难问题，其可能的路径数目与城市数目n是成指数型增长的，所以一般很难精确地求出其最优解，本文采用遗传算法求其近似解。 遗传算法： 初始化过程：用v1,v2,v3,…,vn代表所选n个城市。定义整数pop-size作为染色体的个数，并且随机产生pop-size个初始染色体，每个染色体为1到18的整数组成的随机序列。 适应度f的计算：对种群中的每个染色体vi，计算其适应度，f=σd(t(i),t(i+1)). 评价函数eval(vi)：用来对种群中的每个染色体vi设定一个概率，以使该染色体被选中的可能性与其种群中其它染色体的适应性成比例，既通过轮盘赌，适应性强的染色体被选择产生后台的机会要大，设alpha∈(0,1)，本文定义基于序的评价函数为eval(vi)=alpha*(1-alpha).^(i-1) 。[随机规划与模糊规划] 选择过程：选择过程是以旋转赌轮pop-size次为基础，每次旋转都为新的种群选择一个染色体。赌轮是按每个染色体的适应度进行选择染色体的。 step1 、对每个染色体vi,计算累计概率qi，q0=0;qi=σeval(vj) j=1,…,i;i=1,…pop-size. step2、从区间(0,pop-size)中产生一个随机数r； step3、若qi-1<r<qi,则选择第i个染色体 ； step4、重复step2和step3共pop-size次，这样可以得到pop-size个复制的染色体。 grefenstette编码：由于常规的交叉运算和变异运算会使种群中产生一些无实际意义的染色体，本文采用grefenstette编码《 遗传算法原理及应用》可以避免这种情况的出现。所谓的grefenstette编码就是用所选队员在未选（不含淘汰）队员中的位置，如： 8 15 2 16 10 7 4 3 11 14 6 12 9 5 18 13 17 1 对应： 8 14 2 13 8 6 3 2 5 7 3 4 3 2 4 2 2 1。 交叉过程：本文采用常规单点交叉。为确定交叉操作的父代，从 到pop-size重复以下过程：从[0，1]中产生一个随机数r，如果r<pc ，则选择vi作为一个父代。 将所选的父代两两组队，随机产生一个位置进行交叉，如： 8 14 2 13 8 6 3 2 5 7 3 4 3 2 4 2 2 1 6 12 3 5 6 8 5 6 3 1 8 5 6 3 3 2 1 1 交叉后为： 8 14 2 13 8 6 3 2 5 1 8 5 6 3 3 2 1 1 6 12 3 5 6 8 5 6 3 7 3 4 3 2 4 2 2 1 变异过程：本文采用均匀多点变异。类似交叉操作中选择父代的过程，在r<pm 的标准下选择多个染色体vi作为父代。对每一个选择的父代，随机选择多个位置，使其在每位置按均匀变异（该变异点xk的取值范围为[ukmin,ukmax],产生一个[0，1]中随机数r，该点变异为x'k=ukmin+r(ukmax-ukmin)）操作。如： 8 14 2 13 8 6 3 2 5 7 3 4 3 2 4 2 2 1 变异后： 8 14 2 13 10 6 3 2 2 7 3 4 5 2 4 1 2 1 反grefenstette编码：交叉和变异都是在grefenstette编码之后进行的，为了循环操作和返回最终结果，必须逆grefenstette编码过程，将编码恢复到自然编码。 循环操作：判断是否满足设定的带数xzome，否，则跳入适应度f的计算；是，结束遗传操作，跳出。
function [bestpop,trace]=ga(d,termops,num,pc,cxops,pm,alpha)
%
%————————————————————————
%[bestpop,trace]=ga(d,termops,num,pc,cxops,pm,alpha)
%d:距离矩阵
%termops:种群带数
%num:每带染色体的个数
%pc:交叉概率
%cxops:由于本程序采用单点交叉，交叉点的设置在本程序中没有很好的解决，所以本文了采用定点，即第cxops，可以随机产生。
%pm:变异概率
%alpha:评价函数eval(vi)=alpha*(1-alpha).^(i-1).
%bestpop:返回的最优种群
%trace:进化轨迹
%------------------------------------------------
%####@@@##版权所有！欢迎广大网友改正，改进！##@@@####
%e-mail:tobysidney33@sohu.com
%####################################################
%
citynum=size(d,2);
n=nargin;
if n<2
disp('缺少变量！！')
disp('^_^开个玩笑^_^')
end
if n<2
termops=500;
num=50;
pc=0.25;
cxops=3;
pm=0.30;
alpha=0.10;
end
if n<3
num=50;
pc=0.25;
cxops=3;
pm=0.30;
alpha=0.10;
end
if n<4
pc=0.25;
cxops=3;
pm=0.30;
alpha=0.10;
end
if n<5
cxops=3;
pm=0.30;
alpha=0.10;
end
if n<6
pm=0.30;
alpha=0.10;
end
if n<7
alpha=0.10;
end
if isempty(cxops)
cxops=3;
end
[t]=initializega(num,citynum);
for i=1:termops
[l]=f(d,t);
[x,y]=find(l==max(l));
trace(i)=-l(y(1));
bestpop=t(y(1),:);
[t]=select(t,l,alpha);
[g]=grefenstette(t);
[g1]=crossover(g,pc,cxops);
[g]=mutation(g1,pm); %均匀变异
[t]=congrefenstette(g);
end
---------------------------------------------------------
function [t]=initializega(num,citynum)
for i=1:num
t(i,:)=randperm(citynum);
end
-----------------------------------------------------------
function [l]=f(d,t)
[m,n]=size(t);
for k=1:m
for i=1:n-1
l(k,i)=d(t(k,i),t(k,i+1));
end
l(k,n)=d(t(k,n),t(k,1));
l(k)=-sum(l(k,:));
end
-----------------------------------------------------------
function [t]=select(t,l,alpha)
[m,n]=size(l);
t1=t;
[beforesort,aftersort1]=sort(l,2);%fsort from l to u
for i=1:n
aftersort(i)=aftersort1(n+1-i); %change
end
for k=1:n;
t(k,:)=t1(aftersort(k),:);
l1(k)=l(aftersort(k));
end
t1=t;
l=l1;
for i=1:size(aftersort,2)
evalv(i)=alpha*(1-alpha).^(i-1);
end
m=size(t,1);
q=cumsum(evalv);
qmax=max(q);
for k=1:m
r=qmax*rand(1);
for j=1:m
if j==1&r<=q(1)
t(k,:)=t1(1,:);
elseif j~=1&r>q(j-1)&r<=q(j)
t(k,:)=t1(j,:);
end
end
end
--------------------------------------------------
function [g]=grefenstette(t)
[m,n]=size(t);
for k=1:m
t0=1:n;
for i=1:n
for j=1:length(t0)
if t(k,i)==t0(j)
g(k,i)=j;
t0(j)=[];
break
end
end
end
end
-------------------------------------------
function [g]=crossover(g,pc,cxops)
[m,n]=size(g);
ran=rand(1,m);
r=cxops;
[x,ru]=find(ran<pc);
if ru>=2
for k=1:2:length(ru)-1
g1(ru(k),:)=[g(ru(k),[1:r]),g(ru(k+1),[(r+1):n])];
g(ru(k+1),:)=[g(ru(k+1),[1:r]),g(ru(k),[(r+1):n])];
g(ru(k),:)=g1(ru(k),:);
end
end
--------------------------------------------
function [g]=mutation(g,pm) %均匀变异
[m,n]=size(g);
ran=rand(1,m);
r=rand(1,3); %dai gai jin
rr=floor(n*rand(1,3)+1);
[x,mu]=find(ran<pm);
for k=1:length(mu)
for i=1:length(r)
umax(i)=n+1-rr(i);
umin(i)=1;
g(mu(k),rr(i))=umin(i)+floor((umax(i)-umin(i))*r(i));
end
end
---------------------------------------------------
function [t]=congrefenstette(g)
[m,n]=size(g);
for k=1:m
t0=1:n;
for i=1:n
t(k,i)=t0(g(k,i));
t0(g(k,i))=[];
end
end
-------------------------------------------------
编码：GA在进行搜索之前先将解空间的解数据表示成遗传空间的基因型串结构数据，这些串结构数据的不同组合便构成了不同的点。
初始群体的生成：随机产生N个初始串结构数据，每个串结构数据称为一个个体， N个个体构成了一个群体。GA以这N个串结构数据作为初始点开始迭代。
适应性值评估检测：适应性函数表明个体或解的优劣性。不同的问题，适应性函数的定义方式也不同。
选择：选择的目的是为了从当前群体中选出优良的个体，使它们有机会作为父代为下一代繁殖子孙。遗传算法通过选择过程体现这一思想，进行选择的原则是适应性强的个体为下一代贡献一个或多个后代的概率大。选择实现了达尔文的适者生存原则。
交换：交换操作是遗传算法中最主要的遗传操作。通过交换操作可以得到新一代个体，新个体组合了其父辈个体的特性。交换体现了信息交换的思想。
变异：变异首先在群体中随机选择一个个体，对于选中的个体以一定的概率随机地改变串结构数据中某个串的值。同生物界一样，GA中变异发生的概率很低，通常取值在0.001~0.01之间。变异为新个体的产生提供了机会。
GA的计算过程为：
选择编码方式
产生初始群体
计算初始群体的适应性值
如果不满足条件 {
选择
交换
变异
计算新一代群体的适应性值
}
核心函数：
(1)function [pop]=initializega(num,bounds,eevalFN,eevalOps,options)--初始种群的生成函数
【输出参数】
pop--生成的初始种群
【输入参数】
num--种群中的个体数目
bounds--代表变量的上下界的矩阵
eevalFN--适应度函数
eevalOps--传递给适应度函数的参数
options--选择编码形式(浮点编码或是二进制编码)[precision F_or_B],如
precision--变量进行二进制编码时指定的精度
F_or_B--为1时选择浮点编码，否则为二进制编码,由precision指定精度)
(2)function [x,endPop,bPop,traceInfo] = ga(bounds,evalFN,evalOps,startPop,opts,...
termFN,termOps,selectFN,selectOps,xOverFNs,xOverOps,mutFNs,mutOps)--遗传算法函数
【输出参数】
x--求得的最优解
endPop--最终得到的种群
bPop--最优种群的一个搜索轨迹
【输入参数】
bounds--代表变量上下界的矩阵
evalFN--适应度函数
evalOps--传递给适应度函数的参数
startPop-初始种群
opts[epsilon prob_ops display]--opts(1:2)等同于initializega的options参数，第三个参数控制是否输出，
一般为0。如[1e-6 1 0]
termFN--终止函数的名称,如['maxGenTerm']
termOps--传递个终止函数的参数,如[100]
selectFN--选择函数的名称,如['normGeomSelect']
selectOps--传递个选择函数的参数,如[0.08]
xOverFNs--交叉函数名称表，以空格分开，如['arithXover heuristicXover simpleXover']
xOverOps--传递给交叉函数的参数表，如[2 0;2 3;2 0]
mutFNs--变异函数表，如['boundaryMutation multiNonUnifMutation nonUnifMutation unifMutation']
mutOps--传递给交叉函数的参数表,如[4 0 0;6 100 3;4 100 3;4 0 0]
注意】matlab工具箱函数必须放在工作目录下
【问题】求f(x)=x+10*sin(5x)+7*cos(4x)的最大值，其中0<=x<=9
【分析】选择二进制编码，种群中的个体数目为10，二进制编码长度为20，交叉概率为0.95,变异概率为0.08
【程序清单】
%编写目标函数
function[sol,eval]=fitness(sol,options)
x=sol(1);
eval=x+10*sin(5*x)+7*cos(4*x);
%把上述函数存储为fitness.m文件并放在工作目录下
initPop=initializega(10,[0 9],'fitness');%生成初始种群，大小为10
[x endPop,bPop,trace]=ga([0 9],'fitness',[],initPop,[1e-6 1 1],'maxGenTerm',25,'normGeomSelect',...
[0.08],['arithXover'],[2],'nonUnifMutation',[2 25 3]) %25次遗传迭代
运算借过为：x =
7.8562 24.8553(当x为7.8562时，f（x）取最大值24.8553)
注：遗传算法一般用来取得近似最优解，而不是最优解。
遗传算法实例2
【问题】在－5<=Xi<=5,i=1,2区间内，求解
f(x1,x2)=-20*exp(-0.2*sqrt(0.5*(x1.^2+x2.^2)))-exp(0.5*(cos(2*pi*x1)+cos(2*pi*x2)))+22.71282的最小值。
【分析】种群大小10，最大代数1000，变异率0.1,交叉率0.3
【程序清单】
％源函数的matlab代码
function [eval]=f(sol)
numv=size(sol,2);
x=sol(1:numv);
eval=-20*exp(-0.2*sqrt(sum(x.^2)/numv)))-exp(sum(cos(2*pi*x))/numv)+22.71282;
%适应度函数的matlab代码
function [sol,eval]=fitness(sol,options)
numv=size(sol,2)-1;
x=sol(1:numv);
eval=f(x);
eval=-eval;
%遗传算法的matlab代码
bounds=ones(2,1)*[-5 5];
[p,endPop,bestSols,trace]=ga(bounds,'fitness')
注：前两个文件存储为m文件并放在工作目录下，运行结果为
p =
0.0000 -0.0000 0.0055
大家可以直接绘出f(x)的图形来大概看看f（x）的最值是多少，也可是使用优化函数来验证。
matlab命令行执行命令：
fplot('x+10*sin(5*x)+7*cos(4*x)',[0,9])
evalops是传递给适应度函数的参数，opts是二进制编码的精度，termops是选择
maxGenTerm结束函数时传递个maxGenTerm的参数，即遗传代数。xoverops是
传递给交叉函数的参数。mutops是传递给变异函数的参数。
%郭涛算法_多父体杂交算法和郭涛算法_精英多父体杂交算法分别20次数值实验,并给出平均时间
clear all;
N=50;%初始个体个数
M=8;
n=1;%论域维数,可修改,用循环做
eps=1e-6;%精度
upper=10;lower=-10;%论域范围
drop=upper-lower;
%郭涛算法_多父体杂交算法
minP0=zeros(20,n);minQ0=zeros(20,1);
minFrequency0=zeros(20,1);minTimes0=zeros(20,1);
for i=1:20
[minP0(i,:),minQ0(i),minFrequency0(i),minTimes0(i)]=GT(N,M,n,upper,lower,eps);
end
%对minP、minQ、minFrequency按minQ从小到打排序
tempP=zeros(20,n);tempFrequency=zeros(20,1);
[X,I]=sort(minQ0);
for r=1:20
tempP(r,:)=minP0(I(r),:);
tempFrequency(r)=minFrequency0(I(r));
end
minP0=tempP;minQ0=X;minFrequency0=tempFrequency;
averageTime0=sum(minTimes0)/20;
averageFrequency0=sum(minFrequency0)/20;
%郭涛算法_精英多父体杂交算法
minP1=zeros(20,n);minQ1=zeros(20,1);
minFrequency1=zeros(20,1);minTimes1=zeros(20,1);
for i=1:20
[minP1(i,:),minQ1(i),minFrequency1(i),minTimes1(i)]=GT_GYZJ(N,M,n,upper,lower,eps);
end
%对minP、minQ、minFrequency按minQ从小到打排序
tempP=zeros(20,n);tempFrequency=zeros(20,1);
[X,I]=sort(minQ1);
for r=1:20
tempP(r,:)=minP1(I(r),:);
tempFrequency(r)=minFrequency1(I(r));
end
minP1=tempP;minQ1=X;minFrequency1=tempFrequency;
averageTime1=sum(minTimes1)/20;
averageFrequency1=sum(minFrequency1)/20;
%郭涛算法_多父体杂交算法
function [P_Best,Best,Frequency,Time]=GT(N,M,n,upper,lower,eps)
if nargin<6
disp('输入参数错误');
return;
elseif nargout<4
disp('输出参数错误');
return;
end
drop=upper-lower;%若各个分量上下界不同，可以用数组来代替
P=zeros(N,n);%存放初始N个个体，每个个体有n个基因位
Q=zeros(N,1);%存放P中个体对应函数值
Frequency =0;%当前比较次数
tic
%生成初始群体P
for s=1:n
P(:,s)=drop*rand(N,1)+lower;
end
%生成初始群体P对应的函数值
for r=1:N
Q(r)=f(P(r,:));
end
[Best,BestIndex]=min(Q);[Worst,WorstIndex]=max(Q);
%以下为郭涛算法主体循环部分
A=zeros(1,M);B=zeros(1,M);
while Worst-Best>eps
Frequency=Frequency +1;
%从P中选M个个体生成空间V，其下标存放于A中
A=floor(rand(1,M)*(N-1))+1;
%生成Xson的各个组合系数(待检测)
sum=0;minbound=-0.5;maxbound=1.5;
for r=1:M-1
B(r)=(maxbound-minbound)*rand(1)+minbound;
sum=sum+B(r);
maxbound=min(1.5,1.5-sum);
minbound=max(-0.5,-0.5-sum);
end
B(M)=1-sum;
%生成Xson
Xson=zeros(1,n);
for r=1:M
Xson=Xson+B(r)*P(A(r),:);
end
%越界处理
for s=1:n
if Xson(s)<lower
Xson(s)=lower;
elseif Xson(s)>upper
Xson(s)=upper;
end
end
y=f(Xson);
if y<Worst
P(WorstIndex,:)=Xson;Q(WorstIndex)=y;
[Best,BestIndex]=min(Q);
[Worst,WorstIndex]=max(Q);
end
end
P_Best=P(BestIndex,:);Time=toc;
%郭涛算法_精英多父体杂交算法
function [P_Best,Best,Frequency,Time]=GT_GYZJ(N,M,n,upper,lower,eps)
if nargin<6
disp('输入参数错误');
return;
elseif nargout<4
disp('输出参数错误');
return;
end
drop=upper-lower;%若各个分量上下界不同，可以用数组来代替
P=zeros(N,n);%存放初始N个个体，每个个体有n个基因位
Q=zeros(N,1);%存放P中个体对应函数值
Frequency =0;%当前比较次数
tic
%生成初始群体P
for s=1:n
P(:,s)=drop*rand(N,1)+lower;
end
%生成初始群体P对应的函数值
for r=1:N
Q(r)=f(P(r,:));
end
[Best,BestIndex]=min(Q);[Worst,WorstIndex]=max(Q);
%以下为郭涛算法主体循环部分
A=zeros(1,M);B=zeros(1,M);
while Worst-Best>eps
Frequency=Frequency +1;
[m,A(1)]=min(Q);
%从P中选M-1个个体生成空间V，其下标存放于A中
A(2:end)=floor(rand(1,M-1)*(N-1))+1;
%生成Xson的各个组合系数(待检测)
sum=0;minbound=-0.5;maxbound=1.5;
for r=1:M-1
B(r)=(maxbound-minbound)*rand(1)+minbound;
sum=sum+B(r);
maxbound=min(1.5,1.5-sum);
minbound=max(-0.5,-0.5-sum);
end
B(M)=1-sum;
%生成Xson
Xson=zeros(1,n);
for r=1:M
Xson=Xson+B(r)*P(A(r),:);
end
%越界处理
for s=1:n
if Xson(s)<lower
Xson(s)=lower;
elseif Xson(s)>upper
Xson(s)=upper;
end
end
y=f(Xson);
if y<Worst
P(WorstIndex,:)=Xson;Q(WorstIndex)=y;
[Best,BestIndex]=min(Q);
[Worst,WorstIndex]=max(Q);
end
end
P_Best=P(BestIndex,:);Time=toc;
%函数f(x)
function y=f(x)
n=length(x);
y=1;
for i=1:n
s=0;
for j=1:5
s=s+j*cos((j+1)*x(i)+j);
end
y=y*s;
end
关键
|
