C-TAEA算法和代码一对一对应

avatar 2024年08月02日10:04:15 0 285 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此

仅供参考，可能会有因为马虎或者认识导致的错误

欢迎讨论

一、UpdateCA

 
 
1、非支配排序
 
2、按前沿顺序加入

3、将个体S进行标准化

4、求个体S的所在区域，返回区域索引

5、找最拥挤的区域，即该区域个体最多的

6、求最拥挤区域内个体之间的距离矩阵

 
 
7、求拥挤集合内距离最近的2个解

8、求个体到其权重向量之间的切比雪夫距离，求最远的距离为最差解

9、从S中剔除最差解

10、求不可行解集合

11、对不可行解进行ND排序

12、按前沿顺序，逐个添加SI中的解到S中

13、剔除last前沿中多加的

 
 
 

二、UpdateDA

 
 
1、非支配排序

2、遍历每个区域，
如果该区域的可行解少于1个，则需要操作

3、判断不可行解中该区域是否有解

4、对该区域不可行解进行非支配排序，
获取第一前沿数据，记作个体O

5、求个体O到其权重向量的切比雪夫距离，
获取最短的距离为最佳

6、添加不可行解中的最佳个体

7、从不可行解Hd中移除刚刚选择的解

 
 
 

三、MatingSelection

1、分别求CA和DA中非支配解个数

 
 

四、TournamentSelection

1、随机生成2个解

2、比较两个解的支配关系

3、1个不可行解
或者2个都是不可行解时

 
 
 

五、Association Process

1、求每个个体S到W之间最短距离的向量。
即找每个个体S的区域

 

六、完整代码

仅供参考，代码没有完整运行，仅用于理解算法流程

% C-TAEA
% 1. 主流程
function main(Algorithm, Problem)
	[W, Problem.N] = UniformPoint(Problem.N, Problem.M);
	Population = Problem.Initialzation();
	CA = UpdateCA([], Population, W);
	DA = UpdateDA(CA, [], Population, W);

	while Algorithm.NotTemplated(CA)

		Q = [];
		for i = 1: size(W, 1)
			MatingPool = MatingPoolSelection(CA, DA);
			OffSpring = OperatorGAhalf(Problem, MatingPool);
			Q = [Q, OffSpring];
		end

		CA = UpdateCA(CA, Q, W);
		DA = UpdateDA(CA, DA, Q, W);
	end
end

% 2. 获取交配池(父代)
function MatingPool = MatingPoolSelection(CA, DA)
	Hm = [CA, DA];
	[FrontNo, ~] = NDSort(Hm.objs, inf);

	FrontNo_C = FrontNo(1:ceil(length(Hm) / 2));
	FrontNo_D = FrontNo(ceil(length(Hm) / 2)+1, length(Hm));

	Pc = sum(FrontNo_C == 1) / length(Hm);
	Pd = sum(FrontNo_D == 1) / length(Hm);

	if Pc > Pd
		p1 = TournamentSelection(CA);
	else
		p1 = TournamentSelection(DA);
	end

	if rand() < Pc
		p2 = TournamentSelection(CA);
	else
		p2 = TournamentSelection(DA);
	end	
	MatingPool = [p1, p2];
end

function result = TournamentSelection(Population)
	N = length(Population);
	rnd = randi(N, 1, 2);
	x1 = rnd(1);
	x2 = rnd(2);
	CV1 = sum(max(Population(x1).cons, 0), 2);
	CV2 = sum(max(Population(x2).cons, 0), 2);

	if CV1 == 0 && CV2 == 0
		[FrontNo, ~] = NDSort(Population(rnd).objs, inf);
		if FrontNo(1) < FrontNo(2)
			result = Population(x1);
		elseif FrontNo(2) < FrontNo(1)
			result = Population(x2);
		else
			result = Population(rnd(randi(2)));
		end
	elseif CV1 == 0 && CV2 > 0		
		result = Population(x1);
	elseif CV1 > 0 && CV2 == 0
		result = Population(x2);
	else
		number = randi(2);
		result = Population(rnd(number));
	end
end

