深圳幻海软件技术有限公司 欢迎您！
更多

多目标优化NSGA-II的实现（MATLAB完整代码）

2023-06-29

case end pop
由于历史原因，没有整理好完整的代码，所以在【多目标优化NSGA-II的实现和测试（MATLAB实现）】中只放了部分代码。现在已经整理好了代码，此部分的代码测试内容为：ZDT1、ZDT2、ZDT3、ZDT4、ZDT6。目录主要内容代码模块其他内容运行注意事项 代码nsga2_testnsga

由于历史原因，没有整理好完整的代码，所以在【多目标优化NSGA-II的实现和测试（MATLAB实现）】中只放了部分代码。

现在已经整理好了代码，此部分的代码测试内容为：ZDT1、ZDT2、ZDT3、ZDT4、ZDT6。

目录

主要内容

代码模块

其他内容

运行注意事项

 代码

nsga2_test

nsga2_main

get_variable_bounds

init_pop

sort_pop

select_parent

myga

combined_pop

select_pop

calculate_gd

calculate_sp

calculate_pop

plotPareto

运行结果

主要内容

代码模块

  • nsga2_test：测试函数，用于保存测试数据
  • nsga2_main：主函数，，用于运行NSGA2算法的框架
  • get_variable_bounds：获取种群范围
  • init_pop：种群初始化
  • sort_pop：种群排序
  • select_parent：选择父代
  • myga：进行遗传算法，杂交变异
  • combined_pop：子代和原始种群进行合并
  • select_pop：选择新一代种群
  • calculate_gd：计算GD
  • calculate_sp：计算SP
  • calculate_pop：计算种群

其他内容

plotPareto：画出已知前言数据，用于跟测试得到的前言的可视化对比

 如果需要获取已知的ZDT1、ZDT2、ZDT3、ZDT4、ZDT6的前言数据，通过以下链接获取：

ZDT前沿数据.zip-互联网文档类资源-CSDN文库https://download.csdn.net/download/weixin_44034444/73514580

运行注意事项

  1. 在nsga2_test中设置pop_size，iterations。以及测试次数test。nsga2_test可以保存每一个测试函数，每一测试中每一代的种群数据以及GD和SP的数据。主要是为了方便用获取得到的数据进行分析。
  2. 如果只是需要查看nsga2的效果，运行nsga2_main函数，注意pop_size，iterations的设置。

 代码

