自适应遗传算法

三相负荷不平衡优化问题求解：以电流不平衡度小和换相开关次数少建立模型并编码，采用如下算法求解

% 自适应向量基因遗传算法 %
%种群规模100 迭代次数80 %
% F=P×I_max (K)+(1-P) × H(K) 染色体长度16 %

% %
%--------------------------------------------------------------------------------------------------------------%
%--------------------------------------------------------------------------------------------------------------%

% 编程
%-----------------------------------------------

function y=fun()
clear  %清除原有变量
clf      %清除命令窗口的内容
global popsize;
global chromlength;
popsize=100; %群体大小
chromlength=16; %字符串长度（个体长度）
pc=0.6; %交叉概率
pm=0.01; %初始变异概率
global Ix;
Ix=[9;9;12;6;7;10;6;9;13;10;6;10;7;5;6;5];
global Ia;
Ia=43;
global Ib;
Ib=47;
global Ic;
Ic=40;
global Ie;
Ie=51;
%disp(Ix);
global k itr ;
k=[1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 1;0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0;0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0];
% disp(k);
itr=80;%为迭代次数
adapt_ave(itr)=0;   %种群平均适应值

pop=initpop(popsize,chromlength); %随机产生初始群体
disp(pop);
pop5=ones(itr*3,chromlength);
pop1=pop;
for i=1:itr 
objvalue=calobjvalue(pop); %计算目标函数
adapt_ave(i)=sum(objvalue)/popsize;
fitvalue=calfitvalue(objvalue); %计算群体中每个个体的适应度
%fprintf('pop=%d-%d\n',size(pop));
newpop=selection(pop,fitvalue); %复制
%fprintf('newpop=%d-%d\n',size(newpop));
newpop=crossover(newpop,pc); %交叉
% 
[newpop]=mutation(newpop,pm,objvalue,adapt_ave(i)); %变异

[bestindividual,bestfit]=best(pop,objvalue); %求出群体中适应值最大的个体及其适应值
y(i)=min(bestfit);
n(i)=i;

pop5(3*(i-1)+1:3*(i-1)+3,:)=bestindividual(1:3,:);
pop=newpop;

end

for i=1:itr 
objvalue1=calobjvalue(pop1); %计算目标函数
adapt_ave1(i)=sum(objvalue1)/popsize;
fitvalue1=calfitvalue(objvalue1); %计算群体中每个个体的适应度
%fprintf('pop=%d-%d\n',size(pop));
newpop1=selection(pop1,fitvalue1); %复制
%fprintf('newpop=%d-%d\n',size(newpop));
newpop1=crossover(newpop1,pc); %交叉
% 
[newpop1]=orlmutation(newpop1,pm); %变异

[bestindividualp,bestfitp]=best(pop1,objvalue1); %求出群体中适应值最大的个体及其适应值
y1(i)=min(bestfitp);
n1(i)=i;

pop5p(3*(i-1)+1:3*(i-1)+3,:)=bestindividualp(1:3,:);
pop1=newpop1;

end

xlabel('迭代次数')
ylabel('三相负荷不平衡度平均适应度函数值收敛曲线','Rotation',90)
%  set(gca,'yticklabel',0:2:24);
axis([0 itr 0 max(adapt_ave)+1])
% set(gca,'XTickLabelRotation',46)
% title('标题')
hold on
 x=1:itr;
%  plot(x,y,'r*',x,adapt_ave,'b--')
%  plot(x,y1,'m--',x,adapt_ave1,'g--')
 plot(x,adapt_ave,'b--',x,adapt_ave1,'r--')

hold off

[z1,index1]=min(y1); %计算最大值及其位置

fprintf('biaozhun=%d-%.1f\n',index1,z1);
pop6p(1:3,:)=pop5p(3*(index1-1)+1:3*(index1-1)+3,:);
disp(pop6p);
disp(bestindividualp);

[z,index]=min(y); %计算最大值及其位置
fprintf('zuixiao=%d-%.1f\n',index,z);
pop6(1:3,:)=pop5(3*(index-1)+1:3*(index-1)+3,:);
disp(pop6);
 disp(bestindividual);
 
 [e1,g1]=liuci(bestindividualp);
 [e,g]=liuci(bestindividual);
 v=[bestfitp,e1,g1;bestfit,e,g];
 disp(v);
 [c1,d1]=liuci(pop6p);
 [c,d]=liuci(pop6);
 y=[z1,c1,d1;z,c,d];

% 2.1初始化(编码)
% initpop.m函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength表示染色体的长度(二值数的长度)，
% 长度大小取决于变量的二进制编码的长度(在本例中取10位)。
%遗传算法子程序
%Name: initpop.m
%初始化
function mypop=initpop(popsize,chromlength) 
popa=rand(popsize,chromlength);
mypop(popsize*3,chromlength)=0;
for i=1:popsize   
    for j=1:chromlength
        if popa(i,j)<0.34
            mypop(1+3*(i-1),j)=1;
            mypop(2+3*(i-1),j)=0;
            mypop(3+3*(i-1),j)=0;
        elseif popa(i,j)<0.67
            mypop(1+3*(i-1),j)=0;
            mypop(2+3*(i-1),j)=1;
            mypop(3+3*(i-1),j)=0;
        else
            mypop(1+3*(i-1),j)=0;
            mypop(2+3*(i-1),j)=0;
            mypop(3+3*(i-1),j)=1; 
        end
    end
