找回密码
 注册
关于网站域名变更的通知
查看: 501|回复: 1
打印 上一主题 下一主题

NSGA-II快速非支配排序算法理解

[复制链接]

该用户从未签到

跳转到指定楼层
1#
发表于 2020-10-10 17:26 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

EDA365欢迎您登录!

您需要 登录 才可以下载或查看,没有帐号?注册

x

1 o9 n$ }9 n6 j6 \% l" z- t快速的非支配排序2 W; k8 g8 `6 u) E
& K& F- V' j$ @, P6 k# i
在NSGA进行非支配排序时,规模为N的种群中的每个个体都要针对M个目标函数和种群中的N-1个个体进行比较,复杂度为O(MN),因此种群中的N个个体都比较结束的复杂度为O(MN2),即每进行一次Pareto分级的时间复杂度为O(MN2)。在最坏的情况下,每个Pareto级别都只含有一个个体,那么需要进行N次分级所需要的时间复杂度则会上升为O(MN3)。鉴于此,论文中提出了一种快速非支配排序法,该方法的时间复杂度为O(MN2)。
/ `  v# K$ R$ F3 k
! \" p  h2 c+ q( R5 z该算法需要保存两个量:  D& v# a+ U7 l, _8 \4 c
: N% ]5 ~  `; Y
(1).支配个数np。该量是在可行解空间中可以支配个体p的所有个体的数量。3 E6 H" G' s. }5 s" \

8 v) w& r: D/ B% ^# \(2).被支配个体集合SP。该量是可行解空间中所有被个体p支配的个体组成的集合。" j# P* Z7 s/ P. P7 a- _3 W/ F
* t) u* K2 Z+ O/ m( U* H
下面是fast_nondominated_sort的伪代码0 m2 ^- ]" m' L' _$ C( c

* c: O( {$ b2 o# v7 \! Z- n& V
  • def fast_nondominated_sort( P ):
  •     F = [ ]
  •     for p in P:
  •         Sp = [ ]
  •          np = 0
  •          for q in P:
  •              if p > q:                #如果p支配q,把q添加到Sp列表中
  •                  Sp.append( q )
  •              else if p < q:        #如果p被q支配,则把np加1
  •                  np += 1
  •         if np == 0:
  •             p_rank = 1        #如果该个体的np为0,则该个体为Pareto第一级
  •       F1.append( p )
  •     F.append( F1 )
  •     i = 0
  •     while F:
  •         Q = [ ]
  •         for p in F:
  •             for q in Sp:        #对所有在Sp集合中的个体进行排序
  •                 nq -= 1
  •                 if nq == 0:     #如果该个体的支配个数为0,则该个体是非支配个体
  •                     q_rank = i+2    #该个体Pareto级别为当前最高级别加1。此时i初始值为0,所以要加2
  •                     Q.append( q )
  •         F.append( Q )
  •         i +=1
    : d. ^' w8 \  u9 p1 Z

* P0 H1 _/ T6 K) `+ V! j+ V/ a% ~2 V5 Y
下面是C++实现:' D. S! M, J3 j7 ?) v. F/ g2 v
0 L1 S" e7 O; [2 H$ W/ k# D
  • void population::nodominata_sort()
  • //求pareto解(快速非支配排序)
  • {
  •     int i,j,k;
  •     indivial H[2*popsize];
  •     int h_len=0;
  •     for(i=0;i<2*popsize;i++)
  •     {
  •         R.np=0;//支配个数np
  •         R.is_domied=0;//被支配的个数
  •         len=0;//初始化
  •     }
  •     for(i=0;i<2*popsize;i++)
  •     {
  •         for(j=0;j<2*popsize;j++)
  •         {
  •             if(i!=j)//自己不能支配自身
  •             {
  •                 if(is_dominated(R,R[j]))
  •                 {
  •                     R.domi[R.is_domied++]=j;
  •                     //如果i支配j,把i添加到j的is_domied列表中
  •                 }
  •                 else if(is_dominated(R[j],R))
  •                     R.np+=1;
  •                     //如果i被j支配,则把np加1
  •             }
  •         }
  •         if(R.np==0)//如果该个体的np为0,则该个体为Pareto第一级
  •         {
  •             len_f=1;
  •             F[0][len[0]++]=R;//将R归并
  •         }
  •     }
  •     i=0;
  •     while(len!=0)
  •     {
  •         h_len=0;
  •         for(j=0;j<len;j++)
  •         {
  •             for(k=0;k<F[j].is_domied;k++)
  •             //对所有在is_domied集合中的个体进行排序
  •             {
  •                 R[F[j].domi[k]].np--;
  •                 if( R[F[j].domi[k]].np==0)
  •                 //如果该个体的支配个数为0,则该个体是非支配个体
  •                 {
  •                     H[h_len++]=R[F[j].domi[k]];
  •                     R[F[j].domi[k]].rank=i+1;
  •                 }
  •             }
  •         }
  •         i++;
  •         len=h_len;
  •         if(h_len!=0)
  •         {
  •             len_f++;
  •             for(j=0;j<len;j++)
  •             {
  •                 F[j]=H[j];
  •             }
  •         }
  •     }
  • }
    3 @4 `  d, o" `2 I& H( d
+ |/ r8 j- @8 X. k* \* y4 @" t# x- B
" A  w1 I  @' ?2 R0 Z/ T: L- p. l) |1 |
matlab代码:" i% F) ?# X( M
% @: [- r! ~) P/ S
  • %-------非支配排序
  •         fnum=0;                                             %当前分配的前沿面编号
  •         cz=false(1,size(functionvalue,1));                  %记录个体是否已被分配编号
  •         frontvalue=zeros(size(cz));                         %每个个体的前沿面编号
  •         [functionvalue_sorted,newsite]=sortrows(functionvalue);    %对种群按第一维目标值大小进行排序
  •         while ~all(cz)                                      %开始迭代判断每个个体的前沿面,采用改进的deductive sort
  •             fnum=fnum+1;
  •             d=cz;
  •             for i=1:size(functionvalue,1)
  •                 if ~d(i)
  •                     for j=i+1:size(functionvalue,1)
  •                         if ~d(j)
  •                             k=1;
  •                             for m=2:size(functionvalue,2)
  •                                 if functionvalue_sorted(i,m)>functionvalue_sorted(j,m)
  •                                     k=0;
  •                                     break
  •                                 end
  •                             end
  •                             if k
  •                                 d(j)=true;
  •                             end
  •                         end
  •                     end
  •                     frontvalue(newsite(i))=fnum;
  •                     cz(i)=true;
  •                 end
  •             end
  •         end! a3 ~& A2 [' q' m. b4 b
5 h2 |! \" e9 |9 b9 G( q3 e6 D

8 [3 i( \3 b( `0 [& l3 D NSGA2具体算法实现还在编写中。

该用户从未签到

2#
发表于 2020-10-10 18:32 | 只看该作者
NSGA-II快速非支配排序算法理解
您需要登录后才可以回帖 登录 | 注册

本版积分规则

关闭

推荐内容上一条 /1 下一条

EDA365公众号

关于我们|手机版|EDA365电子论坛网 ( 粤ICP备18020198号-1 )

GMT+8, 2025-11-2 22:29 , Processed in 0.125000 second(s), 23 queries , Gzip On.

深圳市墨知创新科技有限公司

地址:深圳市南山区科技生态园2栋A座805 电话:19926409050

快速回复 返回顶部 返回列表