nsga2_test

  1. clc
  2. clear
  3.  
  4. % 定义全局变量,
  5. global pop_size; 
  6. global iterations;
  7. pop_size = 100;%种群大小
  8. iterations = 500;%迭代次数
  9.  
  10. test = 1; %测试次数
  11.  
  12. for x = 1:5%选择需要计算的函数
  13.     switch x
  14.         case 1
  15.             [~,dim] = get_variable_bounds(x);
  16.             %dim = 10;
  17.             %设置保存参数
  18.             testGD = zeros(test,iterations);
  19.             testSP = zeros(test,iterations);
  20.             testPop = zeros(test,iterations,pop_size,dim+4);
  21.             NSGA2_zdt1 = [];
  22.             disp('正在测试zdt1')
  23.             for i = 1:test
  24.                 disp(['第' num2str(i) '次测试']);
  25.                 [pop,GD,SP] = nsga2_main(x);
  26.                 testGD(i,:) = GD;
  27.                 testSP(i,:) = SP;
  28.                 testPop(i,:,:,:) = pop;      
  29.             end
  30.             NSGA2_zdt1.testGD = testGD;
  31.             NSGA2_zdt1.testSP = testSP;
  32.             NSGA2_zdt1.testPop = testPop;
  33.             save('NSGA2_zdt1.mat','NSGA2_zdt1')
  34.         case 2
  35.             [~,dim] = get_variable_bounds(x);
  36.             %dim = 10;
  37.             %设置保存参数
  38.             testGD = zeros(test,iterations);
  39.             testSP = zeros(test,iterations);
  40.             testPop = zeros(test,iterations,pop_size,dim+4);
  41.             NSGA2_zdt2 = [];
  42.             disp('正在测试zdt2')
  43.             for i = 1:test
  44.                 disp(['第' num2str(i) '次测试']);
  45.                 [pop,GD,SP] = nsga2_main(x);
  46.                 testGD(i,:) = GD;
  47.                 testSP(i,:) = SP;
  48.                 testPop(i,:,:,:) = pop;      
  49.             end
  50.             NSGA2_zdt2.testGD = testGD;
  51.             NSGA2_zdt2.testSP = testSP;
  52.             NSGA2_zdt2.testPop = testPop;
  53.             save('NSGA2_zdt2.mat','NSGA2_zdt2')
  54.        case 3 
  55.             [~,dim] = get_variable_bounds(x);
  56.             %dim = 10;
  57.             %设置保存参数
  58.             testGD = zeros(test,iterations);
  59.             testSP = zeros(test,iterations);
  60.             testPop = zeros(test,iterations,pop_size,dim+4);
  61.             NSGA2_zdt3 = [];
  62.             disp('正在测试zdt3')
  63.             for i = 1:test
  64.                 disp(['第' num2str(i) '次测试']);
  65.                 [pop,GD,SP] = nsga2_main(x);
  66.                 testGD(i,:) = GD;
  67.                 testSP(i,:) = SP;
  68.                 testPop(i,:,:,:) = pop;      
  69.             end
  70.             NSGA2_zdt3.testGD = testGD;
  71.             NSGA2_zdt3.testSP = testSP;
  72.             NSGA2_zdt3.testPop = testPop;
  73.             save('NSGA2_zdt3.mat','NSGA2_zdt3')
  74.         case 4
  75.             [~,dim] = get_variable_bounds(x);
  76.             %dim = 10;
  77.             %设置保存参数
  78.             testGD = zeros(test,iterations);
  79.             testSP = zeros(test,iterations);
  80.             testPop = zeros(test,iterations,pop_size,dim+4);
  81.             NSGA2_zdt4 = [];
  82.             disp('正在测试zdt4')
  83.             for i = 1:test
  84.                 disp(['第' num2str(i) '次测试']);
  85.                 [pop,GD,SP] = nsga2_main(x);
  86.                 testGD(i,:) = GD;
  87.                 testSP(i,:) = SP;
  88.                 testPop(i,:,:,:) = pop;      
  89.             end
  90.             NSGA2_zdt4.testGD = testGD;
  91.             NSGA2_zdt4.testSP = testSP;
  92.             NSGA2_zdt4.testPop = testPop;
  93.             save('NSGA2_zdt4.mat','NSGA2_zdt4')
  94.         case 5
  95.             [~,dim] = get_variable_bounds(x);
  96.             %dim = 10;
  97.             %设置保存参数
  98.             testGD = zeros(test,iterations);
  99.             testSP = zeros(test,iterations);
  100.             testPop = zeros(test,iterations,pop_size,dim+4);
  101.             NSGA2_zdt6 = [];
  102.             disp('正在测试zdt6')
  103.             for i = 1:test
  104.                 disp(['第' num2str(i) '次测试']);
  105.                 [pop,GD,SP] = nsga2_main(x);
  106.                 testGD(i,:) = GD;
  107.                 testSP(i,:) = SP;
  108.                 testPop(i,:,:,:) = pop;      
  109.             end
  110.             NSGA2_zdt6.testGD = testGD;
  111.             NSGA2_zdt6.testSP = testSP;
  112.             NSGA2_zdt6.testPop = testPop;
  113.             save('NSGA2_zdt6.mat','NSGA2_zdt6')
  114.     end
  115.     
  116. end