end
 % rand随机产生每个单元为 {0,1} 行数为popsize，列数为chromlength的矩阵，
% roud对矩阵的每个单元进行圆整。这样产生的初始种群。

% 2.2.3 计算目标函数值
% calobjvalue.m函数的功能是实现目标函数的计算，其公式采用本文示例仿真，可根据不同优化问题予以修改。
%遗传算法子程序
%Name: calobjvalue.m
%实现目标函数的计算
function value=calobjvalue(pop)
global popsize Ix Ia Ib Ic chromlength k;
for i=1:3: popsize*3
        tmp=pop(i:i+2,:);
        tmm=tmp*Ix;
%          disp(tmp);
        maxt=max([abs(tmm(1,1)-Ia),abs(tmm(2,1)-Ib),abs(tmm(3,1)-Ic)]);
%         fprintf('minx=%d\n',maxt);
        count=0;
    for j=1:chromlength 
        if isequal(tmp(:,j),k(:,j))==0
            count=count+1;      
        end
    end
%     adpt=maxt*0.8+count*0.2;
    if maxt>4
       adpt=maxt*0.7+count*0.3;
    elseif count>4
        adpt=maxt*0.2+count*0.8;
    else
        adpt=maxt*0.3+count*0.3;
    end
       
       
%        fprintf('count=%.1f\n',adpt);
      
       value((i-1)/3+1)=adpt;
end
% disp(value);
 %计算目标函数值
function [maxt,count]=liuci(pop)
global  Ix Ia Ib Ic chromlength k;

        tmm=pop*Ix;
%          disp(tmp);
        maxt=max([abs(tmm(1,1)-Ia),abs(tmm(2,1)-Ib),abs(tmm(3,1)-Ic)]);
%         fprintf('minx=%d\n',maxt);
        count=0;
    for j=1:chromlength 
        if isequal(pop(:,j),k(:,j))==0
            count=count+1;      
        end
    end
  

 
 
% 2.3 计算个体的适应值
%遗传算法子程序
%Name:calfitvalue.m
%计算个体的适应值
function fitvalue=calfitvalue(value)
fitvalue=1./value;

% disp(fitvalue);
% fitvalue=fitvalue';

% 2.4 选择复制
% 选择或复制操作是决定哪些个体可以进入下一代。程序中采用赌轮盘选择法选择，这种方法较易实现。
% 根据方程 pi=fi/∑fi=fi/fsum ，选择步骤：
% 1） 在第 t 代，由（1）式计算 fsum 和 pi 
% 2） 产生 {0,1} 的随机数 rand( .)，求 s=rand( .)*fsum
% 3） 求 ∑fi≥s 中最小的 k ，则第 k 个个体被选中
% 4） 进行 N 次2）、3）操作，得到 N 个个体，成为第 t=t+1 代种群
%遗传算法子程序
%Name: selection.m
%选择复制
function newpop=selection(pop,fitvalue)
totalfit=sum(fitvalue); %求适应值之和
fprintf('totalfit=%.1f\n',totalfit);
fitvalue=fitvalue/totalfit; %单个个体被选择的概率
% fprintf('fitvalue=%d-%d\n',size(fitvalue));
fitvalue=cumsum(fitvalue); %如 fitvalue=[1 2 3 4]，则 cumsum(fitvalue)=[1 3 6 10] 
% disp(fitvalue);
global popsize;
px=popsize;
ms=sort(rand(px,1)); %从小到大排列
fitin=1;
newin=1;
while newin<=px

if(ms(newin)) newpop(3*(newin-1)+1,:)=pop(3*(fitin-1)+1,:);
newpop(3*(newin-1)+2,:)=pop(3*(fitin-1)+2,:);
newpop(3*(newin-1)+3,:)=pop(3*(fitin-1)+3,:);

newin=newin+1;

else
fitin=fitin+1;
end
end
% disp(newpop);

