MATLAB智能算法—遗传算法_matlab individual

1.遗传算法的介绍

遗传算法（Genetic Algorithm,GA）关键是把问题参数编码成染色体，再利用迭代方式进行选择、交叉、变异等运算交换种群中的染色体信息，根据适应度的好坏选择一定数量优秀的染色体，经过若干代的进化后，最终收敛于最好的符合优化目标染色体。

特点：

1. 全局搜索能力强，局部搜索能力弱
2. 一般得到的是次优解，而非最优解（问题规模小可得最优解，问题规模大一般只能得近似解）

术语：

1. 个体(individual)
2. 适应度函数(fitness function)、适应度函数值(fitness value)
3. 种群(population)、种群大小(population size)
4. 代(generation)
5. 父代(parents)、子代(children)
6. 选择(select)、交叉(crossover)、变异(mutation)
7. 精英数目(eliteCount)、交叉后代比例(crossover fraction)

步骤：

1. 初始化种群：位串编码、Grey编码、实数编码、多级参数编码、有序串编码、结构式编码
2. 适应度函数：由目标函数变换得到，函数值越大/小，个体越优
3. 选择操作：个体适应度函数值越高，被选中概率越大，轮盘赌法、锦标赛法
4. 交叉操作：随机抽取种群两个个体，通过染色体的交换组合，把父串的优秀特征传给子串，从而产生新的优秀个体
5. 变异操作：维持种群多样性，随机抽取种群单个体，选择染色体的一点变异
6. 收敛寻优：通过迭代产生的新种群为下次计算的初始值，经过众多次迭代，算法收敛于“最优解”
7. 结果统计：多次测试，根据需求，取最优或平均

参数：

1. 种群规模：100
2. 进化次数：30
3. 交叉概率：0.6
4. 变异概率：0.1

改进：

1. 精英策略：子代种群中的最优个体永远不会比父代最优的个体差，使得父代好的个体不至于交叉、变异而丢失
2. 进化逆转：TSP解的关键在于码串的顺序，交叉一方面可以维持种群的多样性，避免陷入局部最优，另一方面它不利于子代继承亲代的较多信息，特别是进化到了后期，群体充斥大量高适应度个体，交叉对亲代的较优基因破坏很大，使子代难以继承到亲代的优良基因，从而使交叉算子的搜索能力大大降低；单向进化逆转，即只接受朝着好的方向的逆转，搜索最优解的能力强于交叉算子

 

2.遗传算法工具箱

2.1 GA工具箱

1. 英国谢菲尔德大学的遗传算法工具箱
2. 美国北卡罗来纳州立大学的遗传算法最优化工具箱
3. MATLAB自带的遗传算法工具箱与直接搜索工具箱

2.2 谢菲尔德遗传算法工具箱

     2.2.1 安装配置到 Matlab

1. 将 gatbx 文件夹复制粘贴到 Matlab 软件安装目录下的 toolbox 目录中
2. 将所在文件夹添加到 Matlab 的搜索路径：str=[matlabroot,'\toolbox\gatbx'];    addpath(str)
3. 测试是否安装成功：v = ver('gatbx')

    2.2.2  工具箱相关函数功能介绍

      

2.2 

2.3 MATLAB自带的遗传算法工具箱与直接搜索工具箱

     Genetic Algorithm and Direct Search Toolbox，GADST

     2.3.1 GADST GUI

命令行输入：

optimtool('ga')

注意：GADST是对目标函数去最小值进行优化，若要最大值优化，将适应度函数*-1

 

 

3 非线性规划的函数寻优

     

1.初始化种群：实数编码：不必进行数值转换，可以直接在解的表现型上进行遗传算法操作

function ret=Code(lenchrom, bound)
% lenchrom   input : 染色体长度
% bound      input : 变量的取值范围
% ret        output: 染色体的编码值
 
flag=0;
 
while flag==0
    pick=rand(1,length(lenchrom));
    ret=bound(:,1)'+(bound(:,2)-bound(:,1))'.*pick; % 线性插值
    flag=test(lenchrom,bound,ret);                  % 检验染色体的可行性
end

2.适应度函数：求函数最小值，将函数值的倒数作为个体的适应度值，即函数值越小的个体越优

function y = fun(x)
y=-5*sin(x(1))*sin(x(2))*sin(x(3))*sin(x(4))*sin(x(5))-sin(5*x(1))*sin(5*x(2))*sin(5*x(3))*sin(5*x(4))*sin(5*x(5))+8;

3.选择操作：轮盘赌：基于适应度比例的选择策略

    

function ret=Select(individuals,sizepop)
% individuals input  : 种群信息
% sizepop     input  : 种群规模
% opts        input  : 选择方法的选择
% ret         output : 经过选择后的种群
 
individuals.fitness= 1./(individuals.fitness);
sumfitness=sum(individuals.fitness);
sumf=individuals.fitness./sumfitness;
index=[];
for i=1:sizepop   % 转sizepop次轮盘
    pick=rand;
    while pick==0
        pick=rand;
    end
    for j=1:sizepop
        pick=pick-sumf(j);
        if pick<0
            index=[index j];
            break;  % 寻找落入的区间，此次转轮盘选中了染色体i，注意：在转sizepop次轮盘的过程中，有可能会重复选择某些染色体
        end
    end