nsga2_main

  1. function [allpop,GD,SP] = nsga2_main(x)
  2. % 测试主函数 x,问题编号
  3. % 输出种群，GD和SP
  4.  
  5. % 参数设置 
  6. global pop_size
  7. global iterations;%迭代次数
  8. target = 2;
  9.  
  10. % 获取种群范围
  11. [bounds,dimension] = get_variable_bounds(x);
  12. %种群初始化
  13. pop = init_pop(pop_size,dimension,bounds,x);
  14. %种群排序
  15. pop = sort_pop(pop,target,dimension);
  16.  
  17. %锦标赛参数设置
  18. parent_size = pop_size/2;
  19. select_size = 2;
  20.  
  21. % 初始化函数返回数据。
  22. % nsga2_test.m 中需要保存的数据。 如果不跑nsga2_test.m。
  23. GD = zeros(1,iterations);
  24. SP = zeros(1,iterations);
  25. allpop = zeros(iterations,pop_size,dimension+4);%保存进化过程中种群的数据
  26.  
  27. warning off all
  28. %迭代循环
  29. for i = 1:iterations
  30.     %选择父代
  31.     parent_pop = select_parent(pop,parent_size,select_size);
  32.     %进行遗传算法，杂交变异
  33.     child_pop = myga(parent_pop,dimension,bounds,x);
  34.     %子代和原始种群进行合并
  35.     pop = combined_pop(pop,child_pop,target,dimension);
  36.     %对合并种群进行非支配排序
  37.     pop = sort_pop(pop,target,dimension);
  38.     %选择新一代种群
  39.     pop = select_pop(pop,target,dimension,pop_size);
  40.     
  41. %    %画出种群迭代的过程。只运行naga2_main的的时候，可以画出单个测试函数的变化
  42. %     plot(pop(:,dimension+1),pop(:,dimension+2),'*')
  43. %     grid on
  44. %     title(['NSGA2测试第',num2str(x),'个函数第 ',num2str(i),' 代结果'])
  45. %     pause(0.1) 
  46.     
  47.     %保存数据，计算每一代的GD和SP，也可以通过保存allpop后单独计算
  48.     allpop(i,:,:) = pop;
  49.     GD(1,i) = calculate_gd(pop,x);
  50.     SP(1,i) = calculate_sp(pop);
  51. end
  52. end

get_variable_bounds

  1. function [bounds,dimension] = get_variable_bounds(x)
  2. switch x
  3.     case 1
  4.         dimension = 30;
  5.         bounds = [ones(dimension,1)*0,ones(dimension,1)*1];
  6.     case 2
  7.         dimension = 30;
  8.         bounds = [ones(dimension,1)*0,ones(dimension,1)*1];
  9.     case 3
  10.         dimension = 30;
  11.         bounds = [ones(dimension,1)*0,ones(dimension,1)*1]; 
  12.     case 4
  13.         dimension = 10;
  14.         bounds = [zeros(1,1),ones(1,1);ones(9,1).*-5,ones(9,1).*5]; 
  15.     case 5 
  16.         dimension = 10;
  17.         bounds = [ones(dimension,1)*0,ones(dimension,1)*1]; 
  18. end

init_pop

  1. function pop = init_pop(pop_size,dimension,bounds,x)
  2. p = rand(pop_size,dimension);%生成popsize*dimension的0-1矩阵
  3. %生成定义域范围内种群
  4. for i = 1:dimension
  5.     p(:,i) = bounds(i,1)+p(:,i)*(bounds(i,2)-bounds(i,1));
  6. end
  7. %计算种群的适应值
  8. evaluate = calculate_pop(p,x);
  9. pop = [p,evaluate];