% 2.5 交叉
% 交叉(crossover)，群体中的每个个体之间都以一定的概率 pc 交叉，即两个个体从各自字符串的某一位置
% （一般是随机确定）开始互相交换，这类似生物进化过程中的基因分裂与重组。例如，假设2个父代个体x1，x2为：
% x1=0100110
% x2=1010001
% 从每个个体的第3位开始交叉，交又后得到2个新的子代个体y1，y2分别为：
% y1＝0100001
% y2＝1010110
% 这样2个子代个体就分别具有了2个父代个体的某些特征。利用交又我们有可能由父代个体在子代组合成具有更高适合度的个体。
% 事实上交又是遗传算法区别于其它传统优化方法的主要特点之一。
%遗传算法子程序
%Name: crossover.m
%交叉
function newpop=crossover(pop,pc)
global popsize chromlength;
px=popsize;
py=chromlength;
newpop=ones(px*3,py);
for i=1:2:px-1
if(rand cpoint=round(rand*py);
newpop(3*(i-1)+1,:)=[pop(3*(i-1)+1,1:cpoint),pop(3*i+1,cpoint+1:py)];
newpop(3*i+1,:)=[pop(3*i+1,1:cpoint),pop(3*(i-1)+1,cpoint+1:py)];
newpop(3*(i-1)+2,:)=[pop(3*(i-1)+2,1:cpoint),pop(3*i+2,cpoint+1:py)];
newpop(3*i+2,:)=[pop(3*i+2,1:cpoint),pop(3*(i-1)+2,cpoint+1:py)];
newpop(3*(i-1)+3,:)=[pop(3*(i-1)+3,1:cpoint),pop(3*i+3,cpoint+1:py)];
newpop(3*i+3,:)=[pop(3*i+3,1:cpoint),pop(3*(i-1)+3,cpoint+1:py)];
else
newpop(3*(i-1)+1,:)=pop(3*(i-1)+1,:);
newpop(3*i+1,:)=pop(3*i+1,:);
newpop(3*(i-1)+2,:)=pop(3*(i-1)+2,:);
newpop(3*i+2,:)=pop(3*i+2,:);
newpop(3*(i-1)+3,:)=pop(3*(i-1)+3,:);
newpop(3*i+3,:)=pop(3*i+3,:);
end
end
% fprintf('newpop-crossover=\n');
% disp(newpop);

% 2.6 变异
% 变异(mutation)，基因的突变普遍存在于生物的进化过程中。变异是指父代中的每个个体的每一位都以概率 pm 翻转，即由“1”变为“0”，
% 或由“0”变为“1”。遗传算法的变异特性可以使求解过程随机地搜索到解可能存在的整个空间，因此可以在一定程度上求得全局最优解。
%遗传算法子程序
%Name: mutation.m
%变异
function [newpop]=orlmutation(pop,pm)
global popsize chromlength;
px=popsize;
py=chromlength;
newpop=ones(px*3,py);
for i=1:px
newpop(1+3*(i-1),:)=pop(1+3*(i-1),:);
newpop(2+3*(i-1),:)=pop(2+3*(i-1),:);
newpop(3+3*(i-1),:)=pop(3+3*(i-1),:);
if(rand mpoint=round(rand*py);
if mpoint<=0
mpoint=1;
end
x=newpop(1+3*(i-1),mpoint);
y=newpop(2+3*(i-1),mpoint);
fei=round(rand);
if x==1
    if fei==0
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=1;
        newpop(3+3*(i-1),mpoint)=0;
    else
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=1;
    end
elseif y==1
    if fei==0
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=1;
    else
        newpop(1+3*(i-1),mpoint)=1;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=0;
    end
else
    if fei==0
        newpop(1+3*(i-1),mpoint)=1;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=0;
    else
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=1;
        newpop(3+3*(i-1),mpoint)=0;
    end
end
end
end
% disp(newpop);

%改进的变异方法
function [newpop]=mutation(pop,pm,objvalue,adapt_ave)
global popsize chromlength;
px=popsize;
py=chromlength;
for i=1:px
    tmp=(objvalue(i)-adapt_ave)^2;
    pmvalue(i)=pm/(1+1*exp(-tmp));
end
disp(pmvalue);
newpop=ones(px*3,py);
for i=1:px
newpop(1+3*(i-1),:)=pop(1+3*(i-1),:);
newpop(2+3*(i-1),:)=pop(2+3*(i-1),:);
newpop(3+3*(i-1),:)=pop(3+3*(i-1),:);
if(rand mpoint=round(rand*py);
if mpoint<=0
mpoint=1;
end
x=newpop(1+3*(i-1),mpoint);
y=newpop(2+3*(i-1),mpoint);
fei=round(rand);
if x==1
    if fei==0
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=1;
        newpop(3+3*(i-1),mpoint)=0;
    else
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=1;
    end
elseif y==1
    if fei==0
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=1;
    else
        newpop(1+3*(i-1),mpoint)=1;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=0;
    end
else
    if fei==0
        newpop(1+3*(i-1),mpoint)=1;
        newpop(2+3*(i-1),mpoint)=0;
        newpop(3+3*(i-1),mpoint)=0;
    else
        newpop(1+3*(i-1),mpoint)=0;
        newpop(2+3*(i-1),mpoint)=1;
        newpop(3+3*(i-1),mpoint)=0;
    end
end
end
end
% disp(newpop);

% 2.7 求出群体中最大得适应值及其个体
%遗传算法子程序
%Name: best.m
%求出群体中适应值最大的值
function [bestindividual,bestfit]=best(pop,objvalue)
global popsize chromlength;
px=popsize;
py=chromlength;
bestindividual=pop(1:3,:);
bestfit=objvalue(1);
for i=2:px
if objvalue(i) bestindividual=pop(3*(i-1)+1:3*(i-1)+3,:);
bestfit=objvalue(i);
end
end