遗传算法的经典案例Word文档下载推荐.docx
《遗传算法的经典案例Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《遗传算法的经典案例Word文档下载推荐.docx（16页珍藏版）》请在冰豆网上搜索。
else
farm_X（j+1,i）=1;
end
end
8
ifRAND<
1/3
farm_Y（j,3*i-2）=1;
elseifRAND>
2/3
farm_Y（j,3*i）=1;
farm_Y（j,3*i-1）=1;
counter=0;
%设置迭代计数器
whilecounter<
M%停止条件为达到最大迭代次数
%第三步：
交叉
newfarm_X=zeros（14,N）;
newfarm_Y=zeros（8,3*N）;
Ser=randperm（N）;
%对X做交叉
fori=1:
（N-1）
A_X=farm_X（:
Ser（i））;
B_X=farm_X（:
Ser（i+1））;
cp=2*unidrnd（6）;
a_X=[A_X（1:
cp）;
B_X（（cp+1）:
end）];
b_X=[B_X（1:
A_X（（cp+1）:
newfarm_X（:
i）=a_X;
i+1）=b_X;
%对Y做交叉
A_Y=farm_Y（:
（3*Ser（i）-2）:
（3*Ser（i）））;
B_Y=farm_Y（:
（3*Ser（i+1）-2）:
（3*Ser（i+1）））;
cp=unidrnd（7）;
a_Y=[A_Y（1:
cp,:
）;
B_Y（（cp+1）:
end,:
）];
b_Y=[B_Y（1:
A_Y（（cp+1）:
newfarm_Y（:
（3*i-2）:
（3*i））=a_Y;
（3*i+1）:
（3*i+3））=b_Y;
%新旧种群合并
FARM_X=[farm_X,newfarm_X];
FARM_Y=[farm_Y,newfarm_Y];
%第四步：
选择复制
Ser=randperm（2*N）;
FITNESS=zeros（1,2*N）;
fitness=zeros（1,N）;
（2*N）
X=FARM_X（:
i）;
Y=FARM_Y（:
（3*i））;
FITNESS（i）=COST（X,Y,x1_x14,F_x1_x14,A,Q,C,S,b）;
f1=FITNESS（Ser（2*i-1））;
f2=FITNESS（Ser（2*i））;
iff1<
f2
farm_X（:
i）=FARM_X（:
Ser（2*i-1））;
farm_Y（:
（3*i））=FARM_Y（:
（3*Ser（2*i-1）-2）:
（3*Ser（2*i-1）））;
fitness（i）=f1;
Ser（2*i））;
（3*Ser（2*i）-2）:
（3*Ser（2*i）））;
fitness（i）=f2;
%记录最佳个体和收敛曲线
minfitness=min（fitness）;
meanfitness=mean（fitness）;
LC1（counter+1）=minfitness;
LC2（counter+1）=meanfitness;
pos=find（fitness==minfitness）;
Xp=farm_X（:
pos
（1））;
Yp=farm_Y（:
（3*pos
（1）-2）:
（3*pos
（1）））;
Zp=minfitness;
%第五步：
变异
ifPm>
rand
GT_X=farm_X（:
GT_Y=farm_Y（:
pos1=2*unidrnd（7）;
ifGT_X（pos1）==1
GT_X（pos1-1）=1;
GT_X（pos1）=0;
i）=GT_X;
elseifGT_X（pos1）==0
GT_X（pos1-1）=0;
GT_X（pos1）=1;
pos2=unidrnd（8）;
GT_Y（pos2,:
）=zeros（1,3）;
GT_Y（pos2,unidrnd（3））=1;
end
counter=counter+1
Xp=Xp'
;
Yp=Yp'
%plot（LC1）
%holdon
plot（LC2）
遗传算法程序:
说明:
fga.m为遗传算法的主程序;
采用二进制Gray编码,采用基于轮盘赌法的非线性排名选择,均匀交叉,变异操作,而且还引入了倒位操作!
function[BestPop,Trace]=fga（FUN,LB,UB,eranum,popsize,pCross,pMutation,pInversion,options）
%[BestPop,Trace]=fmaxga（FUN,LB,UB,eranum,popsize,pcross,pmutation）
%Findsamaximumofafunctionofseveralvariables.
%fmaxgasolvesproblemsoftheform:
%maxF（X）subjectto:
LB<
=X<
=UB
%BestPop-最优的群体即为最优的染色体群
%Trace-最佳染色体所对应的目标函数值
%FUN-目标函数
%LB-自变量下限
%UB-自变量上限
%eranum-种群的代数,取100--1000（默认200）
%popsize-每一代种群的规模；
此可取50--200（默认100）
%pcross-交叉概率,一般取0.5--0.85之间较好（默认0.8）
%pmutation-初始变异概率,一般取0.05-0.2之间较好（默认0.1）
%pInversion-倒位概率,一般取0.05－0.3之间较好（默认0.2）
%options-1*2矩阵,options
（1）=0二进制编码（默认0）,option
（1）~=0十进制编
%码,option
（2）设定求解精度（默认1e-4）
%
%------------------------------------------------------------------------
T1=clock;
ifnargin<
3,error（'
FMAXGArequiresatleastthreeinputarguments'
ifnargin==3,eranum=200;
popsize=100;
pCross=0.8;
pMutation=0.1;
pInversion=0.15;
options=[01e-4];
ifnargin==4,popsize=100;
ifnargin==5,pCross=0.8;
ifnargin==6,pMutation=0.1;
ifnargin==7,pInversion=0.15;
iffind（（LB-UB）>
0）
error（'
数据输入错误,请重新输入（LB<
UB）:
'
s=sprintf（'
程序运行需要约%.4f秒钟时间,请稍等......'
（eranum*popsize/1000））;
disp（s）;
globalmnNewPopchildren1children2VarNum
bounds=[LB;
UB]'
bits=[];
VarNum=size（bounds,1）;
precision=options
（2）;
%由求解精度确定二进制编码长度
bits=ceil（log2（（bounds（:
2）-bounds（:
1））'
./precision））;
%由设定精度划分区间
[Pop]=InitPopGray（popsize,bits）;
%初始化种群
[m,n]=size（Pop）;
NewPop=zeros（m,n）;
children1=zeros（1,n）;
children2=zeros（1,n）;
pm0=pMutation;
BestPop=zeros（eranum,n）;
%分配初始解空间BestPop,Trace
Trace=zeros（eranum,length（bits）+1）;
i=1;
whilei<
=eranum
m
value（j）=feval（FUN（1,:
）,（b2f（Pop（j,:
）,bounds,bits）））;
%计算适应度
[MaxValue,Index]=max（value）;
BestPop（i,:
）=Pop（Index,:
Trace（i,1）=MaxValue;
Trace（i,（2:
length（bits）+1））=b2f（BestPop（i,:
）,bounds,bits）;
[selectpop]=NonlinearRankSelect（FUN,Pop,bounds,bits）;
%非线性排名选择
[CrossOverPop]=CrossOver（selectpop,pCross,round（unidrnd（eranum-i）/eranum））;
%采用多点交叉和均匀交叉，且逐步增大均匀交叉的概率
%round（unidrnd（eranum-i）/eranum）
[MutationPop]=Mutation（CrossOverPop,pMutation,VarNum）;
%变异
[InversionPop]=Inversion（MutationPop,pInversion）;
%倒位
Pop=InversionPop;
%更新
pMutation=pm0+（i^4）*（pCross/3-pm0）/（eranum^4）;
%随着种群向前进化，逐步增大变异率至1/2交叉率
p（i）=pMutation;
i=i+1;
t=1:
eranum;
plot（t,Trace（:
1）'
title（'
函数优化的遗传算法'
xlabel（'
进化世代数（eranum）'
ylabel（'
每一代最优适应度（maxfitness）'
[MaxFval,I]=max（Trace（:
1））;
X=Trace（I,（2:
length（bits）+1））;
holdon;
plot（I,MaxFval,'
*'
text（I+5,MaxFval,['
FMAX='
num2str（MaxFval）]）;
str1=sprintf（'
进化到%d代,自变量为%s时,得本次求解的最优值%f\n对应染色体是：
%s'
I,num2str（X）,MaxFval,num2str（BestPop（I,:
）））;
disp（str1）;
%figure
（2）;
plot（t,p）;
%绘制变异值增大过程
T2=clock;
elapsed_time=T2-T1;
ifelapsed_time（6）<
elapsed_time（6）=elapsed_time（6）+60;
elapsed_time（5）=elapsed_time（5）-1;
ifelapsed_time（5）<
elapsed_time（5）=elapsed_time（5）+60;
elapsed_time（4）=elapsed_time（4）-1;
end%像这种程序当然不考虑运行上小时啦
str2=sprintf（'
程序运行耗时%d小时%d分钟%.4f秒'
elapsed_time（4）,elapsed_time（5）,elapsed_time（6））;
disp（str2）;
TSP问题遗传算法matlab源程序（注释详细，经反复实验收敛速度快）
%TSP问题（又名：
旅行商问题，货郎担问题）遗传算法通用matlab程序
%D是距离矩阵，n为种群个数,建议取为城市个数的1~2倍，
%C为停止代数，遗传到第C代时程序停止,C的具体取值视问题的规模和耗费的时间而定
%m为适应值归一化淘汰加速指数,最好取为1,2,3,4,不宜太大
%alpha为淘汰保护指数,可取为0~1之间任意小数,取1时关闭保护功能,最好取为0.8~1.0
%R为最短路径,Rlength为路径长度
function[R,Rlength]=geneticTSP（D,n,C,m,alpha）
[N,NN]=size（D）;
farm=zeros（n,N）;
%用于存储种群
n
farm（i,=randperm（N）;
%随机生成初始种群
R=farm（1,;
%存储最优种群
len=zeros（n,1）;
%存储路径长度
fitness=zeros（n,1）;
%存储归一化适应值
C
len（i,1）=myLength（D,farm（i,）;
%计算路径长度
maxlen=max（len）;
minlen=min（len）;
fitness=fit（len,m,maxlen,minlen）;
%计算归一化适应值
rr=find（len==minlen）;
R=farm（rr（1,1）,;
%更新最短路径
FARM=farm;
%优胜劣汰，nn记录了复制的个数
nn=0;
iffitness（i,1）>
=alpha*rand
nn=nn+1;
FARM（nn,=farm（i,;
FARM=FARM（1:
nn,;
[aa,bb]=size（FARM）;
%交叉和变异
whileaa<
ifnn<
=2
nnper=randperm
（2）;
nnper=randperm（nn）;
A=FARM（nnper
（1）,;
B=FARM（nnper
（2）,;
[A,B]=intercross（A,B）;
FARM=[FARM;
A;
B];
ifaa>
n,;
%保持种群规模为n
farm=FARM;
clearFARM
Rlength=myLength（D,R）;
function[a,b]=intercross（a,b）
L=length（a）;
ifL<
=10%确定交叉宽度
W=1;
elseif（（L/10）-floor（L/10））>
=rand&
&
L>
10
W=ceil（L/10）;
else
W=floor（L/10）;
p=unidrnd（L-W+1）;
%随机选择交叉范围，从p到p+W
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,p+i-1））;
[a（1,x）,b（1,y）]=exchange（a（1,x）,b（1,y））;
function[x,y]=exchange（x,y）
temp=x;
x=y;
y=temp;
%计算路径的子程序
functionlen=myLength（D,p）
len=D（p（1,N）,p（1,1））;
fori=1N-1）
len=len+D（p（1,i）,p（1,i+1））;
%计算归一化适应值子程序
functionfitness=fit（len,m,maxlen,minlen）
fitness=len;
length（len）
fitness（i,1）=（1-（（len（i,1）-minlen）/（maxlen-minlen+0.000001）））.^m;
end
%采用二进制Gray编码,其目的是为了克服二进制编码的Hamming悬崖缺点
function[initpop]=InitPopGray（popsize,bits）
len=sum（bits）;
initpop=zeros（popsize,len）;
%Thewholezeroencodingindividual
fori=2:
popsize-1
pop=round（rand（1,len））;
pop=mod（（[0pop]+[pop0]）,2）;
%i=1时,b
（1）=a
（1）;
i>
1时,b（i）=mod（a（i-1）+a（i）,2）
%其中原二进制串:
a
（1）a
（2）...a（n）,Gray串:
b
（1）b
（2）...b（n）
initpop（i,:
）=pop（1:
end-1）;
initpop（popsize,:
）=ones（1,len）;
%Thewholeoneencodingindividual
%解码
function[fval]=b2f（bval,bounds,bits）
%fval-表征各变量的十进制数
%bval-表征各变量的二进制编码串
%bounds-各变量的取值范围
%bits-各变量的二进制编码长度
scale=（bounds（:
./（2.^bits-1）;
%Therangeofthevariables
numV=size（bounds,1）;
cs=[0cumsum（bits）];
numV
a=bval（（cs（i）+1）:
cs（i+1））;
fval（i）=sum（2.^（size（a,2）-1:
-1:
0）.*a）*scale（i）+bounds（i,1）;
%选择操作
%采用基于轮盘赌法的非线性排名选择
%各个体成员按适应值从大到小分配选择概率：
%P（i）=（q/1-（1-q）^n）*（1-q）^i,其中P（0）>
P
（1）>
...>
P（n）,sum（P（i））=1
function[selectpop]=NonlinearRankSelect（FUN,pop,bounds,bits）
globalmn
selectpop=zeros（m,n）;
fit=zeros（m,1）;
fit（i）=feval（FUN（1,:
）,（b2f（pop（i,:
%以函数值为适应值做排名依据
selectprob=fit/sum（fit）;
%计算各个体相对适应度（0,1）
q=max（selectprob）;
%选择最优的概率
x=zeros（m,2）;
x（:
1）=[m:
1]'
[yx（:
2）]=sort（selectprob）;
r=q/（1-（1-q）^m）;
%标准分布基值
newfit（x（:
2））=r*（1-q）.^（x（:
1）-1）;
%生成选择概率
newfit=cumsum（newfit）;
%计算各选择概率之和
rNums=sort（rand（m,1））;
fitIn=1;
new
升级会员 