sort_pop

  1. function pop = sort_pop(pop_eva,target,dimension)
  2. [N, ~] = size(pop_eva);
  3. front = 1;
  4. F(front).f = [];
  5. individual = [];
  6. %先确定等级为1的个体以及被支配的集合
  7. for i = 1:N
  8.     individual(i).n = 0; %支配i的个体个数
  9.     individual(i).p = [];%被个体i支配的个体集合
  10.     for j = 1:N
  11.         less = 0;  %判断i是否可以支配j
  12.         equal = 0; %判断i是否等于j，序号相同时相等
  13.         more = 0;  %判断i是否被j支配
  14.         for k = 1:target %在每一个目标函数中判断支配关系
  15.             if pop_eva(i,dimension+k) < pop_eva(j,dimension+k)
  16.                 less = less+1;
  17.             elseif pop_eva(i,dimension+k) == pop_eva(j,dimension+k)
  18.                 equal = equal+1;
  19.             else 
  20.                 more = more + 1;
  21.             end
  22.         end
  23.         if less == 0 && equal ~= target
  24.             individual(i).n = individual(i).n + 1;
  25.         elseif more == 0 && equal ~= target
  26.             individual(i).p = [individual(i).p j];
  27.         end
  28.     end
  29.     if individual(i).n == 0
  30.         pop_eva(i,target+dimension+1) = 1;
  31.         F(front).f = [F(front).f i];
  32.     end
  33. end
  34.  
  35. %对对所有种群所有个体进行等级划分
  36. while ~isempty(F(front).f)
  37.     Q = [];
  38.     for i = 1:length(F(front).f) %等级为1的长度
  39.         if ~isempty(individual(F(front).f(i)).p) %等级为1的个体中查找其所支配的个体
  40.             for j = 1:length((individual(F(front).f(i)).p))%当前个体等级为1的个体所支配的个体数量
  41.                 individual(individual(F(front).f(i)).p(j)).n = ...
  42.                     individual(individual(F(front).f(i)).p(j)).n - 1;
  43.            if individual(individual(F(front).f(i)).p(j)).n == 0
  44.                     pop_eva(individual(F(front).f(i)).p(j),target + dimension + 1) = front + 1;
  45.                     Q = [Q individual(F(front).f(i)).p(j)]; %记录下一等级的集合
  46.                 end                 
  47.             end
  48.         end
  49.     end
  50.     front =  front + 1;
  51.     F(front).f = Q; 
  52. end
  53.  
  54. %排序
  55. [~, index_front] = sort(pop_eva(:,target + dimension +1));%根据等级对个体进行排序
  56. sort_front = zeros(size(pop_eva));
  57. for i = 1 : length(index_front)
  58.     sort_front(i,:) = pop_eva(index_front(i),:); %排序后的结果
  59. end
  60.  
  61. current_index = 0; %当前下标。
  62.  
  63. %计算拥挤距离
  64. for  front = 1 : (length(F)-1)
  65.     distance = 0;
  66.     y =[];
  67.     previous_index = current_index + 1;
  68.     for i = 1 : length(F(front).f)
  69.         y(i,:) = sort_front(current_index + i,:);
  70.     end
  71.     current_index = current_index + i;
  72.     sorted_based_on_objective = [];
  73.     %函数值排序
  74.     for i = 1 : target
  75.         %函数值排序
  76.         [sorted_based_on_objective, index_of_objectives] = sort(y(:,dimension + i));
  77.         sorted_based_on_objective = [];
  78.         for j = 1 : length(index_of_objectives)
  79.             sorted_based_on_objective(j,:) = y(index_of_objectives(j),:);
  80.         end
  81.         f_max = ...
  82.             sorted_based_on_objective(length(index_of_objectives), dimension + i);
  83.         f_min = sorted_based_on_objective(1, dimension + i);
  84.         y(index_of_objectives(length(index_of_objectives)),target + dimension + 1 + i)...
  85.             = Inf;
  86.         y(index_of_objectives(1),target + dimension + 1 + i) = Inf;
  87.         for j = 2 : length(index_of_objectives) - 1
  88.            next_obj  = sorted_based_on_objective(j + 1,dimension + i);
  89.            previous_obj  = sorted_based_on_objective(j - 1,dimension + i);
  90.            if (f_max - f_min == 0)
  91.                y(index_of_objectives(j),target + dimension + 1 + i) = Inf;
  92.            else
  93.                y(index_of_objectives(j),target + dimension + 1 + i) = ...
  94.                     (next_obj - previous_obj)/(f_max - f_min);
  95.            end
  96.         end
  97.     end
  98.     distance = [];
  99.     distance(:,1) = zeros(length(F(front).f),1);
  100.     for i = 1 : target
  101.         distance(:,1) = distance(:,1) + y(:,target + dimension + 1 + i);
  102.     end
  103.     y(:,target + dimension + 2) = distance;
  104.     y = y(:,1 : target + dimension + 2);
  105.     z(previous_index:current_index,:) = y;
  106. end
  107. pop  = z();

