遗传算法的matlab代码实现

遗传算法的总体框架

选择算子（轮盘赌选择）

交叉算子（单点交叉）

变异算子

遗传算法的代码实现
遗传算法的编码与解码方法
编码：把个体的性状变为遗传信息
解码：把遗传信息变为性状
编码举例：对于变量x，假设x变量的范围为：[-1,12]，则区间的长度为12- (-1) = 13，假设我们要求精度为小数点后四位，则进行进制转换
65536 = 2 16 < 13 × 1 0 4 < 2 17 = 131072 65536=2^{16}<13\times 10^4<2^{17}=131072
65536=2 
16
 <13×10 
4
 <2 
17
 =131072
则我们的二进制编码长度为17位
解码方法：若x的区间为[a,b]，x的二进制编码为(a_0,a_1,…a_n-1,a_n)则长度为n+1，那么十进制数为
( a 0 a 1 . . . a n − 1 a n ) 2 = ( ∑ i = 0 n a i × 2 i ) 10 = s u m (a_0a_1...a_{n-1}a_n)_2=(\sum_{i=0}^{n}a_i\times2^i)_{10}=sum
(a 
0
​
 a 
1
​
 ...a 
n−1
​
 a 
n
​
 ) 
2
​
 =( 
i=0
∑
n
​
 a 
i
​
 ×2 
i
 ) 
10
​
 =sum
x = a + s u m × ( b − a ) / ( 2 n + 1 − 1 ) x=a+sum\times(b-a)/(2^{n+1}-1)
x=a+sum×(b−a)/(2 
n+1
 −1)
初始化种群
%% 初始化种群
Num_pop = 200;
Num_gen = 1000;
Binary_lenth = 32;
P_c=0.8;
P_m=0.02;
pop = round(rand(Num_pop,Binary_lenth));        %表示将矩阵元素全都四舍五入取整
                                     %又因为rand函数生成的是(0,1)之间的随机数
                                     %所以取整之后，pop得到了天然的二进制01编码
x1 = decode_x1(pop(:,1:17));         %x1是一个40行17列的矩阵，用来存放所有个体的第一个染色体
x2 = decode_x2(pop(:,18:end));      %x2是一个40行15列的矩阵，用来存放所有个体的第二个染色体

%% 计算适应度值
fitness = x1.*sin(pi*x1) + x2.*sin(exp(x2));
[max_fit,spot]=max(fitness);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
解码
decode_x1

%  date:2019年3月5日
%  Author: Chauncy_xu
function [a] = decode_x1(binary_code)
%该函数把二进制编码进行解码
%   input  x1的二进制编码，是一个40行17列的01矩阵
%   output 一个40行1列的实数矩阵
[M,N] = size(binary_code);%这里面M应该为40，N为17
sum = zeros(M,1);%产生一个M行1列的零矩阵,用于存放实数值
for i = 1:M    %开始遍历01编码矩阵
               %行遍历，也就是按照个体遍历 
    for j = 1:N  %列遍历
        sum(i) = sum(i)+binary_code(i,j)*2^(N-j);
    end
    a(i) = -1.0 + sum(i)*(12.0-(-1.0))/(2^N-1);
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
decode_x2

%  date:2019年3月5日
%  Author: Chauncy_xu
function [b] = decode_x2(binary_code)
%该函数把二进制编码进行解码
%   input  x1的二进制编码，是一个40行17列的01矩阵
%   output 一个40行1列的实数矩阵
[M,N] = size(binary_code);%这里面M应该为40，N为17
sum = zeros(M,1);%产生一个M行1列的零矩阵,用于存放实数值
for i = 1:M    %开始遍历01编码矩阵
               %行遍历，也就是按照个体遍历 
    for j = 1:N  %列遍历
        sum(i) = sum(i)+binary_code(i,j)*2^(N-j);
    end
    b(i) = 4.0 + sum(i)*(6.0-(4.0))/(2^N-1);
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
选择（轮盘赌选择方法）
%  date:2019年3月5日
%  Author: Chauncy_xu
function [new_pop] = Select(fitness,pop)
% 该函数是一个轮盘赌选择函数，选择好的个体进入交配池
% Input  适应度值
% Input  矩阵A
% Output 交配池，也可以说是中间的新的种群
[M,N]=size(pop);
for i=1:M  %把每个个体的适应度值转化为被选择的概率
    prob(i)=fitness(i)/sum(fitness);   %sum函数可以直接获得fitness的总和
end
for i=2:M  %把每个个体的被选择概率转化为累加概率
    prob(i)=prob(i)+prob(i-1);
end
for j=1:M
    p=rand();
    i=1;
    while p>prob(i)
        i=i+1;
    end
    new_pop(j,:)=pop(i,:);
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
交叉（单点交叉）
%  date:2019年3月5日
%  Author: Chauncy_xu
function [Cross_pop] = Crossover(P_c,pop)
% 该函数实现交配池中的交叉，基本思想是两两配对，根据交叉概率选择是否交叉，
% 这里进行的交叉是单点交叉
% Input   P_c  交叉概率
% Input   pop  交配池，也可以说是中间种群
% Output  Cross_poop   进行交叉运算之后的种群
Cross_pop=pop;
[M,N]=size(pop);
for i=1:2:M-1
    p=rand();
    q=rand();
    if p<P_c
        spot = ceil(q*N);  %随机选择交叉点
        for j=spot:N
            temp = pop(i,j);
            Cross_pop(i,j) = pop(i+1,j);
            Cross_pop(i+1,j) = temp;
        end
    end
end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
变异
%  date:2019年3月5日
%  Author: Chauncy_xu
function [Mut_pop] = Mutation(P_m,pop)
% 该函数进行遗传算法中的变异操作，具体为随机选择变异位值，对该点的二进制编码取反
% Input   P_m  变异概率
% Iutput  pop   刚刚进行过交叉的中间种群
% Output  Mut_pop  变异之后的种群 
[M,N] = size(pop);
Mut_pop = pop;
flag = (rand(M,N)<P_m);
for i=1:M
    for j=1:N
        if flag(i,j)==1
            if pop(i,j)==1
                Mut_pop(i,j)=0;
            else
                Mut_pop(i,j)=1;
            end
        end
    end
end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
迭代过程
%  date:2019年3月5日
%  Author: Chauncy_xu
for gen=1:Num_gen
    %% 进行选择操作
    [pop] = Select(fitness,pop);
    %% 进行交叉操作
    [pop] = Crossover(P_c,pop);
    %% 进行变异操作
    [pop] = Mutation(P_m,pop);
    pop=pop;
    %解码
    x1 = decode_x1(pop(:,1:17));         
    x2 = decode_x2(pop(:,18:end)); 
    fitness = x1.*sin(pi*x1) + x2.*sin(exp(x2));
     %存储该代的最优个体适应值
    [best_fit,index] = max(fitness); 
    %更新全局最优值
    if best_fit >= max_fit
        max_fit = best_fit;
        spot = pop(index,:);
        x_1 = decode_x1(spot(1:17));
        x_2 = decode_x2(spot(18:end));<