end
individuals.chrom=individuals.chrom(index,:);
individuals.fitness=individuals.fitness(index);
ret=individuals;

4.交叉操作：实数交叉

   

function ret=Cross(pcross, lenchrom, chrom, sizepop, bound)
% pcorss                input  : 交叉概率
% lenchrom              input  : 染色体的长度
% chrom                 input  : 染色体群
% sizepop               input  : 种群规模
% ret                   output : 交叉后的染色体
 
for i=1:sizepop 
    % 随机选择两个染色体进行交叉
    pick=rand(1,2);
    while prod(pick)==0
        pick=rand(1,2);
    end
    index=ceil(pick.*sizepop);
    % 交叉概率决定是否进行交叉
    pick=rand;
    while pick==0
        pick=rand;
    end
    if pick>pcross
        continue;
    end
    flag=0;
    while flag==0
        % 随机选择交叉位置
        pick=rand;
        while pick==0
            pick=rand;
        end
        % 随机选择进行交叉的位置，即选择第几个变量进行交叉，注意：两个染色体交叉的位置相同
        pos=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==0
            flag=0;
        else flag=1;
        end    % 如果两个染色体不是都可行，则重新交叉
    end
end
 
ret=chrom;

5.变异操作

       

function ret=Mutation(pmutation, lenchrom, chrom, sizepop, pop, bound)
% pcorss                input  : 变异概率
% lenchrom              input  : 染色体长度
% chrom                 input  : 染色体群
% sizepop               input  : 种群规模
% pop                   input  : 当前种群的进化代数和最大的进化代数信息
% ret                   output : 变异后的染色体
 
for i=1:sizepop  
    % 随机选择一个染色体进行变异
    pick=rand;
    while pick==0
        pick=rand;
    end
    index=ceil(pick*sizepop);
    % 变异概率决定该轮循环是否进行变异
    pick=rand;
    if pick>pmutation
        continue;
    end
    flag=0;
    while flag==0
        % 变异位置
        pick=rand;
        while pick==0
            pick=rand;
        end
        % 随机选择了染色体变异的位置，即选择了第pos个变量进行变异
        pos=ceil(pick*sum(lenchrom));  
        v=chrom(i,pos);
        v1=v-bound(pos,1);
        v2=bound(pos,2)-v;
        pick=rand; % 变异开始
        if pick>0.5
            delta=v2*(1-pick^((1-pop(1)/pop(2))^2));
            chrom(i,pos)=v+delta;
        else
            delta=v1*(1-pick^((1-pop(1)/pop(2))^2));
            chrom(i,pos)=v-delta;
        end        % 变异结束
        flag=test(lenchrom,bound,chrom(i,:));     % 检验染色体的可行性
    end
end
 
ret=chrom;

6.收敛寻优

基本GA寻优

%% 清空环境
clc
clear
 
%% 遗传算法参数
maxgen=30;              % 进化代数
sizepop=100;            % 种群规模
pcross=[0.6];           % 交叉概率
pmutation=[0.01];       % 变异概率
lenchrom=[1 1 1 1 1];   % 变量字串长度
bound=[0 0.9*pi;0 0.9*pi;0 0.9*pi;0 0.9*pi;0 0.9*pi];  % 变量范围
 
%% 个体初始化
individuals=struct('fitness',zeros(1,sizepop), 'chrom',[]);  % 种群结构体
avgfitness=[];                                               % 种群平均适应度
bestfitness=[];                                              % 种群最佳适应度
bestchrom=[];                                                % 适应度最好染色体
% 初始化种群
for i=1:sizepop
    individuals.chrom(i,:)=Code(lenchrom,bound);       % 随机产生个体
    x=individuals.chrom(i,:);
    individuals.fitness(i)=fun(x);                     % 个体适应度
end
 
% 找最好的染色体
[bestfitness bestindex]=min(individuals.fitness);
bestchrom=individuals.chrom(bestindex,:);    % 最好的染色体
avgfitness=sum(individuals.fitness)/sizepop; % 染色体的平均适应度
% 记录每一代进化中最好的适应度和平均适应度
trace=[]; 
 
%% 进化开始
for i=1:maxgen
     % 选择操作
     individuals=Select(individuals,sizepop); 
     avgfitness=sum(individuals.fitness)/sizepop;
     % 交叉操作
     individuals.chrom=Cross(pcross,lenchrom,individuals.chrom,sizepop,bound);
     % 变异操作
     individuals.chrom=Mutation(pmutation,lenchrom,individuals.chrom,sizepop,[i maxgen],bound);
    
    % 计算适应度 
    for j=1:sizepop
        x=individuals.chrom(j,:);
        individuals.fitness(j)=fun(x);   
    end
    
    % 找到最小和最大适应度的染色体及它们在种群中的位置
    [newbestfitness,newbestindex]=min(individuals.fitness);
    [worestfitness,worestindex]=max(individuals.fitness);
    % 代替上一次进化中最好的染色体
    if bestfitness>newbestfitness
        bestfitness=newbestfitness;
        bestchrom=individuals.chrom(newbestindex,:);
    end
    individuals.chrom(worestindex,:)=bestchrom;
    individuals.fitness(worestindex)=bestfitness;
    
    avgfitness=sum(individuals.fitness)/sizepop;
    % 记录每一代进化中最好的适应度和平均适应度
    trace=[trace;avgfitness bestfitness]; 