select_parent

  1. function parent_pop = select_parent(pop,parent_size,compare_size)
  2. %父代个体的选择
  3. [pop_size,distance] = size(pop);
  4. rank = distance-1; %记录等级所在的列
  5. select_pop = zeros(compare_size,distance);
  6.  
  7. for i = 1:parent_size
  8.     %生成参与锦标赛的个体序列
  9.     parent_list = randperm(pop_size,compare_size);
  10.     %参与锦标赛的个体集合
  11.     for j = 1:compare_size
  12.         select_pop(j,:) = pop(parent_list(j),:);
  13.     end
  14.     [min_rank,min_rank_index] = min(select_pop(:,rank));
  15.     if length(min_rank)==1
  16.         parent_pop(i,:) = select_pop(min_rank_index,:);
  17.     else
  18.         %最小等级相同的个体集合
  19.         for k = 1:length(min_rank)
  20.             select_pop1(k,:) = select_pop(min_rank_index(k),:);
  21.         end
  22.         [~,max_distance_index] = max(select_pop1(:,distance));
  23.         parent_pop(i,:) = select_pop1(max_distance_index(1),:);
  24.     end
  25. end

myga

  1. function child_pop = myga(parent_pop,dimension,bounds,x)
  2. %GA算法
  3. parent_pop = sortrows(parent_pop,[2+dimension+1,-(2+dimension+2)]);
  4. parent_pop = parent_pop(:,1:dimension);
  5. [popsize,~] = size(parent_pop);
  6. %定义交叉变异的概率
  7. crossover = 1;
  8. mutation = 1;
  9. nc=20;
  10. child = [];
  11.  
  12.  
  13. for i = 1:popsize
  14.     c_r = rand(1);
  15.     m_r = rand(1);
  16.     %交叉变换
  17.     if c_r < crossover
  18.         %随机选择一个个体与该个体进行杂交
  19.         p1 = randperm(popsize,1); 
  20.         parent1 = parent_pop(p1,:);
  21.         parent2 = parent_pop(i,:);
  22.            
  23.         % 多项式杂交
  24.         child1 = zeros(1,dimension);
  25.         child2 = zeros(1,dimension);
  26.         for j = 1:dimension
  27.             r = rand(1);
  28.             if r <= 0.5
  29.                 a = (2*r)^(1/(nc+1));
  30.             else
  31.                 a= (2*(1-r))^(-(1/(nc+1)));
  32.             end
  33.             
  34.             child1(j) = ((1+a)*parent1(j) + (1-a)*parent2(j))/2;
  35.             child2(j) = ((1-a)*parent1(j) + (1+a)*parent2(j))/2;
  36.             
  37.             if child1(j) > bounds(j,2)
  38.                 child1(j) = bounds(j,2);
  39.             elseif child1(j) < bounds(j,1)
  40.                 child1(j) = bounds(j,1);
  41.             end
  42.             if child2(j) > bounds(j,2)
  43.                 child2(j) = bounds(j,2);
  44.             elseif child2(j) < bounds(j,1)
  45.                 child2(j) = bounds(j,1);
  46.             end
  47.         end
  48.         child = [child;child1;child2];
  49.     end
  50.     if m_r < mutation
  51.         child3=parent_pop(i,:);
  52.         for k = 1:dimension
  53.             r = rand();
  54.             if r<0.5
  55.                 m = (2*r)^(1/21)-1;
  56.             else
  57.                 m = 1 - (2*(1 - r))^(1/(21));
  58.             end
  59.             child3(1,k) = child3(1,k)+m;
  60.             if child3(1,k)>bounds(k,2)
  61.                 child3(1,k) = bounds(k,2);
  62.             end
  63.             if child3(1,k)<bounds(k,1)
  64.                 child3(1,k) = bounds(k,1);
  65.             end
  66.         end  
  67.         child = [child;child3];
  68.     end
  69. end
  70. child_pop = child(:,1:dimension);
  71. child_eva = calculate_pop(child_pop,x);
  72. child_pop = [child_pop,child_eva];