% 3. UpdateCA
function UpdatedCA=UpdateCA(CA,Q,W)   
    % 【更新CA，从Hc中获取优质可行解，如果可行解不足，则获取优质不可行解】

    S=[];        % 初始化用于输出的解集合
    Sc=[];       % 初始化用于收集满足约束的可行解集合
    Hc=[CA,Q];   % 将当前存档和后代合并，用于接下来的操作
    N=size(W,1); % 权重向量的数量，通常等同于需要维持的解的数量

    for i = 1:length(Hc)
        if sum(max(Hc(i).con, 0)) == 0 % 等价于 if all(Hc(i).con <= 0)
            Sc = [Sc, Hc(i)];
        end
    end

    if length(Sc)==N 
        UpdatedCA=Sc; % 如果可行解数量正好等于N，直接使用这些解作为新的CA

    elseif length(Sc)>N  % 可行解过多，需要裁剪
        % 1. 优先添加帕累托前沿靠前的解
        [FrontNO, MaxFNo] = NDSort(Sc.objs,inf);  
		for i = 1 : MaxFNo
			S = [S, Sc(FrontNO == i)];
			if length(S) >= N
				break;
			end
		end	

        % 2. 添加多了，就裁剪
        while length(S)>N 
            % 2.1 标准化目标函数值以进行距离计算
            Zmax=max(S.objs,[],1);
            Zmin=min(S.objs,[],1);
            SPopObj=(S.objs-Zmin)./(Zmax-Zmin);

             % 2.2 将解关联到最近的权重向量
             % 求每个解对应的区域(最相似的，距离最近的)
            [~,Region] = min(pdist2(SPopObj, W,'cosine'), [], 2);  % 求S中每个解对应的权重向量(距离最近的)索引

            counter = histcounts(Region, 1:max(Region)+1); % 计算每个子区域的解数量

            % 2.3 最拥挤区域的识别
            [~,most_crowded]=max(counter); % 找出最拥挤的子区域
            S_crowdest=S(Region==most_crowded);  % 选出该子区域中的所有解
            dist=pdist2(S_crowdest.objs,S_crowdest.objs); % 计算解之间的距离，欧式距离                    
            dist(dist==0)=inf; % 将距离矩阵中的对角线元素（自身与自身的距离）设置为无穷大，以避免后续操作中将自己与自己视为最近的解。
            [row,~]=find(min(min(dist))==dist); % 找到最近的解对（最近的2个解）
            St=S_crowdest(row);  % 选择距离最近的解，2个解

            % 2.4 计算切比雪夫距离
            [~,Region_St] = min(pdist2(St.objs,W,'cosine'),[],2);
            Z = min(St.objs,[],1);
            distance=max(abs(St.objs-Z) ./ W(Region_St,:),[],2);
            [~,index]=max(distance);  % 找出具有最大切比雪夫距离的解

            % 2.5 选择并移除最差的解 【最差的解，就是拥挤距离最大的2个解，距离他们权重向量距离最远的解】
            % 筛选拥挤距离最大的解，目的是减少拥挤度，增加解的多样性
            % 筛选离权重向量远的解，目的是期望解朝着权重向量方向移动
            x_wrost=St(index);     % 选择最差的解以移除
            S=setdiff(S, x_wrost);  % 从集合中移除最差的解
        end
        UpdatedCA=S;

    elseif length(Sc)<N % 可行解不足，需要补充一些优质不可行解(帕累托前沿靠前的，同一个前沿取约束小的)
        % 1. 先添加可行解
        S = [S, Sc];

        % 2. 根据前沿顺序添加
        SI = setdiff(Hc,Sc);	% 找出不满足约束的解集  

        % f1, 约束违反程度
        CV = sum(max(SI.cons, 0),2);  
        % f2，个体与权重向量之间的切比雪夫距离
        [~,Region_SI] = min(pdist2(SI.objs,W,'cosine'),[],2); 
        Z = min(SI.objs,[],1) ;
        Distance = max(abs(SI.objs - Z) ./ W(Region_SI,:),[],2);
        PopObj=[CV, Distance];  
        % 对不满足约束的解进行非支配排序
        [FrontNO, MaxFNo]= NDSort(PopObj, inf);  

        % 全部是不可行解，不能使用这个
        % [FrontNO, MaxFNo] = NDSort(SI.objs, SI.cons); 

		for i = 1 : MaxFNo
			S = [S, SI(FrontNO == i)];
			if length(S) >= N
				last = i;
				break;
			end
		end	

        % 3. 批量删除多余的(last前沿中多加的)
        Last = SI(FrontNO == last);
        CV = sum(max(Last.cons, 0),2); % 剔除约束违反程度大的
        [~, index] = sort(CV, 'descend');
        x_wrost = Last(index(1:length(S) - N)); 
        S = setdiff(S, x_wrost);

        UpdatedCA=S; 
        
    end
end

% 4. UpdateDA
function UpdatedDA=UpdateDA(CA,DA,Q,W)
    % 【更新DA，遍历所有权重向量对应的区域，如果某个区域的CA个数较少，优先从Hd的对应区域中获取最优个体，
    %  加入到S中，同时从Hd中剔除最优个体，循环】
    S=[];           % 初始化输出集合 S
    Hd=[DA,Q];      % 将多样性存档和后代合并为一个新的集合 Hd
    N=size(W,1);    % 获取权重向量的数量，定义所需的存档大小

    [~, Region_Hd] = min(pdist2(real(Hd.objs), W, 'cosine'),[],2);
    [~, Region_CA] = min(pdist2(CA.objs, W, 'cosine'),[], 2);

    itr=1;
    while length(S)<N

        % 判断每个区域
        for i = 1 : N
            % 如果该区域可行解数量少于1 (即itr)个，则从当前区域里的Hd中补充
            if sum(Region_CA == i) < itr 

                for j = 1 : itr - sum(Region_CA == i)
                	% 如果Hd中该区域也没有解，则提前结束该区域
                    if sum(Region_Hd == i) ==  0 
                        break;
                    end	
                    
                    % 从Hd中的当前区域的第一前沿(非支配解)中选择
                    St = Hd(Region_Hd == i);
                    [FrontNO, ~] = NDSort(St.objs, inf);
                    O = St(FrontNO == 1);

                    % 求切比雪夫距离最短的解
                    [~, Region_O] = min(pdist2(O.objs, W, 'cosine'), [], 2);
                    Z = min(O.objs, [], 1);
                    distance = max(abs(O.objs - Z) ./ W(Region_O,:), [], 2);
                    [~,index] = min(distance);
                    x_best = O(index);

                    if length(S) < N
                        S = [S, x_best];
                    end

                    % 从Hd中移除x_best
                    Hd = setdiff(Hd, x_best);
                    % 更新Region_Hd
                    if ~isempty(Hd)
                        [~, Region_Hd] = min(pdist2(real(Hd.objs),W,'cosine'),[],2);
                    else
                        Region_Hd = [];
                    end    
               end
            end

            if length(S) ==N   % 如果 S 的长度达到 N，跳出外层循环
                break;
            end

        end
        itr = itr + 1;
    end
    UpdatedDA=S;
end

 

 

历史上的今天
八月
02日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0