def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population)  # 先调用父类构造方法
     if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
         raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
     self.name = 'GGAP-SGA'
     self.selFunc = 'rws'  # 轮盘赌选择算子
     # 由于有多个染色体,因此需要用多个重组和变异算子
     self.recOpers = []
     self.mutOpers = []
     for i in range(population.ChromNum):
         if population.Encodings[i] == 'P':
             recOper = ea.Xovpmx(XOVR=1)  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=1)  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=1)  # 生成两点交叉算子对象
             if population.Encodings[i] == 'BG':
                 mutOper = ea.Mutbin(
                     Pm=None)  # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
             elif population.Encodings[i] == 'RI':
                 mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
                                     MutShrink=0.5,
                                     Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
     self.GGAP = 0.9  # 代沟,表示使用多少个子代替换父代来形成新一代种群
Esempio n. 2
0
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population)  # 先调用父类构造方法
     if population.ChromNum == 1:
         raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
     self.name = 'psy-EGA'
     self.selFunc = 'tour'  # 锦标赛选择算子
     # 由于有多个染色体,因此需要用多个重组和变异算子
     self.recOpers = []
     self.mutOpers = []
     for i in range(population.ChromNum):
         if population.Encodings[i] == 'P':
             recOper = ea.Xovpmx(XOVR=0.7)  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=0.5)  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=0.7)  # 生成两点交叉算子对象
             if population.Encodings[i] == 'BG':
                 mutOper = ea.Mutbin(
                     Pm=None)  # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
             elif population.Encodings[i] == 'RI':
                 mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
                                     MutShrink=0.5,
                                     Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