combined_pop

  1. function pop = combined_pop(pop,child_pop,target,dimension)
  2. %合并父代和子代个体
  3. pop1 = pop(:,1:target+dimension);
  4. clear pop
  5. pop = [pop1;child_pop];

select_pop

  1. function pop = select_pop(pop,target,dimension,pop_size)
  2. [popsize,~] = size(pop);
  3. sort_pop = sortrows(pop,[target+dimension+1,-(target+dimension+2)]);
  4. s_pop = [];
  5. no_index = [];
  6. num = 0;
  7. if popsize > pop_size
  8.     %根据等级对pop进行升序排序，对拥挤距离进行降序排序   
  9.     for i = 1:popsize-1
  10.         a = sort_pop(i,dimension+1:dimension+2);
  11.         b = sort_pop(i+1,dimension+1:dimension+2);
  12.         if norm(a-b)>1e-10
  13.             s_pop = [s_pop;sort_pop(i,:)];
  14.             num = num+1;
  15.             if num == pop_size
  16.                 break;
  17.             end
  18.         else
  19.             no_index = [no_index;i];
  20.         end    
  21.     end
  22.     if size(s_pop,1)< pop_size
  23.         n = pop_size - size(s_pop,1);
  24.         for j = 1:n
  25.             s_pop = [s_pop;sort_pop(no_index(j),:)];
  26.         end
  27.     end
  28.     pop = s_pop;
  29. end

calculate_gd

  1. function GD = calculate_gd(pop,x)
  2.  
  3. switch x
  4.     case 1
  5.         y = importdata('前沿数据/ZDT1.txt');
  6.     case 2
  7.         y = importdata('前沿数据/ZDT2.txt');
  8.     case 3
  9.         y = importdata('前沿数据/ZDT3.txt');
  10.     case 4
  11.         zdt4 = importdata('前沿数据/ZDT4.txt');
  12.         y = sortrows(zdt4,[1,2]);
  13.     case 5 
  14.         y = importdata('前沿数据/ZDT6.txt');
  15. end
  16. %pop测试结果，y真实值
  17. GD = 0;
  18. [n,d] = size(pop);
  19. pop = pop(:,d-3:d-2);
  20.  
  21. for i = 1:n
  22.     dis = pdist2(pop(i,:),y,'euclidean');
  23.     gd = (min(dis))^2;  
  24. %     gd = min(dis);  
  25.     GD = GD + gd;
  26. end
  27. GD = sqrt(GD/n);
  28. % GD = GD/n
  29. end

calculate_sp

  1. function SP = calculate_sp(pop)
  2. [x,y] = size(pop);
  3. pop = pop(:,y-3:y-2);
  4.  
  5. mindis = zeros(x,1);
  6.  
  7. for i = 1:x
  8.     di = pop(i,:);
  9.     dis = pdist2(di,pop,'euclidean');
  10.     dis = sort(dis);
  11.     mindis(i) = dis(2);
  12. end
  13. meandis = mean(mindis);
  14. Sp = 0;
  15. for j = 1:x
  16.     sp = (meandis-mindis(j))^2;
  17.     Sp = Sp + sp;
  18. end
  19. SP = sqrt(Sp/x)/meandis;

