三个遗传算法程序.docx

三个遗传算法程序.docx

《三个遗传算法程序.docx》由会员分享，可在线阅读，更多相关《三个遗传算法程序.docx（22页珍藏版）》请在冰点文库上搜索。

三个遗传算法程序

遗传算法程序

（一）:

说明:

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'）;end

ifnargin==3,eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[01e-4];end

ifnargin==4,popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[01e-4];end

ifnargin==5,pCross=0.8;pMutation=0.1;pInversion=0.15;options=[01e-4];end

ifnargin==6,pMutation=0.1;pInversion=0.15;options=[01e-4];end

ifnargin==7,pInversion=0.15;options=[01e-4];end

iffind（（LB-UB）>0）

error（'数据输入错误,请重新输入（LB

'）;

end

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

forj=1:

m

value（j）=feval（FUN（1,:

）,（b2f（Pop（j,:

）,bounds,bits）））;%计算适应度

end

[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;

end

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）<0

elapsed_time（6）=elapsed_time（6）+60;elapsed_time（5）=elapsed_time（5）-1;

end

ifelapsed_time（5）<0

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）;

%初始化种群

%采用二进制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）;

end

initpop（popsize,:

）=ones（1,len）;%Thewholeoneencodingindividual

%解码

function[fval]=b2f（bval,bounds,bits）

%fval-表征各变量的十进制数

%bval-表征各变量的二进制编码串

%bounds-各变量的取值范围

%bits-各变量的二进制编码长度

scale=（bounds（:

2）-bounds（:

1））'./（2.^bits-1）;%Therangeofthevariables

numV=size（bounds,1）;

cs=[0cumsum（bits）];

fori=1:

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）;

end

%选择操作

%采用基于轮盘赌法的非线性排名选择

%各个体成员按适应值从大到小分配选择概率：

%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）;

fori=1:

m

fit（i）=feval（FUN（1,:

）,（b2f（pop（i,:

）,bounds,bits）））;%以函数值为适应值做排名依据

end

selectprob=fit/sum（fit）;%计算各个体相对适应度（0,1）

q=max（selectprob）;%选择最优的概率

x=zeros（m,2）;

x（:

1）=[m:

-1:

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;newIn=1;

whilenewIn<=m

ifrNums（newIn）

selectpop（newIn,:

）=pop（fitIn,:

）;

newIn=newIn+1;

else

fitIn=fitIn+1;

end

end

%交叉操作

function[NewPop]=CrossOver（OldPop,pCross,opts）

%OldPop为父代种群，pcross为交叉概率

globalmnNewPop

r=rand（1,m）;

y1=find（r

y2=find（r>=pCross）;

len=length（y1）;

iflen>2&mod（len,2）==1%如果用来进行交叉的染色体的条数为奇数，将其调整为偶数

y2（length（y2）+1）=y1（len）;

y1（len）=[];

end

iflength（y1）>=2

fori=0:

2:

length（y1）-2

ifopts==0

[NewPop（y1（i+1）,:

）,NewPop（y1（i+2）,:

）]=EqualCrossOver（OldPop（y1（i+1）,:

）,OldPop（y1（i+2）,:

））;

else

[NewPop（y1（i+1）,:

）,NewPop（y1（i+2）,:

）]=MultiPointCross（OldPop（y1（i+1）,:

）,OldPop（y1（i+2）,:

））;

end

end

end

NewPop（y2,:

）=OldPop（y2,:

）;

%采用均匀交叉

function[children1,children2]=EqualCrossOver（parent1,parent2）

globalnchildren1children2

hidecode=round（rand（1,n））;%随机生成掩码

crossposition=find（hidecode==1）;

holdposition=find（hidecode==0）;

children1（crossposition）=parent1（crossposition）;%掩码为1，父1为子1提供基因

children1（holdposition）=parent2（holdposition）;%掩码为0，父2为子1提供基因

children2（crossposition）=parent2（crossposition）;%掩码为1，父2为子2提供基因

children2（holdposition）=parent1（holdposition）;%掩码为0，父1为子2提供基因

%采用多点交叉，交叉点数由变量数决定

function[Children1,Children2]=MultiPointCross（Parent1,Parent2）

globalnChildren1Children2VarNum

Children1=Parent1;

Children2=Parent2;

Points=sort（unidrnd（n,1,2*VarNum））;

fori=1:

VarNum

Children1（Points（2*i-1）:

Points（2*i））=Parent2（Points（2*i-1）:

Points（2*i））;

Children2（Points（2*i-1）:

Points（2*i））=Parent1（Points（2*i-1）:

Points（2*i））;

end

%变异操作

function[NewPop]=Mutation（OldPop,pMutation,VarNum）

globalmnNewPop

r=rand（1,m）;

position=find（r<=pMutation）;

len=length（position）;

iflen>=1

fori=1:

len

k=unidrnd（n,1,VarNum）;%设置变异点数，一般设置1点

forj=1:

length（k）

ifOldPop（position（i）,k（j））==1

OldPop（position（i）,k（j））=0;

else

OldPop（position（i）,k（j））=1;

end

end

end

end

NewPop=OldPop;

%倒位操作

function[NewPop]=Inversion（OldPop,pInversion）

globalmnNewPop

NewPop=OldPop;

r=rand（1,m）;

PopIn=find（r<=pInversion）;

len=length（PopIn）;

iflen>=1

fori=1:

len

d=sort（unidrnd（n,1,2））;

ifd

（1）~=1&d

（2）~=n

NewPop（PopIn（i）,1:

d

（1）-1）=OldPop（PopIn（i）,1:

d

（1）-1）;

NewPop（PopIn（i）,d

（1）:

d

（2））=OldPop（PopIn（i）,d

（2）:

-1:

d

（1））;

NewPop（PopIn（i）,d

（2）+1:

n）=OldPop（PopIn（i）,d

（2）+1:

n）;

end

end

end

遗传算法程序

（二）:

functionyouhuafun

D=code;

N=50;%Tunable

maxgen=50;%Tunable

crossrate=0.5;%Tunable

muterate=0.08;%Tunable

generation=1;

num=length（D）;

fatherrand=randint（num,N,3）;

score=zeros（maxgen,N）;

whilegeneration<=maxgen

ind=randperm（N-2）+2;%随机配对交叉

A=fatherrand（:

ind（1:

（N-2）/2））;

B=fatherrand（:

ind（（N-2）/2+1:

end））;

%多点交叉

rnd=rand（num,（N-2）/2）;

ind=rndtmp=A（ind）;

A（ind）=B（ind）;

B（ind）=tmp;

%%两点交叉

%forkk=1:

（N-2）/2

%rndtmp=randint（1,1,num）+1;

%tmp=A（1:

rndtmp,kk）;

%A（1:

rndtmp,kk）=B（1:

rndtmp,kk）;

%B（1:

rndtmp,kk）=tmp;

%end

fatherrand=[fatherrand（:

1:

2）,A,B];

%变异

rnd=rand（num,N）;

ind=rnd[m,n]=size（ind）;

tmp=randint（m,n,2）+1;

tmp（:

1:

2）=0;

fatherrand=tmp+fatherrand;

fatherrand=mod（fatherrand,3）;

%fatherrand（ind）=tmp;

%评价、选择

scoreN=scorefun（fatherrand,D）;%求得N个个体的评价函数

score（generation,:

）=scoreN;

[scoreSort,scoreind]=sort（scoreN）;

sumscore=cumsum（scoreSort）;

sumscore=sumscore./sumscore（end）;

childind（1:

2）=scoreind（end-1:

end）;

fork=3:

N

tmprnd=rand;

tmpind=tmprnddifind=[0,diff（tmpind）];

if~any（difind）

difind

（1）=1;

end

childind（k）=scoreind（logical（difind））;

end

fatherrand=fatherrand（:

childind）;

generation=generation+1;

end

%score

maxV=max（score,[],2）;

minV=11*300-maxV;

plot（minV,'*'）;title（'各代的目标函数值'）;

F4=D（:

4）;

FF4=F4-fatherrand（:

1）;

FF4=max（FF4,1）;

D（:

5）=FF4;

saveDDataD

functionD=code

loadyouhua.mat

%propertiesF2andF3

F1=A（:

1）;

F2=A（:

2）;

F3=A（:

3）;

if（max（F2）>1450）||（min（F2）<=900）

error（'DATApropertyF2exceedit''srange（900,1450]'）

end

%getgrouppropertyF1ofdata,accordingtoF2value

F4=zeros（size（F1））;

forite=11:

-1:

1

index=find（F2<=900+ite*50）;

F4（index）=ite;

end

D=[F1,F2,F3,F4];

functionScoreN=scorefun（fatherrand,D）

F3=D（:

3）;

F4=D（:

4）;

N=size（fatherrand,2）;

FF4=F4*ones（1,N）;

FF4rnd=FF4-fatherrand;

FF4rnd=max（FF4rnd,1）;

ScoreN=ones（1,N）*300*11;

%这里有待优化

fork=1:

N

FF4k=FF4rnd（:

k）;

forite=1:

11

F0index=find（FF4k==ite）;

if~isempty（F0index）

tmpMat=F3（F0index）;

tmpSco=sum（tmpMat）;

ScoreBin（ite）=mod（tmpSco,300）;

end

end

Scorek（k）=sum（ScoreBin）;

end

ScoreN=ScoreN-Scorek;

遗传算法程序（三）：

%IAGA

functionbest=ga

clear

MAX_gen=200;%最大迭代步数

best.max_f=0;%当前最大的适应度

STOP_f=14.5;%停止循环的适应度

RANGE=[0255];%初始取值范围[0255]

SPEEDUP_INTER=5;%进入加速迭代的间隔

advance_k=0;%优化的次数

popus=init;%初始化

forgen=1:

MAX_gen

fitness=fit（popus,RANGE）;%求适应度

f=fitness.f;

picked=choose（popus,fitness）;%选择

popus=intercross（popus,picked）;%杂交

popus=aberrance（popus,picked）;%变异

ifmax（f）>best.max_f

advance_k=advance_k+1;

x_better（advance_k）=fitness.x;

best.max_f=max（f）;

best.popus=popus;

best.x=fitness.x;

end

ifmod（advance_k,SPEEDUP_INTER）==0

RANGE=minmax（x_better）;

RANGE

advance=0;

end

end

return;

functionpopus=init%初始化

M=50;%种群个体数目

N=30;%编码长度

popus=round（rand（M,N））;

return;

function