end  %进化结束
 
 
%% 结果显示
[r c]=size(trace);
figure
plot([1:r]',trace(:,1),'r-',[1:r]',trace(:,2),'b--');
title(['函数值曲线  ' '终止代数＝' num2str(maxgen)],'fontsize',12);
xlabel('进化代数','fontsize',12);ylabel('函数值','fontsize',12);
legend('各代平均值','各代最佳值');
disp('函数值                   变量');
ylim([1.5 8])
%xlim([1,size(trace,1)])
grid on
% 窗口显示
disp([bestfitness x]);

工具箱fmincon函数优化

function ret = nonlinear(chrom,sizepop)
 
for i=1:sizepop
    x=fmincon(inline('-5*sin(x(1))*sin(x(2))*sin(x(3))*sin(x(4))*sin(x(5))-sin(5*x(1))*sin(5*x(2))*sin(5*x(3))*sin(5*x(4))*sin(5*x(5))'),chrom(i,:)',[],[],[],[],[0 0 0 0 0],[2.8274 2.8274 2.8274 2.8274 2.8274]);
    ret(i,:)=x';
end

%% 清空环境
clc
clear
warning off
 
%% 遗传算法参数
maxgen=30;                         % 进化代数
sizepop=100;                       % 种群规模
pcross=[0.6];                      % 交叉概率
pmutation=[0.01];                  % 变异概率
lenchrom=[1 1 1 1 1];              % 变量字串长度
bound=[0 0.9*pi;0 0.9*pi;0 0.9*pi;0 0.9*pi;0 0.9*pi];  %变量范围
 
%% 个体初始化
individuals=struct('fitness',zeros(1,sizepop), 'chrom',[]);  % 种群结构体
avgfitness=[];                                               % 种群平均适应度
bestfitness=[];                                              % 种群最佳适应度
bestchrom=[];                                                % 适应度最好染色体
% 初始化种群
for i=1:sizepop
    individuals.chrom(i,:)=Code(lenchrom,bound);       % 随机产生个体
    x=individuals.chrom(i,:);
    individuals.fitness(i)=fun(x);                     % 个体适应度
end
 
%找最好的染色体
[bestfitness bestindex]=min(individuals.fitness);
bestchrom=individuals.chrom(bestindex,:);    % 最好的染色体
avgfitness=sum(individuals.fitness)/sizepop; % 染色体的平均适应度
% 记录每一代进化中最好的适应度和平均适应度
trace=[];
 
%% 进化开始
for i=1:maxgen
    
    % 选择操作
    individuals=Select(individuals,sizepop);
    avgfitness=sum(individuals.fitness)/sizepop;
    % 交叉操作
    individuals.chrom=Cross(pcross,lenchrom,individuals.chrom,sizepop,bound);
    % 变异操作
    individuals.chrom=Mutation(pmutation,lenchrom,individuals.chrom,sizepop,[i maxgen],bound);
    
    if mod(i,10)==0
        individuals.chrom=nonlinear(individuals.chrom,sizepop);
    end
    
    % 计算适应度
    for j=1:sizepop
        x=individuals.chrom(j,:);
        individuals.fitness(j)=fun(x);
    end
    
    % 找到最小和最大适应度的染色体及它们在种群中的位置
    [newbestfitness,newbestindex]=min(individuals.fitness);
    [worestfitness,worestindex]=max(individuals.fitness);
    % 代替上一次进化中最好的染色体
    if bestfitness>newbestfitness
        bestfitness=newbestfitness;
        bestchrom=individuals.chrom(newbestindex,:);
    end
    individuals.chrom(worestindex,:)=bestchrom;
    individuals.fitness(worestindex)=bestfitness;
    
    avgfitness=sum(individuals.fitness)/sizepop;
    % 记录每一代进化中最好的适应度和平均适应度
    trace=[trace;avgfitness bestfitness]; 
end   % 进化结束
 
%% 结果显示
figure
[r c]=size(trace);
plot([1:r]',trace(:,1),'r-',[1:r]',trace(:,2),'b--');
title(['函数值曲线  ' '终止代数＝' num2str(maxgen)],'fontsize',12);
xlabel('进化代数','fontsize',12);ylabel('函数值','fontsize',12);
legend('各代平均值','各代最佳值','fontsize',12);
ylim([1.5 8])
disp('函数值                   变量');
% 窗口显示
disp([bestfitness x]);
grid on

7.结果

基本GA优化迭代到第30次函数值收敛于2，工具箱优化迭代到第10次函数值收敛于2

 

 

 

4 基于遗传算法的TSP算法

TSP：从一个城市出发，访问每个城市且只去一次，最后回到出发城市，使路径最短（一条遍历n个城市的最短曼哈顿回路）