calculate_pop

  1. function evaluate = calculate_pop(pop,x)
  2. %测试函数
  3. [~,dim] = size(pop);
  4. switch x
  5.     case 1  %ZDT1
  6.         fx1 = pop(:,1); 
  7.         gx = 1+sum(pop(:,2:end),2).*(9/(dim-1));
  8.         hx = 1-sqrt(fx1./gx);
  9.         fx2 = gx.*hx;
  10.         evaluate = [fx1,fx2];
  11.     case 2  %ZDT2
  12.         fx1 = pop(:,1); 
  13.         gx = 1+sum(pop(:,2:end),2).*(9/(dim-1));
  14.         hx = 1-(fx1./gx).^2;
  15.         fx2 = gx.*hx;
  16.         evaluate = [fx1,fx2];       
  17.     case 3  %ZDT3
  18.         fx1 = pop(:,1); 
  19.         gx = 1+sum(pop(:,2:end),2).*(9/(dim-1));
  20.         hx = 1-sqrt(fx1./gx)-(fx1./gx).*sin(10*pi.*fx1);
  21.         fx2 = gx.*hx;
  22.         evaluate = [fx1,fx2];
  23.     case 4  %ZDT4
  24.        fx1 = pop(:,1); 
  25.        gx = 91+sum((pop(:,2:dim).^2-10.*cos(4*pi.*pop(:,2:dim))),2);
  26.        hx = 1-sqrt(fx1./gx);
  27.        fx2 = gx.*hx;
  28.        evaluate = [fx1,fx2];
  29.        
  30.     case 5
  31.         x1 = pop(:,1);
  32.         fx1 = 1-exp(-4.*x1).*(sin(6*pi.*x1)).^6;
  33.         s = sum(pop(:,2:end),2);
  34.         gx = 1+9/(dim-1).*s;
  35.         hx = 1-(fx1./gx).^2;
  36.         fx2 = gx.*hx;
  37.         evaluate = [fx1,fx2];
  38.     case 6
  39.         n = -sum((pop-1/sqrt(dim)).^2,2);
  40.         m = -sum((pop+1/sqrt(dim)).^2,2);
  41.         fx1 = 1-exp(n);
  42.         fx2 = 1-exp(m);
  43.         evaluate = [fx1,fx2];
  44. end

plotPareto

  1. function plotPareto(x)
  2. switch x
  3.     case 1
  4.         zdt1 = importdata('前沿数据/ZDT1.txt');
  5.         hold on
  6.         plot(zdt1(:,1),zdt1(:,2),'-')
  7.         legend('改进NSGA2测试前沿','理想前沿')
  8.       
  9.     case 2
  10.         zdt2 = importdata('前沿数据/ZDT2.txt');
  11.         hold on
  12.         plot(zdt2(:,1),zdt2(:,2),'-')
  13.         legend('测试前沿','已知前沿')
  14.         
  15.     case 3
  16.         zdt3 = importdata('前沿数据/ZDT3.txt');
  17.         hold on
  18.         plot(zdt3(:,1),zdt3(:,2),'*')
  19.         legend('测试前沿','已知前沿')
  20.         
  21.     case 4
  22.         zdt4 = importdata('前沿数据/ZDT4.txt');
  23.         zdt4 = sortrows(zdt4,[1,2]);
  24.         hold on
  25.         plot(zdt4(:,1),zdt4(:,2),'-')
  26.         legend('测试前沿','已知前沿')
  27.         
  28.     case 5
  29.         zdt6 = importdata('前沿数据/ZDT6.txt');
  30.         hold on
  31.         plot(zdt6(:,1),zdt6(:,2),'-')
  32.         legend('测试前沿','已知前沿')
  33.     otherwise
  34.        fprintf('错误')
  35. end
  36. end

运行结果

运行过程

保存的数据 

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览48554 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