MONBM_MOEA_templet.py

# -*- coding: utf-8 -*-
import geatpy as ea  # 导入geatpy库
import MONBM_Algorithm
from MONBM_reproduction import Crossover_NN, Mutation_NN

import os
import numpy as np
import copy
import SRA
import time


class MONBM_MOEA_templet(MONBM_Algorithm.MoeaAlgorithm):
    """
moea_NSGA3_templet : class - 多目标进化优化NSGA-III算法类

算法描述:
    采用NSGA-III进行多目标优化。
    注意：在初始化染色体时，种群规模会被修正为NSGA-III所用的参考点集的大小。

参考文献:
    [1] Deb K , Jain H . An Evolutionary Many-Objective Optimization Algorithm
    Using Reference-Point-Based Nondominated Sorting Approach, Part I:
    Solving Problems With Box Constraints[J]. IEEE Transactions on
    Evolutionary Computation, 2014, 18(4):577-601.

    """

    def __init__(self, problem, population, MAXGEN=None, muta_mu=0, muta_var=0.001, mutation_p=0.2, crossover_p=0.8,
                 objectives=None, run_id=0, logTras=None, verbose=None, drawing=None, dirName=None, nbm_model=None,
                 base_num=100, all_partial_training=False):
        # 先调用父类构造方法
        super().__init__(problem, population)
        if population.ChromNum != 1:
            raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
        self.name = 'MONBM_MOEA'
        if self.problem.M < 10:
            self.ndSort = ea.ndsortESS  # 采用ENS_SS进行非支配排序
        else:
            self.ndSort = ea.ndsortTNS  # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
        self.selFunc = 'tour'  # 选择方式，采用锦标赛选择

        # TODO 交叉变异
        self.recOper = Crossover_NN(crossover_p, problem.all_optimized)
        self.mutOper = Mutation_NN(mu=muta_mu, var=muta_var, p=mutation_p, all_optimized=problem.all_optimized)

        self.objectives_class = objectives
        self.run_id = run_id
        self.mutation_p = mutation_p
        self.crossover_p = crossover_p
        self.muta_mu = muta_mu
        self.muta_var = muta_var
        self.nbm_model = nbm_model
        self.base_num = base_num
        self.all_partial_training = all_partial_training

    def reinsertion(self, population, offspring, NUM):
        if len(self.problem.list_objs) == 1:
            # 父子两代合并
            population = population + offspring

            # 找出目标值优的n个个体
            chooseFlag = np.argsort(population.ObjV.flatten())[:NUM]
            return population[chooseFlag], chooseFlag
        else:
            # 父子两代合并
            population = population + offspring

            # SRA
            [levels, criLevel] = self.ndSort(population.ObjV, NUM, None, population.CV,
                                             self.problem.maxormins)  # 对NUM个个体进行非支配分层
            ObjV = copy.deepcopy(population.ObjV)
            chooseFlag = SRA.SRA_env_selection(ObjV, NUM, levels)
            return population[chooseFlag], chooseFlag

    def run(self, prophetPop=None, file_path=None):
        base_res_path = 'Result/{}/'.format(self.problem.dataname)
        if not os.path.exists(base_res_path):
            os.makedirs(base_res_path)
        # ==========================初始化配置===========================
        population = self.population
        NIND = population.sizes
        self.initialization()  # 初始化算法类的一些动态参数
        # ===========================准备进化============================
        population.initChrom(NIND)  # 初始化种群染色体矩阵
        self.call_aimFunc(population)  # 计算种群的目标函数值
        population.save(file_path + '/0')

        # ===========================开始进化============================
        while not self.terminated(population):
            start = time.time()
            K_num = 3
            MOEA_sel_num = NIND - K_num * len(self.problem.list_objs)

            better_parents_idx = list(np.random.choice(NIND, MOEA_sel_num, replace=False))

            offspring_better = population[better_parents_idx].copy()

            """ exploitation """
            if self.crossover_p > 0:
                offspring_better.Chrom[0:np.int32(np.floor(MOEA_sel_num / 2) * 2)] = self.recOper.do(
                    offspring_better.Chrom[0:np.int32(np.floor(MOEA_sel_num / 2))],
                    offspring_better.Chrom[np.int32(np.floor(MOEA_sel_num / 2)):np.int32(np.floor(MOEA_sel_num / 2) * 2)],
                    np.random.uniform(0, 1, 1))
            offspring_better.Chrom = self.mutOper.do(offspring_better.Chrom)
            # 是否全部pt
            if self.all_partial_training:
                self.problem.partial_training(offspring_better)
            self.call_aimFunc(offspring_better)
            offspring = offspring_better.copy()

            """ exploration """
            # k个极致做pt
            extreme_idx = np.argmin(population.ObjV, axis=0)
            extreme_idx = np.argsort(population.ObjV, axis=0)[:K_num]
            offsprint_extrme = population[extreme_idx].copy()
            offsprint_extrme.Chrom = self.mutOper.do(offsprint_extrme.Chrom)
            optimal_objs = []
            for i in range(len(self.problem.list_objs)):
                for j in range(K_num):
                    optimal_objs.append(self.problem.list_objs[i])
            offspring_extreme_temp = offsprint_extrme.copy()
            self.problem.partial_training(offspring_extreme_temp, optimal_objs)
            self.call_aimFunc(offspring_extreme_temp)
            offspring = offspring + offspring_extreme_temp

            population, chooseidx = self.reinsertion(population, offspring, NIND)

            print('currentGen: ', self.currentGen)
            end = time.time()
            print('epoch time: ', end - start)

            population.save(file_path + '/' + str(self.currentGen), current_generation=self.currentGen)


        return self.finishing(population)  # 调用finishing完成后续工作并返回结果