遗传算法求函数极值
利用遗传算法求函数的极大值
利用遗传算法求函数的极大值该函数有两个局部极大值点,分别是f (2.048,-2.048)=3897.7342和f (2.048,-2.048)=3905.9262,其中,后者为全局最大点。
可以分别用二进制编码和十进制编码遗传算法求函数极大值遗传算法二进制编码求函数极大值程序%Generic Algorithm for function f(x1,x2) optimumclear all;close all;%Parameters 参数Size=80; %群体大小G=100; %终止进化代数CodeL=10; %代码长度umax=2.048;umin=-2.048;E=round(rand(Size,2*CodeL)); %Initial Code 最初代码%Main Program 主程序for k=1:1:Gtime(k)=k;222212121(,)100()(1)2.048 2.048(1,2)i f x x x x x x i ⎧=-+-⎨-≤≤=⎩for s=1:1:Sizem=E(s,:);y1=0;y2=0; %X对应的十进制代码%Uncodingm1=m(1:1:CodeL);for i=1:1:CodeLy1=y1+m1(i)*2^(i-1); %将y1转换为十进制数endx1=(umax-umin)*y1/1023+umin;m2=m(CodeL+1:1:2*CodeL);for i=1:1:CodeLy2=y2+m2(i)*2^(i-1); %将y2转换为十进制数endx2=(umax-umin)*y2/1023+umin; %求x对应的十进制数F(s)=100*(x1^2-x2)^2+(1-x1)^2; %个体适应度函数endJi=1./F; %个体适应度函数的倒数%****** Step 1 : Evaluate BestJ ******BestJ(k)=min(Ji);fi=F; %Fitness Function 适应函数[Oderfi,Indexfi]=sort(fi); %Arranging fi small to biggerBestfi=Oderfi(Size); %Let Bestfi=max(fi)BestS=E(Indexfi(Size),:); %Let BestS=E(m), m is the Indexfi belong to max(fi) %最佳样本bfi(k)=Bestfi;%****** Step 2 : Select and Reproduct Operation******fi_sum=sum(fi);fi_Size=(Oderfi/fi_sum)*Size;fi_S=floor(fi_Size); %Selecting Bigger fi valuekk=1;for i=1:1:Sizefor j=1:1:fi_S(i) %Select and ReproduceTempE(kk,:)=E(Indexfi(i),:);kk=kk+1; %kk is used to reproduceendend%************ Step 3 : Crossover Operation ************pc=0.60; %交叉概率n=ceil(20*rand); %种群大小for i=1:2:(Size-1)temp=rand;if pc>temp %Crossover Conditionfor j=n:1:20TempE(i,j)=E(i+1,j); %交换E(i,j)和E(i+1,j)TempE(i+1,j)=E(i,j);endendendTempE(Size,:)=BestS;E=TempE;%************ Step 4: Mutation Operation ************** %pm=0.001; %变异概率%pm=0.001-[1:1:Size]*(0.001)/Size; %Bigger fi, smaller Pm %pm=0.0; %No mutationpm=0.1; %Big mutationfor i=1:1:Sizefor j=1:1:2*CodeLtemp=rand;if pm>temp %Mutation Conditionif TempE(i,j)==0TempE(i,j)=1;elseTempE(i,j)=0;endendendend%Guarantee TempPop(30,:) is the code belong to the best individual(max(fi)) TempE(Size,:)=BestS;E=TempE;endMax_Value=BestfiBestSx1x2figure(1);plot(time,BestJ); %目标函数和时间的坐标系xlabel('Times');ylabel('Best J');figure(2);plot(time,bfi);xlabel('times');ylabel('Best F');遗传算法十进制编码求函数极大值程序%Generic Algorithm for function f(x1,x2) optimumclear all;close all;%Parameters参数Size=80;G=100; %迭代次数CodeL=10; %编码长度umax=2.048;umin=-2.048;E=round(rand(Size,2*CodeL)); %Initial Code ???%Main Programfor k=1:1:Gtime(k)=k;for s=1:1:Sizem=E(s,:);y1=0;y2=0;%Uncodingm1=m(1:1:CodeL); %???for i=1:1:CodeLy1=y1+m1(i)*2^(i-1);endx1=(umax-umin)*y1/1023+umin;m2=m(CodeL+1:1:2*CodeL);for i=1:1:CodeLy2=y2+m2(i)*2^(i-1);endx2=(umax-umin)*y2/1023+umin;F(s)=100*(x1^2-x2)^2+(1-x1)^2;endJi=1./F;%****** Step 1 : Evaluate BestJ ****** BestJ(k)=min(Ji);fi=F; %Fitness Function[Oderfi,Indexfi]=sort(fi); %Arranging fi small to biggerBestfi=Oderfi(Size); %Let Bestfi=max(fi)BestS=E(Indexfi(Size),:); %Let BestS=E(m), m is the Indexfi belong to max(fi)bfi(k)=Bestfi;%****** Step 2 : Select and Reproduct Operation******fi_sum=sum(fi);fi_Size=(Oderfi/fi_sum)*Size;fi_S=floor(fi_Size); %Selecting Bigger fi valuekk=1;for i=1:1:Sizefor j=1:1:fi_S(i) %Select and ReproduceTempE(kk,:)=E(Indexfi(i),:);kk=kk+1; %kk is used to reproduceendend%************ Step 3 : Crossover Operation ************ pc=0.60;n=ceil(20*rand);for i=1:2:(Size-1)temp=rand;if pc>temp %Crossover Conditionfor j=n:1:20TempE(i,j)=E(i+1,j);TempE(i+1,j)=E(i,j);endendendTempE(Size,:)=BestS;E=TempE;%************ Step 4: Mutation Operation ************** %pm=0.001;%pm=0.001-[1:1:Size]*(0.001)/Size; %Bigger fi, smaller Pm%pm=0.0; %No mutationpm=0.1; %Big mutationfor i=1:1:Sizefor j=1:1:2*CodeLtemp=rand;if pm>temp %Mutation Conditionif TempE(i,j)==0TempE(i,j)=1;elseTempE(i,j)=0;endendendend%Guarantee TempPop(30,:) is the code belong to the best individual(max(fi)) TempE(Size,:)=BestS;E=TempE;endMax_Value=BestfiBestSx1x2figure(1);plot(time,BestJ);xlabel('Times');ylabel('Best J');figure(2);plot(time,bfi);xlabel('times');ylabel('Best F');思考:通过改变群体大小、终止进化代数G、交叉概率P c和变异概率P m,分析群体大小、终止进化代数、交叉概率和变异概率对优化效果的影响。
利用遗传算法求函数的极大值
利用遗传算法求函数的极大值遗传算法是一种通过模拟生物进化的方式来解决优化问题的算法。
它基于达尔文的演化论思想,通过不断演化和交叉变异,逐步优化解空间中的解向最优解靠拢。
在求解函数的极大值问题中,遗传算法可以通过优化染色体的基因序列来寻找最大值点。
遗传算法的基本流程如下:1.初始化种群:随机生成初始种群,每个个体都对应问题的一个可能解。
2.适应度评估:根据问题的具体要求,计算每个个体的适应度值,即目标函数值。
3.选择操作:根据适应度值选择一定数量的个体作为父代,用于进行交叉和变异操作。
4.交叉操作:从父代中选择两个个体,按照一定的交叉规则对其基因序列进行交叉生成子代。
5.变异操作:对子代的基因序列进行一定概率的变异操作,引入新的基因。
6.新一代种群形成:将父代和子代合并形成新一代种群。
7.终止条件判断:根据设定的终止条件判断是否停止算法。
8.若满足终止条件,输出结果;否则,转至步骤2在求解函数的极大值问题中,适应度评估的目标函数可以直接使用待求解函数的值。
下面以一个简单的函数f(x)=x^2为例,说明如何利用遗传算法求函数的极大值。
1.初始化种群:随机生成一定数量的个体,每个个体的基因序列代表一个可能的解,在本例中基因序列即为x的取值。
2.适应度评估:计算每个个体的适应度,即将基因序列代入目标函数得到函数值。
3.选择操作:根据适应度值选择一定数量的个体作为父代。
4.交叉操作:从父代中选择两个个体,按照一定的交叉规则对其基因序列进行交叉生成子代。
5.变异操作:对子代的基因序列进行一定概率的变异操作,引入新的基因。
6.新一代种群形成:将父代和子代合并形成新一代种群。
7.终止条件判断:根据设定的终止条件判断是否停止算法。
例如,可以设定迭代次数达到一定阈值或者适应度值足够接近最大值。
8.若满足终止条件,输出最优解的基因序列;否则,转至步骤2通过不断迭代上述步骤,遗传算法可以逐步逼近函数的极大值点。
在实际应用中,可以根据问题的具体特性和要求对交叉、变异概率等参数进行调整,以达到更好的求解效果。
遗传算法GA求解函数极值
主程序%% GAclc % 清屏clear all; % 删除workplace变量close all; % 关掉显示图形窗口warning off%% 参数初始化popsize=100; %种群规模lenchrom=7; %变量字串长度pc=0.7; %设置交叉概率,本例中交叉概率是定值,若想设置变化的交叉概率可用表达式表示,或从写一个交叉概率函数,例如用神经网络训练得到的值作为交叉概率pm=0.3; %设置变异概率,同理也可设置为变化的maxgen=100; % 进化次数%种群popmax=50;popmin=0;bound=[popminpopmax;popminpopmax;popminpopmax;popminpopmax;popminpopmax;popminpopmax;popm inpopmax]; %变量范围%% 产生初始粒子和速度fori=1:popsize%随机产生一个种群GApop(i,:)=Code(lenchrom,bound); %随机产生个体%计算适应度fitness(i)=fun(GApop(i,:)); %染色体的适应度end%找最好的染色体[bestfitnessbestindex]=min(fitness);zbest=GApop(bestindex,:); %全局最佳gbest=GApop; %个体最佳fitnessgbest=fitness; %个体最佳适应度值fitnesszbest=bestfitness; %全局最佳适应度值%% 迭代寻优fori=1:maxgeni%种群更新GA选择更新GApop=Select2(GApop,fitness,popsize);% 交叉操作GAGApop=Cross(pc,lenchrom,GApop,popsize,bound);% 变异操作GA变异GApop=Mutation(pm,lenchrom,GApop,popsize,[imaxgen],bound);pop=GApop;for j=1:popsize%适应度值if0.072*pop(j,1)+0.063*pop(j,2)+0.057*pop(j,3)+0.05*pop(j,4)+0.032*pop(j,5)+0.0442*pop(j,6)+0.0675*pop(j,7) <=264.4if128*pop(j,1)+78.1*pop(j,2)+64.1*pop(j,3)+43*pop(j,4)+58.1*pop(j,5)+36.9*pop(j,6)+50.5*pop(j,7)<=69719 fitness(j)=fun(pop(j,:));endend%个体最优更新if fitness(j) <fitnessgbest(j)gbest(j,:) = pop(j,:);fitnessgbest(j) = fitness(j);end%群体最优更新if fitness(j) <fitnesszbestzbest = pop(j,:);fitnesszbest = fitness(j);endendyy(i)=fitnesszbest;end%% 结果disp '*************best particle number****************'zbest%%plot(yy,'linewidth',2);title(['适应度曲线' '终止代数=' num2str(maxgen)]);xlabel('进化代数');ylabel('适应度');grid on子程序funfunction y = fun(x)y=0.072*x(1)+0.063*x(2)+0.057*x(3)+0.05*x(4)+0.032*x(5)+0.0442*x(6)+0.0675*x(7);Mutationfunction ret=Mutation(pmutation,lenchrom,chrom,sizepop,pop,bound)% 本函数完成变异操作% pcorss input : 变异概率% lenchrom input : 染色体长度% chrom input : 染色体群% sizepop input : 种群规模% pop input : 当前种群的进化代数和最大的进化代数信息% ret output : 变异后的染色体fori=1:sizepop% 随机选择一个染色体进行变异pick=rand;while pick==0pick=rand;endindex=ceil(pick*sizepop);% 变异概率决定该轮循环是否进行变异pick=rand;if pick>pmutationcontinue;endflag=0;while flag==0% 变异位置pick=rand;while pick==0pick=rand;endpos=ceil(pick*sum(lenchrom)); %随机选择了染色体变异的位置,即选择了第pos个变量进行变异v=chrom(i,pos);v1=v-bound(pos,1);v2=bound(pos,2)-v;pick=rand; %变异开始if pick>0.5delta=v2*(1-pick^((1-pop(1)/pop(2))^2));chrom(i,pos)=v+delta;elsedelta=v1*(1-pick^((1-pop(1)/pop(2))^2));chrom(i,pos)=v-delta;end %变异结束flag=test(lenchrom,bound,chrom(i,:)); %检验染色体的可行性endendret=chrom;Crossfunction ret=Cross(pcross,lenchrom,chrom,sizepop,bound)%本函数完成交叉操作% pcorss input : 交叉概率% lenchrom input : 染色体的长度% chrom input : 染色体群% sizepop input : 种群规模% ret output : 交叉后的染色体fori=1:sizepop% 随机选择两个染色体进行交叉pick=rand(1,2);while prod(pick)==0pick=rand(1,2);endindex=ceil(pick.*sizepop);% 交叉概率决定是否进行交叉pick=rand;while pick==0pick=rand;endif pick>pcrosscontinue;endflag=0;while flag==0% 随机选择交叉位置pick=rand;while pick==0pick=rand;endpos=ceil(pick.*sum(lenchrom)); %随机选择进行交叉的位置,即选择第几个变量进行交叉,注意:两个染色体交叉的位置相同pick=rand; %交叉开始v1=chrom(index(1),pos);v2=chrom(index(2),pos);chrom(index(1),pos)=pick*v2+(1-pick)*v1;chrom(index(2),pos)=pick*v1+(1-pick)*v2; %交叉结束flag1=test(lenchrom,bound,chrom(index(1),:)); %检验染色体1的可行性flag2=test(lenchrom,bound,chrom(index(2),:)); %检验染色体2的可行性if flag1*flag2==0flag=0;else flag=1;end %如果两个染色体不是都可行,则重新交叉endendret=chrom;Codefunction ret=Code(lenchrom,bound)%本函数将变量编码成染色体,用于随机初始化一个种群% lenchrom input : 染色体长度% bound input : 变量的取值范围% ret output: 染色体的编码值flag=0;while flag==0pick=rand(1,lenchrom);ret=bound(:,1)'+(bound(:,2)-bound(:,1))'.*pick; %线性插值flag=test(lenchrom,bound,ret); %检验染色体的可行性endSelect2function ret=Select(individuals,fitness,sizepop)% 本函数对每一代种群中的染色体进行选择,以进行后面的交叉和变异% individuals input : 种群信息% fitness input : 适应度% sizepop input : 种群规模% opts input : 选择方法的选择% ret output : 经过选择后的种群fitness= 1./(fitness);sumfitness=sum(fitness);sumf=fitness./sumfitness;index=[];for i=1:sizepop %转sizepop次轮盘pick=rand;while pick==0pick=rand;endfor j=1:sizepoppick=pick-sumf(j);if pick<0index=[index j];break; %寻找落入的区间,此次转轮盘选中了染色体i,注意:在转sizepop次轮盘的过程中,有可能会重复选择某些染色体endendendindividuals=individuals(index,:);fitness=fitness(index);ret=individuals;testfunction flag=test(lenchrom,bound,code)% lenchrom input : 染色体长度% bound input : 变量的取值范围% code output: 染色体的编码值flag=1;[n,m]=size(code);fori=1:nif code(i)<bound(i,1) || code(i)>bound(i,2)flag=0;endend。
利用遗传算法求rosenbrock函数的极大值
利用遗传算法求rosenbrock函数的极大值遗传算法是一种常用于解决复杂问题的机器学习算法,而Rosenbrock函数是一种特殊的二叉搜索树函数,它在搜索树中找到了一组最优解,并且能够保持这些最优解的稳定性。
因此,Rosenbrock函数的极大值是搜索树中的一个重要问题。
为了求解Rosenbrock函数的极大值,可以使用遗传算法来解决。
遗传算法的基本思想是通过随机化交配和自然选择来改进算法的性能。
在遗传算法中,每个个体都是随机生成的,并且每个决策变量和变异体都对应着不同的搜索树结构和策略。
然后,通过交叉和变异操作,算法不断迭代,直到达到最优解。
对于Rosenbrock函数的极大值问题,我们可以将搜索树看作是一个二叉搜索树,并且通过计算每个节点的Rosenbrock函数值来确定搜索树的根节点的值。
具体来说,我们可以将搜索树分成两个子搜索树,一个子搜索树是Rosenbrock函数的极大值所在的子搜索树,另一个子搜索树是搜索树中任意一个节点的Rosenbrock函数的极大值所在的子搜索树。
在求解Rosenbrock函数的极大值问题时,我们可以使用经典的遗传算法求解步骤。
首先,初始化所有个体的值,然后随机生成所有个体的变异体。
接着,计算每个个体的父节点的值,并将这些父节点的值作为个体的变异系数。
然后,计算每个个体的交叉子节点的值,并将这些交叉子节点的值作为个体的变异系数。
最后,根据交叉和变异操作的结果,不断迭代,直到达到最优解。
需要注意的是,在遗传算法中,每个个体的值是由所有个体的值和变异系数计算得到的。
因此,在计算每个个体的值时,需要考虑到所有个体的值和变异系数。
此外,在计算交叉和变异操作的结果时,需要考虑到所有个体的值和变异系数。
利用遗传算法求解Rosenbrock函数的极大值问题是一种有效的方法,可以高效地求解这个问题。
此外,遗传算法还可以应用于其他搜索树的求解问题,如最小生成树、最短路径问题等。
遗传算法用matlab求函数极大值
遗传算法用matlab求函数极大值一、题目:寻找f(x)=x2,,当x在0~31区间的最大值。
二、源程序:%遗传算法求解函数最大值%本程序用到了英国谢菲尔德大学(Sheffield)开发的工具箱GATBX,该工具箱比matlab自带的GATOOL使用更加灵活,但在编写程序方面稍微复杂一些Close all;Clear all;figure(1);fplot('variable*variable',[0,31]); %画出函数曲线%以下定义遗传算法参数GTSM=40; %定义个体数目ZDYCDS=20; %定义最大遗传代数EJZWS=5; %定义变量的二进制位数DG=0.9; %定义代沟trace=zeros(2, ZDYCDS); %最优结果的初始值FieldD=[5;-1;2;1;0;1;1]; %定义区域描述器的各个参数%以下为遗传算法基本操作部分,包括创建初始种群、复制、交叉和变异Chrom=crtbp(GTSM, EJZWS); %创建初始种群,即生成给定规模的二进制种群和结构gen=0; %定义代数计数器初始值variable=bs2rv(Chrom, FieldD); %对生成的初始种群进行十进制转换ObjV=variable*variable; %计算目标函数值f(x)=x2 while gen<ZDYCDS %进行循环控制,当当前代数小于定义的最大遗传代数时,继续循环,直至代数等于最大遗传代数FitnV=ranking(-ObjV); %分配适应度值SelCh=select('sus', Chrom, FitnV, DG); %选择,即对个体按照他们的适配值进行复制SelCh=recombin('xovsp', SelCh, 0.7); %交叉,即首先将复制产生的匹配池中的成员随机两两匹配,再进行交叉繁殖SelCh=mut(SelCh); %变异,以一个很小的概率随机地改变一个个体串位的值variable=bs2rv(SelCh, FieldD); %子代个体的十进制转换ObjVSel=variable*variable; %计算子代的目标函数值[Chrom ObjV]=reins(Chrom, SelCh, 1, 1, ObjV, ObjVSel);%再插入子代的新种群,其中Chrom为包含当前种群个体的矩阵,SelCh为包好当前种群后代的矩阵variable=bs2rv(Chrom, FieldD); %十进制转换gen=gen+1; %代数计数器增加%输出最优解及其序号,并在目标函数图像中标出,Y为最优解, I为种群的%序号[Y, I]=max(ObjV);hold on; %求出其最大目标函数值plot(variable(I), Y, 'bo');trace(1, gen)=max(ObjV); %遗传算法性能跟踪trace(2, gen)=sum(ObjV)/length(ObjV);end%以下为结果显示部分,通过上面计算出的数值进行绘图variable=bs2rv(Chrom, FieldD); %最优个体进行十进制转换hold on, grid;plot(variable,ObjV,'b*'); %将结果画出三、运行结果:由图可见该函数为单调递增函数,即当X=31时,该取得最大值f(x)max =961。
遗传算法求函数极大值(matlab实现)
遗传算法求函数最大值(matlab实现)一、题目:寻找f(x)=x2,,当x在0~31区间的最大值。
二、源程序:%遗传算法求解函数最大值%本程序用到了英国谢菲尔德大学(Sheffield)开发的工具箱GATBX,该工具箱比matlab自带的GATOOL使用更加灵活,但在编写程序方面稍微复杂一些Close all;Clear all;figure(1);fplot('variable*variable',[0,31]); %画出函数曲线%以下定义遗传算法参数GTSM=40; %定义个体数目ZDYCDS=20; %定义最大遗传代数EJZWS=5; %定义变量的二进制位数DG=0.9; %定义代沟trace=zeros(2, ZDYCDS); %最优结果的初始值FieldD=[5;-1;2;1;0;1;1]; %定义区域描述器的各个参数%以下为遗传算法基本操作部分,包括创建初始种群、复制、交叉和变异Chrom=crtbp(GTSM, EJZWS); %创建初始种群,即生成给定规模的二进制种群和结构gen=0; %定义代数计数器初始值variable=bs2rv(Chrom, FieldD); %对生成的初始种群进行十进制转换ObjV=variable*variable; %计算目标函数值f(x)=x2 while gen<ZDYCDS %进行循环控制,当当前代数小于定义的最大遗传代数时,继续循环,直至代数等于最大遗传代数FitnV=ranking(-ObjV); %分配适应度值SelCh=select('sus', Chrom, FitnV, DG); %选择,即对个体按照他们的适配值进行复制SelCh=recombin('xovsp', SelCh, 0.7); %交叉,即首先将复制产生的匹配池中的成员随机两两匹配,再进行交叉繁殖SelCh=mut(SelCh); %变异,以一个很小的概率随机地改变一个个体串位的值variable=bs2rv(SelCh, FieldD); %子代个体的十进制转换ObjVSel=variable*variable; %计算子代的目标函数值[Chrom ObjV]=reins(Chrom, SelCh, 1, 1, ObjV, ObjVSel);%再插入子代的新种群,其中Chrom为包含当前种群个体的矩阵,SelCh为包好当前种群后代的矩阵variable=bs2rv(Chrom, FieldD); %十进制转换gen=gen+1; %代数计数器增加%输出最优解及其序号,并在目标函数图像中标出,Y为最优解,I 为种群的%序号[Y, I]=max(ObjV);hold on; %求出其最大目标函数值plot(variable(I), Y, 'bo');trace(1, gen)=max(ObjV); %遗传算法性能跟踪trace(2, gen)=sum(ObjV)/length(ObjV);end%以下为结果显示部分,通过上面计算出的数值进行绘图variable=bs2rv(Chrom, FieldD); %最优个体进行十进制转换hold on, grid;plot(variable,ObjV,'b*'); %将结果画出三、运行结果:由图可见该函数为单调递增函数,即当X=31时,该取得最大值f(x)max=961。
实验五:遗传算法求解函数最值问题实验
实验五:遗传算法求解函数最值问题实验实验五:遗传算法求解函数最值问题实验一、实验目的使用遗传算法求解函数f优y)=x*sin(6*y)+y*cos(8*x)在m及yDll的最大值。
使用遗传算法进行求解,篇末所附源代码中带有算法的详细注释。
算法中涉及不同的参数,参数的取值需要根据实际情况进行设定,F面运行时将给出不同参数的结果对比。
//参数constintN-2种群的个休数constintlen=30;每个个体的染色体的长度,xffiyS占一半constintcrossnum=4;交叉操作B孩点交叉曲支叉点个数constintmaxGeneration=19000;//最大进化代^constdoubleprobCross=9.85;//概率constdoubleprobMutation-15;//豈异IK率定义整体算法的结束条件为,当种群进化次数达到maxGeneration时停止,此时种群中的最优解即作为算法的最终输出。
//融饶for(intg=0jgmaxGeneration;g++)(设种群规模为N,首先是随机产生N个个体,实验中定义了类型Chromosome表示一个个体,并且在默认构造函数中即进行了随机的操作。
//初始化种群for(inti=0;iN;i++)grcup[i]=Chrcmc50me();实验内容然后程序进行若干次的迭代,在每次迭代过程中,进行选择、交叉及变异三个操作。
1选择操作首先计算当前每个个体的适应度函数值,这里的适应度函数即为所要求的优化函数,然后归一化求得每个个体选中的概率,然后用轮盘赌的方法以允许重复的方式选择选择N个个体,即为选择之后的群体。
//选择操作Elvoidselect(匚hromosoraegroup[mxn])计算每个个体的询?概率doublefitnessVal[mxn];for(inti=ii++)0;//使用轮蛊賭算法困环体doublerandNum=randoiT01();intj;for(j-B;jN-1;j++)if(randNump rab[j])selectld[i]*j;break;(jN-1)selectld[i]=j;//把种群更新为新选挥的个体集合for(inti=0;itemGroup[i]=g^oup[i]for(intift;igroup[i]=temOrc upfselectId[i]];但实验时发现结果不好,经过仔细研究之后发现,这里在取某些值的时候,目标函数计算出来的适应值可能会出现负值,这时如果按照把每个个体的适应值除以适应值的总和的进行归一化的话会出现问题,因为个体可能出现负值,总和也可能出现负值,如果归一化的时候除以了一个负值,选择时就会选择一些不良的个体,对实验结果造成影响。
遗传算法求多元函数的极值
遗传算法求多元函数的极值
遗传算法是一种基于生物进化理论的优化算法,可以用来求解多元函数的极值。
下面介绍遗传算法求解多元函数极值的基本流程:
确定目标函数:首先需要确定待优化的目标函数,将其转化为一个优化问题。
确定变量范围和初始种群:对于每个变量,需要确定其可行域范围,并生成一个随机的初始种群。
适应度函数的定义:根据目标函数确定适应度函数,并将其作为评估个体优劣的标准。
选择操作:选择操作是遗传算法的核心,通过适应度函数选择个体,以保留优良个体。
遗传操作:包括交叉和变异两种操作。
交叉操作是指将两个个体的染色体部分进行交换,从而产生新个体;变异操作是指对某个个体的染色体部分进行随机变换,从而产生新个体。
繁殖新种群:通过选择和遗传操作,生成新的种群,并根据适应度函数进行排序。
判断停止条件:根据实际情况设定停止条件,如达到最大迭代次数、收敛到一定程度等。
输出结果:在满足停止条件后,输出当前最优解和最优适应度值。
需要注意的是,遗传算法求解多元函数极值需要根据实际情况调整参数和优化算法流程,以达到最优结果。
遗传算法求函数极值
遗传算法求函数极值遗传算法是一种基于模拟生物进化过程的优化算法,它通过模拟生物的进化过程中的遗传、交叉和变异等操作,对问题的解空间进行,并到满足最优条件的解。
它被广泛应用于求解各种复杂问题,包括函数极值问题。
在使用遗传算法求函数极值的过程中,首先需要明确问题的目标函数。
目标函数是一个将自变量映射到一个实数值的函数,它描述了问题的优化目标。
例如,我们可以考虑一个简单的目标函数f(x),其中x表示自变量,f(x)表示因变量。
遗传算法的基本流程如下:1.初始化种群:随机生成一组初始解,也就是种群。
种群中的每个个体都是一个可能的问题解,而个体中的染色体则表示了问题解的具体数值。
2.适应度评估:对于种群中的每个个体,通过计算目标函数的值,评估每个个体的适应度。
适应度越高的个体,越有可能成为下一代个体的基因。
3.选择操作:根据个体的适应度,选择一些个体作为下一代遗传操作的基因。
4.交叉操作:从选择出的个体中随机选择一对个体,进行交叉操作。
交叉操作通过交换两个个体的染色体信息,产生新的个体。
5.变异操作:对交叉操作生成的新个体进行变异操作。
变异操作通过改变个体染色体中的部分基因,引入新的解,以增加问题解的多样性。
6.新种群产生:基于交叉和变异操作,生成新的种群。
7.终止条件判断:如果满足终止条件(例如达到最大迭代次数、找到了满足要求的解等),则停止算法;否则,返回第2步。
通过以上步骤的循环迭代,遗传算法可以到问题的最优解,即函数的极值。
由于遗传算法充分利用了进化算法的生物特点,具有全局能力和自适应优化能力,因此在函数极值求解中得到了广泛的应用。
遗传算法的关键在于如何进行适应度评估、选择操作、交叉操作和变异操作。
适应度评估是指根据目标函数计算个体的适应度值,一般情况下适应度越高的个体越有可能成为下一代的基因。
选择操作可以采用轮盘赌选择、最优选择等方式,根据个体的适应度选择一定数量的个体进行交叉和变异。
交叉操作通过交换染色体信息,产生新的个体;变异操作通过改变个体染色体中的部分基因,引入新的解。
遗传算法求解函数极值C语言代码
#include "stdio.h"#include "stdlib.h"#include "conio.h"#include "math.h"#include "time.h"#define num_C 12 //个体的个数,前6位表示x1,后6位表示x2 #define N 100 //群体规模为100#define pc 0.9 //交叉概率为0.9#define pm 0.1 //变异概率为10%#define ps 0.6 //进行选择时保留的比例#define genmax 2000 //最大代数200int RandomInteger(int low,int high);void Initial_gen(struct unit group[N]);void Sort(struct unit group[N]);void Copy_unit(struct unit *p1,struct unit *p2);void Cross(struct unit *p3,struct unit *p4);void Varation(struct unit group[N],int i);void Evolution(struct unit group[N]);float Calculate_cost(struct unit *p);void Print_optimum(struct unit group[N],int k);/* 定义个体信息*/typedef struct unit{int path[num_C]; //每个个体的信息double cost; //个体代价值};struct unit group[N]; //种群变量groupint num_gen=0; //记录当前达到第几代int main(){int i,j;srand((int)time(NULL)); //初始化随机数发生器Initial_gen(group); //初始化种群Evolution(group); //进化:选择、交叉、变异getch();return 0;}/* 初始化种群*/void Initial_gen(struct unit group[N]){int i,j;struct unit *p;for(i=0;i<=N-1;i++) //初始化种群里的100个个体{p=&group[i]; //p指向种群的第i个个体for(j=0;j<12;j++){p->path[j]=RandomInteger(0,9); //end }Calculate_cost(p); //计算该种群的函数值}//end 初始化种群}/* 种群进化,进化代数由genmax决定*/void Evolution(struct unit group[N]){int i,j;int temp1,temp2,temp3,temp4,temp5;temp1=N*pc/2;temp2=N*(1-pc);temp3=N*(1-pc/2);temp4=N*(1-ps);temp5=N*ps;for(i=1;i<=genmax;i++){//选择for(j=0;j<=temp4-1;j++){ Copy_unit(&group[j],&group[j+temp5]); }//交叉for(j=0;j<=temp1-1;){Cross(&group[temp2+j],&group[temp3+j]);j+=2;}//变异Varation(group,i);}Sort(group);Print_optimum(group,i-1); //输出当代(第i-1代)种群}/* 交叉*/void Cross(struct unit *p3,struct unit *p4){int i,j,cross_point;int son1[num_C],son2[num_C];for(i=0;i<=num_C-1;i++) //初始化son1、son2{son1[i]=-1;son2[i]=-1;}cross_point=RandomInteger(1,num_C-1); //交叉位随机生成//交叉,生成子代//子代1//子代1前半部分直接从父代复制for(i=0;i<=cross_point-1;i++) son1[i]=p3->path[i];for(i=cross_point;i<=num_C-1;i++)for(j=0;j<=num_C-1;j++) //补全p1{son1[i]=p4->path[j];}//end 子代1//子代2//子代1后半部分直接从父代复制for(i=cross_point;i<=num_C-1;i++) son2[i]=p4->path[i];for(i=0;i<=cross_point-1;i++){for(j=0;j<=num_C-1;j++) //补全p1{son2[i]=p3->path[j];}}//end 子代2//end 交叉for(i=0;i<=num_C-1;i++){p3->path[i]=son1[i];p4->path[i]=son2[i];}Calculate_cost(p3); //计算子代p1的函数值Calculate_cost(p4); //计算子代p2的函数值}/* 变异*/void Varation(struct unit group[N],int flag_v){int flag,i,j,k,temp;struct unit *p;flag=RandomInteger(1,100);//在进化后期,增大变异概率if((!flag>(flag_v>100))?(5*100*pm):(100*pm)){i=RandomInteger(0,N-1); //确定发生变异的个体j=RandomInteger(0,num_C-1); //确定发生变异的位k=RandomInteger(0,num_C-1);p=&group[i]; //变异temp=p->path[j];p->path[j]=p->path[k];p->path[k]=temp;Calculate_cost(p); //重新计算变异后的函数值}}/* 将种群中个体按函数值从小到大排序*/void Sort(struct unit group[N]){int i,j;struct unit temp,*p1,*p2;for(j=1;j<=N-1;j++) //排序总共需进行N-1轮{for(i=1;i<=N-1;i++){p1=&group[i-1];p2=&group[i];if(p1->cost>p2->cost) //值大的往后排{Copy_unit(p1,&temp);Copy_unit(p2,p1);Copy_unit(&temp,p2);}}//end 一轮排序}//end 排序}/* 计算某个个体的函数值*/float Calculate_cost(struct unit *p){double x1,x2;x1=0;if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){x1=0-(p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001);}x2=0;if(p->path[6]>5){}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}p->cost=20+x1*x1+x2*x2-10*(cos(2*3.14*x1)+cos(2*3.14*x2));return(p->cost);}/* 复制种群中的p1到p2中*/void Copy_unit(struct unit *p1,struct unit *p2){int i;for(i=0;i<=num_C-1;i++)p2->path[i]=p1->path[i];p2->cost=p1->cost;}/* 生成一个介于两整型数之间的随机整数*/int RandomInteger(int low,int high){int k;double d;k=rand();k=(k!=RAND_MAX)?k:(k-1); //RAND_MAX是VC中可表示的最大整型数d=(double)k/((double)(RAND_MAX));k=(int)(d*(high-low+1));return (low+k);}/* 输出当代种群中的最优个体*/void Print_optimum(struct unit group[N],int k){struct unit *p;double x1,x2;x1=x2=0;p=&group[0];if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){}x2=0;if(p->path[6]>5){x2=p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001;}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}printf(" 当x1=%f x2=%f\n",x1,x2);printf(" 函数最小值为:%f \n",p->cost);}。
计算机遗传算法求极值问题
B[i] = cl.ff(x[i]);//求出f(x)=x^2的值存入B中
sum += B[i];
}
for(inti = 0; i < 4; i++)
{
C[i] = B[i] / sum;
}
max =cl.Max(x);
min = cl.Min(x);
t2 = x[max];//用来记录每次循环的最大值
A[max] = A[max].Substring(0, k1) + s3;
A[min] = A[min].Substring(0, k2) + s4;
A[3 - max] = A[3 - max].Substring(0,k1) + s1;
A[3 - min] = A[3 - min].Substring(0,k2) + s2;
strings4 = A[3].Substring(k2);
A[max] = A[max].Substring(0,k1) + s3;
A[min] = A[min].Substring(0,k2) + s4;
A[0] = A[0].Substring(0,k1) + s1;
System.Console.Write(' ');
}
System.Console.Write("\n");//换行
A[min] = A[max];//适配值较小的被淘汰,由最大的取代
k1 = a.Next(1,4);//从1-4之间选一个随机数
k2 =a.Next(1,4);
if(max + min != 3)
for(intl = 1; l < smax; l++)
遗传算法求复杂函数极值问题
遗传算法求复杂函数极值问题中文摘要:本文首先介绍遗传算法的历史背景,基本思想,对遗传算法的常见的编码解码方法进行了深入的阐述,并对算子选择方法进行深入分析和对比,在此基础上把遗传算法应用于求解复杂函数的极值计算。
最后在MATLAB语言环境下编写程序,对求解函数的最大值进行了仿真,并对调试的结果进行了分析,得出了部分结论。
关键词:遗传算法最优解算子选择复杂函数作者:xx xx指导老师:xxxx xxUsing Genetic Algorithm to Solve Extreme Problemof Complex FunctionAbstractFirstly,the historical background and basic idea of genetic algorithm are introduced in this paper. The common coding and decoding method of genetic algorithm are discussed too.Secondly, the selection method of genetic operator is analyzed and compared deeply, based on which genetic algorithm is used to solve extreme problem of complex function.Finally, with MATLAB software, the program is compiled and the maximum is sought out. At the end of the paper, the debugging result is analyzed and the conclusion is given.Keywords: Genetic Algorithm Optimal Solution Operator Selection Complex FunctionWritten by : xx xxSupervised by: xxxx xx目录第一章绪论 (5)1.1 遗传算法生物学背景 (5)1.1.1 遗传与变异 (5)1.1.2 进化 (5)1.2 本文主要内容 (5)第二章遗传算法简介 (6)2.1 遗传算法历史和发展 (6)2.2 遗传算法的基本原理 (6)2.3 遗传算法的特点 (7)2.4 遗传算法的目的 (7)2.5 遗传算法应用 (8)第三章遗传算法的参数和算子选择 (10)3.1 遗传算法的数学理论 (10)3.2 编码 (11)3.2.1 编码方法 (11)3.2.2 编码原则 (13)3.3 个体适应度函数 (13)3.3.1 评价个体适应 (13)3.2.2 适应度尺度变换 (14)3.3 算子选择 (14)3.3.1 选择运算 (14)3.3.2 交叉运算 (16)3.3.3 变异运算 (18)3.4 其他运行参数 (18)第四章遗传算法求解复杂函数极值问题 (20)4.1 遗传算法的求解步骤 (20)4.2 算例验证 (24)第五章结论 (28)参考文献 (28)附录(程序) (29)第一章绪论1.1遗传算法生物学背景生物的进化是一个奇妙的优化过程,它通过选择淘汰,突然变异,基因遗传等规律产生适应环境变化的优良物种。
人工智能遗传算法求函数极值
实验目的与原理1)目的熟悉和掌握遗传算法的原理、流程和编码策略,并利用遗传求解函数优化问题,理解求解函数极值问题的流程并测试主要参数对结果的影响,掌握遗传算法的基本实现方法。
2)原理遗传算法的基本思想正是基于模仿生物界遗传学的遗传过程。
它把问题的参数用基因代表,把问题的解用染色体代表(在计算机里用二进制码表示),从而得到一个由具有不同染色体的个体组成的群体。
这个群体在问题特定的环境里生存竞争,适者有最好的机会生存和产生后代。
后代随机化地继承了父代的最好特征,并也在生存环境的控制支配下继续这一过程。
群体的染色体都将逐渐适应环境,不断进化,最后收敛到一族最适应环境的类似个体,即得到问题最优的解。
要求利用遗传算法求解函数极值问题。
1、实验内容及条件(1)实验内容利用“智能搜索算法实验系统”中的“遗传算法工具箱”求解下列函数极值(2)实验流程图如2-1所示:图2-1(3)实验条件智能搜索算法教学实验系统3、实验步骤(1)打开软件进入主界面,选择遗传算法,界面如图3-1所示:图3-1(2)选择本次实验所涉及的最值问题,界面如图3-2所示:图3-2(3)点击开始按钮,利用的是轮盘赌选择个体方法,产生一个随机数,它落入转盘的哪个区域就选择相应的个体交叉,根据公式自主选择变量进行调试:a.根据极值算法公式,交叉率选择“0.85”,变异率选择“0.05”,概率分配选择“适应度比例法”,变异方法选择“每位都按Pm进行变异”,随即开始实验,点击计算选择概率,界面如图3-3所示:图3-3首先利用适应度函数计算每个染色体的适应度值。
适应度函数是由目标函数变换而来的,前四位是x染色体后四位是y染色体。
轮盘是根据轮盘赌选择方法,根据个体的选择概率产生的,轮盘上每个区域的角度跟个体的选择概率成比例,然后随即产生一个随机数,它落到哪个区域,就代表着哪个区域的个体进行交叉操作。
b.点击选择按钮,对个体进行选择,如图3-4所示:图3-4选择也叫复制,它是对群体中一些优良的基因进行选择,保证子代基因的优良。
python实现遗传算法求函数最大值(人工智能作业)
python实现遗传算法求函数最⼤值(⼈⼯智能作业)题⽬:⽤遗传算法求函数f(a,b)=2a x sin(8PI x b) + b x cos(13PI x a)最⼤值,a:[-3,7],b:[-4:10]实现步骤:初始化种群计算种群中每个个体的适应值淘汰部分个体(这⾥是求最⼤值,f值存在正值,所以淘汰所有负值)轮盘算法对种群进⾏选择进⾏交配、变异,交叉点、变异点随机分析:为了⽅便,先将⾃变量范围调整为[0,10]、[0,14]有两个变量,种群中每个个体⽤⼀个列表表⽰,两个列表项,每项是⼀个⼆进制字符串(分别由a、b转化⽽来)种群之间交配时需要确定交叉点,先将个体染⾊体中的两个⼆进制字符串拼接,再确定⼀个随机数作为交叉点为了程序的数据每⼀步都⽐较清晰正确,我在select、crossover、mutation之后分别都进⾏了⼀次适应值的重新计算具体代码:import mathimport randomdef sum(list):total = 0.0for line in list:total += linereturn totaldef rand(a, b):number = random.uniform(a,b)return math.floor(number*100)/100PI = math.pidef fitness(x1,x2):return 2*(x1-3)*math.sin(8*PI*x2)+(x2-4)*math.cos(13*PI*x1)def todecimal(str):parta = str[0:4]partb = str[4:]numerical = int(parta,2)partb = partb[::-1]for i in range(len(partb)):numerical += int(partb[i])*math.pow(0.5,(i+1))return numericaldef tobinarystring(numerical):numa = math.floor(numerical)numb = numerical - numabina = bin(numa)bina = bina[2:]result = "0"*(4-len(bina))result += binafor i in range(7):numb *= 2result += str(math.floor(numb))numb = numb - math.floor(numb)return resultclass Population:def __init__(self):self.pop_size = 500 # 设定种群个体数为500self.population = [[]] # 种群个体的⼆进制字符串集合,每个个体的字符串由⼀个列表组成[x1,x2]self.individual_fitness = [] # 种群个体的适应度集合self.chrom_length = 22 # ⼀个染⾊体22位self.results = [[]] # 记录每⼀代最优个体,是⼀个三元组(value,x1_str,x2_str)self.pc = 0.6 # 交配概率self.pm = 0.01 # 变异概率self.distribution = [] # ⽤于种群选择时的轮盘def initial(self):for i in range(self.pop_size):x1 = rand(0,10)x2 = rand(0,14)x1_str = tobinarystring(x1)x2_str = tobinarystring(x2)self.population.append([x1_str,x2_str]) # 添加⼀个个体fitness_value = fitness(x1,x2)self.individual_fitness.append(fitness_value) # 记录该个体的适应度self.population = self.population[1:]self.results = self.results[1:]def eliminate(self):for i in range(self.pop_size):if self.individual_fitness[i]<0:self.individual_fitness[i] = 0.0def getbest(self):"取得当前种群中的⼀个最有个体加⼊results集合"index = self.individual_fitness.index(max(self.individual_fitness))x1_str = self.population[index][0]x2_str = self.population[index][1]value = self.individual_fitness[index]self.results.append((value,x1_str,x2_str,))def select(self):"轮盘算法,⽤随机数做个体选择,选择之后会更新individual_fitness对应的数值""第⼀步先要初始化轮盘""选出新种群之后更新individual_fitness"total = sum(self.individual_fitness)begin = 0for i in range(self.pop_size):temp = self.individual_fitness[i]/total+beginself.distribution.append(temp)begin = tempnew_population = []new_individual_fitness = []for i in range(self.pop_size):num = random.random() # ⽣成⼀个0~1之间的浮点数j = 0for j in range(self.pop_size):if self.distribution[j]<num:continueelse:breakindex = j if j!=0 else (self.pop_size-1)new_population.append(self.population[index])new_individual_fitness.append(self.individual_fitness[index])self.population = new_populationself.individual_fitness = new_individual_fitnessdef crossover(self):"选择好新种群之后要进⾏交配""注意这只是⼀次种群交配,种群每⼀次交配过程,会让每两个相邻的染⾊体进⾏信息交配"for i in range(self.pop_size-1):if random.random()<self.pc:cross_position = random.randint(1,self.chrom_length-1)i_x1x2_str = self.population[i][0]+self.population[i][1] # 拼接起第i个染⾊体的两个⼆进制字符串i1_x1x2_str = self.population[i+1][0]+self.population[i+1][1] # 拼接起第i+1个染⾊体的两个⼆进制字符串 str1_part1 = i_x1x2_str[:cross_position]str1_part2 = i_x1x2_str[cross_position:]str2_part1 = i1_x1x2_str[:cross_position]str2_part2 = i1_x1x2_str[cross_position:]str1 = str1_part1+str2_part2str2 = str2_part1+str1_part2self.population[i] = [str1[:11],str1[11:]]self.population[i+1] = [str2[:11],str2[11:]]"然后更新individual_fitness"for i in range(self.pop_size):x1_str = self.population[i][0]x2_str = self.population[i][1]x1 = todecimal(x1_str)x2 = todecimal(x2_str)self.individual_fitness[i] = fitness(x1,x2)def mutation(self):"个体基因变异"for i in range(self.pop_size):if random.random()<self.pm:x1x2_str = self.population[i][0]+self.population[i][1]pos = random.randint(0,self.chrom_length-1)bit = "1" if x1x2_str[pos]=="0" else "0"x1x2_str = x1x2_str[:pos]+bit+x1x2_str[pos+1:]self.population[i][0] = x1x2_str[:11]self.population[i][1] = x1x2_str[11:]"然后更新individual_fitness"for i in range(self.pop_size):x1_str = self.population[i][0]x2_str = self.population[i][1]x1 = todecimal(x1_str)x2 = todecimal(x2_str)self.individual_fitness[i] = fitness(x1, x2)def solving(self,times):"进⾏times次数的整个种群交配变异""先获得初代的最优个体"self.getbest()for i in range(times):"每⼀代的染⾊体个体和适应值,需要先淘汰,然后选择,再交配、变异,最后获取最优个体。
遗传算法求函数最值
{
char chrom[30];//定义染色体长度数组,留有余地,真实长度由构造函数完成
double value; //函数值
double fitness; //适应度
};
class Genetic
{
public:
int popsize;//种群规模
int maxgeneration;//最大世代数
Genetic(int popsizeout,int maxgenerationout,double pcout,double pmout,double Xfirst,double Xend,int chromlengthout,int functionmode=1);//带参数的构造函数
~Genetic();//析构函数
void PerformEvolution(); //演示评价结果
void SelectOperator(); //比例选择算法
void CrossoverOperator(); //交叉算法
void MutationOperator();//变异算法
void OutputReport(); //数据输出
}
else
{
temp=0.0;
}
}
else if (functionmode==0)
{
if(population[i].value<cmax)
{
temp=cmax-population[i].value;
}
else{ temp=0.0;}
}
population[i].fitness=temp;
}
}
///////////////////////////////////////////////////////////////////////////////
遗传算法求四元函数极值
遗传算法求四元函数极值遗传算法是一种启发式搜索算法,可以用来求解函数的极值问题。
对于四元函数,我们可以采用以下步骤来求解其极值:1.确定变量范围:对于四元函数,我们需要确定每个变量的取值范围。
2.初始化种群:以随机方式生成一组初始解作为种群的第一代。
3.评价适应度:根据目标函数的值,评价每个个体的适应度。
4.选择交叉操作:从种群中选择适应度较高的个体,并对它们进行交叉操作,生成新的个体。
5.变异操作:对于一部分个体,进行变异操作,以增加种群的多样性。
6.更新种群:将新生成的个体加入到种群中,并淘汰适应度较低的个体。
7.检查终止条件:如果达到了预设的终止条件,算法停止;否则,继续进行第3步。
可以通过多次迭代,不断优化种群中的个体,直到得到满意的极值或达到最大迭代次数为止。
对于四元函数极值问题,考虑以下四元函数:f(x1,x2,x3,x4)=x1^2+x2^2+x3^2+x4^2。
假设变量范围均在[-5,5]之间,则可以采用以下Python代码来实现遗传算法求解极值:``` python。
import numpy as np。
def fitness(x):。
return sum(x**2)。
def selection(population, fitness):。
idx = np.random.choice(len(population), size=len(population), replace=True, p=fitness/fitness.sum())。
return population[idx]。
def crossover(parents, p_crossover=0.9):。
offspring = np.empty_like(parents)。
for i in range(len(parents)//2):。
p1, p2 = parents[2*i], parents[2*i+1]。
if np.random.rand() < p_crossover:。
实验五:遗传算法求解函数最值问题实验
实验五:遗传算法求解函数最值问题实验一、实验目的使用遗传算法求解函数在及y的最大值。
二、实验内容使用遗传算法进行求解,篇末所附源代码中带有算法的详细注释。
算法中涉及不同的参数,参数的取值需要根据实际情况进行设定,下面运行时将给出不同参数的结果对比。
定义整体算法的结束条件为,当种群进化次数达到maxGeneration时停止,此时种群中的最优解即作为算法的最终输出。
设种群规模为N,首先是随机产生N个个体,实验中定义了类型Chromosome表示一个个体,并且在默认构造函数中即进行了随机的操作。
然后程序进行若干次的迭代,在每次迭代过程中,进行选择、交叉及变异三个操作。
1.选择操作首先计算当前每个个体的适应度函数值,这里的适应度函数即为所要求的优化函数,然后归一化求得每个个体选中的概率,然后用轮盘赌的方法以允许重复的方式选择选择N个个体,即为选择之后的群体。
但实验时发现结果不好,经过仔细研究之后发现,这里在x、y 取某些值的时候,目标函数计算出来的适应值可能会出现负值,这时如果按照把每个个体的适应值除以适应值的总和的进行归一化的话会出现问题,因为个体可能出现负值,总和也可能出现负值,如果归一化的时候除以了一个负值,选择时就会选择一些不良的个体,对实验结果造成影响。
对于这个问题,我把适应度函数定为目标函数的函数值加一个正数,保证得到的适应值为正数,然后再进行一般的归一化和选择的操作。
实验结果表明,之前的实验结果很不稳定,修正后的结果比较稳定,趋于最大值。
2.交叉操作首先是根据交叉概率probCross选择要交叉的个体进行交叉。
这里根据交叉参数crossnum进行多点交叉,首先随机生成交叉点位置,允许交叉点重合,两个重合的交叉点效果互相抵消,相当于没有交叉点,然后根据交叉点进行交叉操作,得到新的个体。
3.变异操作首先是根据变异概率probMutation选择要变异的个体。
变异时先随机生成变异的位置,然后把改位的01值翻转。
二进制编码遗传算法求函数极大值
二进制编码遗传算法求函数极大值二进制编码遗传算法是一种用于求解函数极大值的优化方法。
通过将函数的自变量编码为二进制字符串,然后利用遗传算法进行搜索,以找到函数的极大值。
下面是详细步骤:1. 确定问题:首先,明确需要求解的函数以及自变量的取值范围。
例如,假设我们要寻找函数f(x) = x^2 + 3x - 2在[0, 10]范围内的最大值。
2. 二进制编码:将自变量x的取值范围划分为若干个区间,然后用二进制字符串表示每个区间。
例如,如果将区间[0, 10]划分为5个区间,那么二进制编码的长度为log2(5) = 3。
3. 构建初始种群:根据二进制编码规则,生成一定数量的初始个体。
每个个体表示一个可能的解。
例如,生成10个个体。
4. 评估适应度:将每个个体解码为自变量x,计算对应的函数值f(x)。
然后,根据函数值计算每个个体的适应度。
适应度越高,表示个体对应的解越有可能为极大值。
5. 选择操作:采用轮盘赌选择法等策略,从当前种群中选择一部分优秀个体作为父代,用于产生下一代。
6. 交叉操作:对选定的父代个体进行交叉,生成一定数量的子代。
交叉操作可以采用单点交叉、多点交叉等方法。
7. 变异操作:对子代个体进行变异,即随机改变某些位上的二进制值。
变异操作有助于保持种群的多样性。
8. 更新种群:根据新的个体适应度重新构建种群。
9. 终止条件:当满足终止条件(如达到最大遗传代数、找到满足精度要求的极大值等)时,算法结束。
10. 结果输出:输出找到的极大值以及对应的自变量值。
通过以上步骤,二进制编码遗传算法可以用于求解函数的极大值。
需要注意的是,二进制编码遗传算法的性能受到种群数量、编码长度、交叉率、变异率等因素的影响,需要根据实际情况调整参数。
利用遗传算法求函数的极小值
1、利用遗传算法求出下面函数的极小值:z=2-exp[-(x2+y2)], x,y∈[-5,+5]对于此函数,求某一极值、或说最值时,由于x、y定义域与系数相同,x与y相对于z 来说是地位等同的,因此可以转换成求该函数极值:;继而转换成了一种单变量函数。
函数的实现:(1)ga_main脚本文件% GA main program% Edited by Bian Xuezi% n ---- 种群规模% ger ---- 迭代次数% pc ---- 交叉概率% pm ---- 变异概率% v ---- 初始种群(规模为n)% f ---- 目标函数值% fit ---- 适应度向量% vx ---- 最优适应度值向量% vmfit ---- 平均适应度值向量clear all;close all;clc;tic;n=20;ger=100;pc=0.70;pm=0.009;% 生成初始种群v=init_population(n,20);[N,L]=size(v);disp(sprintf('Number of generations:%d',ger)); disp(sprintf('Population size:%d',N));disp(sprintf('Crossover probability:%.3f',pc)); disp(sprintf('Mutation probability:%.3f',pm)); % 待优化问题xmin=-5;ymin=-5;xmax=5;ymax=5;f='-2+exp(-x.^2-y.^2)';%初始化sol=0.1;vmfit=[];it=1;vx=[];%C=[];% 计算适应度,并画出图形x=decode(v(:,1:10),xmin,xmax);y=decode(v(:,11:20),ymin,ymax);fit=eval(f);figure(1);[X,Y]=meshgrid(-5:0.1:5,-5:0.1:5);Z=-2+exp(-X.^2-Y.^2);mesh(X,Y,Z);grid on;hold on;plot3(x,y,fit,'k*');title('染色体的初始位置');xlabel('x');ylabel('y');zlabel('f(x,y)');% 开始进化while it<=ger%Reproduction(Bi-classist Selection) vtemp=roulette(v,fit);%Crossoverv=crossover(vtemp,pc);%MutationM=rand(N,L)<=pm;%M(1,:)=zeros(1,L);v=v-2.*(v.*M)+M;%Resultsx=decode(v(:,1:10),xmin,xmax);y=decode(v(:,11:20),ymin,ymax);fit=eval(f);[sol,indb]=max(fit);v(1,:)=v(indb,:);media=mean(fit);vx=[vx sol];vmfit=[vmfit media];it=it+1;end%%%% 最后的结果disp(sprintf('\n')); %空一行% 显示最优解及最优值disp(sprintf('Maximum found[x,f(x)]:[%.4f,%.4f,%.4f]',x(indb),y(indb),sol)); % 图形显示最优结果figure(2);[X,Y]=meshgrid(-5:0.1:5,-5:0.1:5);Z=-2+exp(-X.^2-Y.^2);mesh(X,Y,Z);grid on;hold on;plot3(x,y,fit,'k*');title('染色体的最终位置');xlabel('x');ylabel('y');zlabel('f(x,y)');% 图形显示最优及平均函数值变化趋势figure(3);plot(vx);%title('最优,平均函数值变化趋势'); xlabel('Generations');ylabel('f(x,y)');hold on;plot(vmfit,'r');hold off;runtime=toc(2)Crossover函数%Crossoverfunction v=crossover(vtemp,pc) [N,L]=size(vtemp);C(:,1)=rand(N,1)<=pc;I=find(C(:,1)==1);I';j=1;for i=1:2:size(I)if i>=size(I)break;endsite=fix(1+L*rand(1));temp=vtemp(I(i,1),:);vtemp(I(i,1),site:end)=vtemp(I(i+1,1),site:end); vtemp(I(i+1,1),site:end)=temp(:,site:end);%j=j+2;endv=vtemp;(3)decode函数%Decodify bitstringsfunction x=decode(v,min,max)% x ----真实值% v ----待解码的已编码的0-1串v=fliplr(v);[s,c]=size(v);aux=0:1:c-1 ;%21;aux=ones(s(1),1)*aux;x1=sum((v.*2.^aux)');x=min+(max-min)*x1./(2^c-1); % ; (4)init_population函数function v=init_population(n1,s1)v=round(rand(n1,s1));(5)roulette函数function vtemp=roulette(v,fit)N=size(v);fitmin=abs(min(fit));fit=fitmin+fit;%fitS=sum(fit);for i=1:NSI=S*rand(1);for j=1:Nif SI<=sum(fit(1:j))vtemp(i,:)=v(j,:);breakendendend。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
智能优化算法第一次作业--------------遗传算法洪文杰 S151000853 问题:用遗传算法求解f(x)=xsin(10π*x)+2.0的最大值,x取[-1,2].一、分析:遗传算法基本思路二、实例简介1. 产生初始种群s1= 13 (01101)s2= 24 (11000)s3= 8 (01000)s4= 19 (10011)2. 计算适应度假定适应度为f(s)=s^2 ,则f (s1) = f(13) = 13^2 = 169 f (s2) = f(24) = 24^2 = 576 f (s3) = f(8) = 8^2 = 64f (s4) = f(19) = 19^2 = 3613.选择染色体的选择概率为:染色体的累计概率为:根据上面的式子,可得到:例如设从区间[0, 1]中产生4个随机数: r1 = 0.450126, r2 = 0.110347r3 = 0.572496, r4 = 0.985034. 交叉基本遗传算法(SGA)中交叉算子采用单点交叉算子。
单点交叉运算5.变异6.至下一代,适应度计算→选择→交叉→变异,直至满足终止条件三、解决问题四、实验结果源代码:/*问题:用遗传算法求解f(x)=xsin(10π*x)+2.0的最大值,x取[-1,2].*/ /*洪文杰 2016-3-9. 智能优化算法第一次作业*/#include<iostream>//#includ<stdio.h>#include<stdlib.h>#include<math.h>#include<time.h>#include<float.h>using namespace std;#define NUMBER 50//种群规模#define GENE_NUMBER 10000//迭代次数int Unit[NUMBER][30];//初始种群int Unit_choose[NUMBER][30];//选择、交叉、变异后的种群int Number[NUMBER];//被选择的个体编号float Fitness[NUMBER];//适应度float select_probability[NUMBER];//选择概率float accumula_probability[NUMBER] ;//积累概率float f_max=0.0;//最大值float f_x=0.0;//最大值对应的自变量int hwj_coding(int start,int end);//编码void hwj_initial_population(int num);//产生初始种群void hwj_fitness(int num);//适应度计算void hwj_choose();//选择个体int hwj_binary_search(int l, int r,float temp);//查找选择//void hwj_N_M(int a[],int b[],int N, int M);//从M个数中选N个不一样的数void hwj_cross(int num,float cross);//交叉后的得到种群void hwj_aberrance(int num,float aberrance);//变异后的得到的种群void hwj_max(int num);//找到最适应的个体int main(){int strat,end;//区间int Num;//编码大小float cross=0.8;//交叉概率float aberrance = 0.04;//变异概率int key=1;cout<<"请输入求解区间:"<<endl;cin>>strat>>end;Num=hwj_coding(strat,end);cout<<"Num:"<<Num<<endl;// cout<<"--------------------------1-----------------"<<endl;hwj_initial_population(Num);// cout<<"--------------------------2初始种群-----------------"<<endl;/* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/while(key!=GENE_NUMBER){hwj_fitness(Num);// cout<<"--------------------------3适应度-----------------"<<endl;// for(int i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;// }hwj_choose();// cout<<"--------------------------4被选择的个体-----------------"<<endl; /* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit_choose[i][j]<<' ';}cout<<endl;}*/hwj_cross(Num,cross);/* cout<<"--------------------------5交叉后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/hwj_aberrance(Num,aberrance);/* cout<<"--------------------------6变异后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/key++;hwj_max(Num);}cout<<"最大值是对应的x值是:"<<endl;cout<<f_x<<endl;cout<<"最大值为:"<<f_max<<endl;return 0;}int hwj_coding(int start,int end){//种群编码float precision;int temp=2;int sum;int N=1;cout<<"请输入精度范围:"<<endl;cin>>precision;if(precision==0){cout<<"对不起精度不能为零:"<<endl;return 0;}else{sum=(end-start)/precision;cout<<"sum:"<<sum<<endl;while(temp<sum){temp*=2;N++;}return N;}}void hwj_initial_population(int num){//生成初始种群srand(time(NULL));for(int i=0;i<NUMBER;i++){for(int j=0;j<num;j++){Unit[i][j]=rand()%2;}}}void hwj_fitness(int num){//计算适应度float sum;int temp;for(int i=0;i<NUMBER;i++){temp=1;sum=0.0;for(int j=num-1;j>=0;j--){sum+=Unit[i][j]*temp;temp*=2.0;}Fitness[i]=sum*3/(temp-1.0)-1.0;// cout<<Fitness[i];// cout<<"--------------+++++";Fitness[i]=Fitness[i]*sin(10*3.1415926*Fitness[i])+2.0;// cout<<Fitness[i]<<endl;}}int hwj_binary_search(int l,int r,float temp){for(int i=0;i<NUMBER;i++){if(temp<=accumula_probability[i]&&temp>accumula_probability[i-1]){ return i;}}return -1;}void hwj_choose(){//选择个体float sum=0.0;float temp;int i;for(i=0;i<NUMBER;i++){sum+=Fitness[i];}select_probability[0]=Fitness[0]/sum;temp=accumula_probability[0]=select_probability[0];for(i=1;i<NUMBER;i++){select_probability[i]=Fitness[i]/sum;temp+=select_probability[i];accumula_probability[i]=temp;// cout<<accumula_probability[i]<<endl;}for(i=0;i<NUMBER;i++){// srand(time(NULL));temp=(rand()%1000000)/1000000.0;// cout<<temp;Number[i]=hwj_binary_search(0,NUMBER,temp);// cout<<Number[i]<<endl;for(int j=0;j<NUMBER;j++){Unit_choose[i][j]=Unit[Number[i]][j];}}}/*void hwj_N_M(int a[],int b[],int N,int M){//从M个数中选N个不一样的数 int i=1;srand(time(NULL));a[0]=rand()%M;b[a[0]]=1;while(i!=N){a[i]=rand()%M;if(b[a[i]]==0){i++;b[a[i]]=1;cout<<a[i]<<endl;}}// cout<<a[i]<<' '<<b[a[i]]<<endl;}*/void hwj_cross(int num,float cross){//交叉后的得到种群int num_cross=NUMBER*cross;int k;//交叉点int i , j;if(num_cross%2!=0){num_cross=num_cross+1;}//需要交叉的个体数int cro[NUMBER];//被交叉的个体编号int temp[NUMBER];//是否交叉数组一览for(i=0;i<NUMBER;i++){cro[i]=-1;temp[i]=0;}// hwj_N_M(cro,temp,num_cross,NUMBER);srand(time(NULL));cro[0]=rand()%NUMBER;temp[cro[0]]=1;i=1;while(i!=num_cross){cro[i]=rand()%NUMBER;if(temp[cro[i]]==0){temp[cro[i]]=1;i++;}}// for(int i=0;i<NUMBER;i++){// cout<<temp[i]<<" "<<cro[i]<<endl;// }// cout<<num_cross<<endl;for(i=0;i<num_cross/2;i++){srand(time(NULL));k=rand()%num;for(j=0;j<num;j++){if(j<=k){Unit[i][j]=Unit_choose[cro[num_cross-i]][j];Unit[i+num_cross/2][j]=Unit_choose[cro[i]][j];}else{Unit[i][j]=Unit_choose[cro[i]][j];Unit[i+num_cross/2][j]=Unit_choose[cro[i]][j];}}}for(i=0;i<NUMBER;i++){// cout<<temp[i]<<endl;if(temp[i]==0){for(j=0;j<num;j++){Unit[num_cross][j]=Unit_choose[i][j];}num_cross++;}}}void hwj_aberrance(int num,float aberrance){//变异后的得到的种群int num_aberrance=NUMBER*aberrance;//变异的个体数int k;//变异点int abe[NUMBER];//变异的个体编号int temp[NUMBER];//是否变异数组一览int i,j,p;for(i=0;i<NUMBER;i++){abe[i]=-1;temp[i]=0;}// hwj_N_M(cro,temp,num_cross,NUMBER);srand(time(NULL));abe[0]=rand()%NUMBER;temp[abe[0]]=1;i=1;while(i!=num_aberrance){abe[i]=rand()%NUMBER;if(temp[abe[i]]==0){temp[abe[i]]=1;i++;}}for( i=0;i<NUMBER;i++){for( j=0;j<num_aberrance;j++){if(i==abe[j]){k=rand()%num;for( p=0;p<num;p++){if(p==k){if(Unit[i][p]==1){Unit[i][p]==0;}else{Unit[i][p]==1;}}}}}}}void hwj_max(int num){hwj_fitness(num);// float max=0.0;int i;int temp=1;float sum=0.0;int k;for(i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;if(Fitness[i]>f_max){f_max=Fitness[i];k=i;}}for(int j=num-1;j>=0;j--){sum+=Unit[k][j]*temp;temp*=2.0;}f_x=sum*3/(temp-1.0)-1.0;}Welcome !!! 欢迎您的下载,资料仅供参考!。