Esempio n. 3
0
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population)  # 先调用父类构造方法
     if type(population) != list:
         raise RuntimeError('传入的种群对象列表必须为list类型')
     self.name = 'multi-SEGA'
     self.PopNum = len(population)  # 种群数目
     self.selFunc = 'tour'  # 锦标赛选择算子
     self.migFr = 5  # 发生种群迁移的间隔代数
     self.migOpers = ea.Migrate(MIGR=0.2, Structure=2, Select=1, Replacement=2)  # 生成种群迁移算子对象
     # 为不同的种群设置不同的重组、变异算子
     self.recOpers = []
     self.mutOpers = []
     Pms = np.linspace(1 / self.problem.Dim, 1, self.PopNum)  # 生成变异概率列表,为不同的种群分配不同的变异概率
     Pcs = np.linspace(0.7, 1, self.PopNum)  # 生成重组概率列表,为不同的种群分配不同的重组概率
     for i in range(self.PopNum):  # 遍历种群列表
         pop = population[i]  # 得到当前种群对象
         if pop.Encoding == 'P':
             recOper = ea.Xovpmx(XOVR=Pcs[i])  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=float(Pms[i]))  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=Pcs[i])  # 生成两点交叉算子对象
             if pop.Encoding == 'BG':
                 mutOper = ea.Mutbin(Pm=float(Pms[i]))  # 生成二进制变异算子对象
             elif pop.Encoding == 'RI':
                 mutOper = ea.Mutbga(Pm=float(Pms[i]), MutShrink=0.5, Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
Esempio n. 4
0
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population)  # 先调用父类构造方法
     if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
         raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
     self.name = 'psy-studGA'
     self.problem = problem
     self.population = population
     self.selFunc = 'tour'  # 锦标赛选择算子
     # 由于有多个染色体,因此需要用多个重组和变异算子
     self.recOpers = []
     self.mutOpers = []
     for i in range(population.ChromNum):
         if population.Encodings[i] == 'P':
             recOper = ea.Xovpmx(XOVR=1)  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=1)  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=1)  # 生成两点交叉算子对象
             if population.Encodings[i] == 'BG':
                 mutOper = ea.Mutbin(Pm=1)  # 生成二进制变异算子对象
             elif population.Encodings[i] == 'RI':
                 mutOper = ea.Mutbga(Pm=1, MutShrink=0.5,
                                     Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
Esempio n. 5
0
 def __init__(self,
              problem,
              population,
              MAXGEN=None,
              MAXTIME=None,
              MAXEVALS=None,
              MAXSIZE=None,
              logTras=None,
              verbose=None,
              outFunc=None,
              drawing=None,
              trappedValue=None,
              maxTrappedCount=None,
              dirName=None,
              **kwargs):
     # 先调用父类构造方法
     super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
                      MAXSIZE, logTras, verbose, outFunc, drawing,
                      trappedValue, maxTrappedCount, dirName)
     if type(population) != list:
         raise RuntimeError('传入的种群对象列表必须为list类型')
     self.name = 'multi-SEGA'
     self.PopNum = len(population)  # 种群数目
     self.selFunc = 'tour'  # 锦标赛选择算子
     self.migFr = 5  # 发生种群迁移的间隔代数
     self.migOpers = ea.Migrate(MIGR=0.2,
                                Structure=2,
                                Select=1,
                                Replacement=2)  # 生成种群迁移算子对象
     # 为不同的种群设置不同的重组、变异算子
     self.recOpers = []
     self.mutOpers = []
     Pms = np.linspace(1 / self.problem.Dim, 1,
                       self.PopNum)  # 生成变异概率列表,为不同的种群分配不同的变异概率
     Pcs = np.linspace(0.7, 1, self.PopNum)  # 生成重组概率列表,为不同的种群分配不同的重组概率
     for i in range(self.PopNum):  # 遍历种群列表
         pop = population[i]  # 得到当前种群对象
         if pop.Encoding == 'P':
             recOper = ea.Xovpmx(XOVR=Pcs[i])  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=float(Pms[i]))  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=Pcs[i])  # 生成两点交叉算子对象
             if pop.Encoding == 'BG':
                 mutOper = ea.Mutbin(Pm=float(Pms[i]))  # 生成二进制变异算子对象
             elif pop.Encoding == 'RI':
                 mutOper = ea.Mutbga(Pm=float(Pms[i]),
                                     MutShrink=0.5,
                                     Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
     if str(type(population)) != "<class 'Population.Population'>":
         raise RuntimeError('传入的种群对象必须为Population类型')
     self.name = 'steadyGA'
     self.selFunc = 'etour' # 锦标赛选择算子
     if population.Encoding == 'P':
         self.recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
         self.mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
     else:
         self.recOper = ea.Xovdp(XOVR = 1) # 生成两点交叉算子对象
         if population.Encoding == 'BG':
             self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
         elif population.Encoding == 'RI':
             self.mutOper = ea.Mutbga(Pm = 1/self.problem.Dim, MutShrink = 0.5, Gradient = 20) # 生成breeder GA变异算子对象
         else:
             raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
Esempio n. 7
0
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
     if population.ChromNum != 1:
         raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
     self.name = 'studGA'
     self.selFunc = 'tour' # 锦标赛选择算子
     if population.Encoding == 'P':
         self.recOper = ea.Xovpmx(XOVR = 0.7) # 生成部分匹配交叉算子对象
         self.mutOper = ea.Mutinv(Pm = 0.5) # 生成逆转变异算子对象
     else:
         self.recOper = ea.Xovdp(XOVR = 0.7) # 生成两点交叉算子对象
         if population.Encoding == 'BG':
             self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
         elif population.Encoding == 'RI':
             self.mutOper = ea.Mutbga(Pm = 1/self.problem.Dim, MutShrink = 0.5, Gradient = 20) # 生成breeder GA变异算子对象
         else:
             raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
 def __init__(self,
              problem,
              population,
              MAXGEN=None,
              MAXTIME=None,
              MAXEVALS=None,
              MAXSIZE=None,
              logTras=None,
              verbose=None,
              outFunc=None,
              drawing=None,
              trappedValue=None,
              maxTrappedCount=None,
              dirName=None,
              **kwargs):
     # 先调用父类构造方法
     super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
                      MAXSIZE, logTras, verbose, outFunc, drawing,
                      trappedValue, maxTrappedCount, dirName)
     if population.ChromNum == 1:
         raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
     self.name = 'GGAP-SGA'
     self.selFunc = 'rws'  # 轮盘赌选择算子
     # 由于有多个染色体,因此需要用多个重组和变异算子
     self.recOpers = []
     self.mutOpers = []
     for i in range(population.ChromNum):
         if population.Encodings[i] == 'P':
             recOper = ea.Xovpmx(XOVR=0.7)  # 生成部分匹配交叉算子对象
             mutOper = ea.Mutinv(Pm=0.5)  # 生成逆转变异算子对象
         else:
             recOper = ea.Xovdp(XOVR=0.7)  # 生成两点交叉算子对象
             if population.Encodings[i] == 'BG':
                 mutOper = ea.Mutbin(
                     Pm=None)  # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
             elif population.Encodings[i] == 'RI':
                 mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
                                     MutShrink=0.5,
                                     Gradient=20)  # 生成breeder GA变异算子对象
             else:
                 raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
         self.recOpers.append(recOper)
         self.mutOpers.append(mutOper)
     self.GGAP = 0.9  # 代沟,表示使用多少个子代替换父代来形成新一代种群
