DE 算法的变体python实现

上演化计算课的时候老师讲了一种DE算法的改进算法CoDE,于是看了下CoDE的论文中的算法步骤：

算法中使用的三种交叉策略：

根据不同的交叉策略采取不同的变异策略：

超参数的三种不同组合（一一对应）：

---

python代码实现

import numpy as np
import random
import math

class Population:
    def __init__(self, min_range, max_range, dim, rounds, size, object_func):
        self.min_range = min_range
        self.max_range = max_range
        self.dimension = dim
        self.rounds = rounds
        self.size = size
        self.cur_round = 1
        self.get_object_function_value = object_func
        # 初始化种群
        self.individuality = [np.array([random.uniform(self.min_range, self.max_range) for s in range(self.dimension)])
                              for tmp in range(size)]
        self.object_function_values = [self.get_object_function_value(v) for v in self.individuality]
        self.mutant1 = None
        self.mutant2 = None
        self.mutant3 = None
    #变异

    def mutate1(self): #使用rand/1进行变异
        self.mutant1 = []
        factor = 1.0
        for i in range(self.size):
            r0, r1, r2 = 0, 0, 0
            #随机查找变异父代
            while r0 == r1 or r1 == r2 or r0 == r2 or r0 == i:
                r0 = random.randint(0, self.size - 1)
                r1 = random.randint(0, self.size - 1)
                r2 = random.randint(0, self.size - 1)
            #变异向量
            tmp = self.individuality[r0] + (self.individuality[r1] - self.individuality[r2]) * factor
            for t in range(self.dimension):
                if tmp[t] > self.max_range or tmp[t] < self.min_range:
                    tmp[t] = random.uniform(self.min_range, self.max_range)
            self.mutant1.append(tmp)

    def mutate2(self): #使用rand/2进行变异
        self.mutant2 = []
        factor = 1.0
        for i in range(self.size):
            r0, r1, r2 , r3, r4= 0, 0, 0, 0, 0
            #随机查找变异父代
            while r0 == r1 or r1 == r2 or r2 == r3 or r3 == r4 or r4 == r0 \
                    or r0 == r2 or r0 == r3 or r0 == r4 or r1 == r3 or r1 == r4 \
                    or r2 == r4 or r0 == i:
                r0 = random.randint(0, self.size - 1)
                r1 = random.randint(0, self.size - 1)
                r2 = random.randint(0, self.size - 1)
                r3 = random.randint(0, self.size - 1)
                r4 = random.randint(0, self.size - 1)
            #变异向量
            tmp = self.individuality[r0] + (self.individuality[r1] - self.individuality[r2]) * factor\
                  + (self.individuality[r3] - self.individuality[r4]) * factor
            for t in range(self.dimension):
                if tmp[t] > self.max_range or tmp[t] < self.min_range:
                    tmp[t] = random.uniform(self.min_range, self.max_range)
            self.mutant2.append(tmp)

    def mutate3(self): #使用current-to-rand/1进行变异
        self.mutant3 = []
        factor = 0.8
        for i in range(self.size):
            r0, r1, r2 = 0, 0, 0
            # 随机查找变异父代
            while r0 == r1 or r1 == r2 or r0 == r2 or r0 == i:
                r0 = random.randint(0, self.size - 1)
                r1 = random.randint(0, self.size - 1)
                r2 = random.randint(0, self.size - 1)
            # 变异向量
            tmp = self.individuality[i] + (self.individuality[r0] - self.individuality[i]) * factor \
            + (self.individuality[r1] - self.individuality[r2]) * factor
            for t in range(self.dimension):
                if tmp[t] > self.max_range or tmp[t] < self.min_range:
                    tmp[t] = random.uniform(self.min_range, self.max_range)
            self.mutant3.append(tmp)

    #交叉
    def crossover(self,mutant,CR):
        for i in range(self.size):
            Jrand = random.randint(0, self.dimension)
            for j in range(self.dimension):
                if random.random() > CR and j != Jrand:
                    mutant[i][j] = self.individuality[i][j]
        return mutant

    #选择
    def select(self,u1,u2,u3):
        for i in range(self.size):
            tmp1 = self.get_object_function_value(u1[i])
            tmp2 = self.get_object_function_value(u2[i])
            tmp3 = self.get_object_function_value(u3[i])
            if tmp1 < tmp2 and tmp1 < tmp3 and tmp1 < self.object_function_values[i]:
                self.individuality[i] = u1[i]
                self.object_function_values[i] = tmp1
            elif tmp2 < tmp1 and tmp2 < tmp3 and tmp2 < self.object_function_values[i]:
                self.individuality[i] = u2[i]
                self.object_function_values[i] = tmp2
            elif tmp3 < tmp1 and tmp3 < tmp2 and tmp3 < self.object_function_values[i]:
                self.individuality[i] = u3[i]
                self.object_function_values[i] = tmp3

    def print_best(self):
        m = min(self.object_function_values)
        i = self.object_function_values.index(m)
        print("轮数：" + str(self.cur_round))
        print("最佳个体：" + str(self.individuality[i]))
        print("目标函数值：" + str(m))

    def evolution(self):
        while self.cur_round < self.rounds:
            self.mutate1()
            self.mutate2()
            self.mutate3()
            u1 = self.crossover(self.mutant1,CR=0.1)
            u2 = self.crossover(self.mutant2,CR=0.9)
            u3 = self.mutant3
            self.select(u1,u2,u3)
            self.print_best()
            self.cur_round = self.cur_round + 1

# 测试部分
if __name__ == "__main__":
    def f(x):
        return x**2
    p = Population(min_range=-3, max_range=3, dim=1, rounds=100, size=30, object_func=f)
    p.evolution()

　　

---***如有不对欢迎指正***---