Esempio n. 9
0
 def __init__(self, problem, population):
     ea.SoeaAlgorithm.__init__(self, problem, population)  # 先调用父类构造方法
     if str(type(population)) != "<class 'Population.Population'>":
         raise RuntimeError('传入的种群对象必须为Population类型')
     self.name = 'GGAP-SGA'
     self.selFunc = 'rws'  # 轮盘赌选择算子
     if population.Encoding == 'P':
         self.recOper = ea.Xovpmx(XOVR=1)  # 生成部分匹配交叉算子对象
         self.mutOper = ea.Mutinv(Pm=1)  # 生成逆转变异算子对象
     else:
         self.recOper = ea.Xovdp(XOVR=1)  # 生成两点交叉算子对象
         if population.Encoding == 'BG':
             self.mutOper = ea.Mutbin(Pm=1)  # 生成二进制变异算子对象
         elif population.Encoding == 'RI':
             self.mutOper = ea.Mutbga(Pm=1, MutShrink=0.5,
                                      Gradient=20)  # 生成breeder GA变异算子对象
         else:
             raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
     self.GGAP = 0.9  # 代沟,表示使用多少个子代替换父代来形成新一代种群
Esempio n. 10
0
 def __init__(self,
              problem,
              population,
              MAXGEN=None,
              MAXTIME=None,
              MAXEVALS=None,
              MAXSIZE=None,
              logTras=None,
              verbose=None,
              outFunc=None,
              drawing=None,
              trappedValue=None,
              maxTrappedCount=None,
              dirName=None,
              **kwargs):
     # 先调用父类构造方法
     super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
                      MAXSIZE, logTras, verbose, outFunc, drawing,
                      trappedValue, maxTrappedCount, dirName)
     if population.ChromNum != 1:
         raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
     self.name = 'studGA'
     self.selFunc = 'tour'  # 锦标赛选择算子
     if population.Encoding == 'P':
         self.recOper = ea.Xovpmx(XOVR=0.7)  # 生成部分匹配交叉算子对象
         self.mutOper = ea.Mutinv(Pm=0.5)  # 生成逆转变异算子对象
     else:
         self.recOper = ea.Xovdp(XOVR=0.7)  # 生成两点交叉算子对象
         if population.Encoding == 'BG':
             self.mutOper = ea.Mutbin(
                 Pm=None)  # 生成二进制变异算子对象,Pm设置为None时,具体数值取变异算子中Pm的默认值
         elif population.Encoding == 'RI':
             self.mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
                                      MutShrink=0.5,
                                      Gradient=20)  # 生成breeder GA变异算子对象
         else:
             raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')