【最优化问题】使用离散重组完成的整数规划遗传算法

'''
使用离散重组完成的整数规划遗传算法 

过程
1、初始化族群
2、计算个体适应度
3、淘汰适应度最低的个体。
4、适应度最高的个体直接延续到下一代，同时所有个体通过离散重组进行繁衍。产生新的族群
重复2,3,4步。
'''
import numpy as np

class GeneticAlgorithm:
    def __init__(self,target,populationsNum, DNALen,maxiter, passRate,keepRate, mutationRate,lb,ub):
        self.target = target
        self.populationsNum = populationsNum  # 种族数量 
        self.DNALen = DNALen  # 个体数值长度
        self.passRate = passRate # 淘汰比率
        self.keepRate = keepRate # 留存比率
        self.maxiter = maxiter  # 最大迭代次数 
        self.mutationRate = mutationRate  # 变异系数 
#         self.getMax = getMax
    def init_populations(self):  # 初始化族群函数 
        '''
        初始化族群
        '''
        populations = []  # 存储初始化种群 
        for i in range(self.DNALen): 
            populations.append(np.random.randint(lb[i],ub[i],self.populationsNum)) # 根据上下限生成个体 
        populations = np.array(populations).T  # 转为numpy格式 
        return populations  # 返回初始化族群 
    
    def fitness(self,populations):  # 适应度计算函数  目标函数 
        '''
        输入族群，输出族群适应度
        '''
        fitness_list = [] # 储存每一个个体的适应度
        for i in range(self.populationsNum):
            fitness_list.append(self.target(populations[i,:]))
        fitness_list = np.array(fitness_list)
        return fitness_list
    
    def crossover(self,populations ,fitness_list):
        '''
        淘汰掉适应度低的样本之后，进行遗传，得到新的族群。使用离散重组进行繁衍 
        '''
#         childs = []
        populations = populations[fitness_list >= np.percentile(fitness_list,self.passRate*100)]  #  淘汰个体
        fitness_list = fitness_list[fitness_list >= np.percentile(fitness_list,self.passRate*100)]  # 更新个体的适应度
        childs = populations[fitness_list >= np.percentile(fitness_list,(1 - self.keepRate)*100)].tolist()  # 保留优质个体 
        for i in range(self.populationsNum - len(childs)):  # 生成新个体 
            choice_id = np.random.choice(range(populations.shape[0]), size = 2,p= (fitness_list - fitness_list.min())/(fitness_list - fitness_list.min()).sum(),replace = False) # 选择父母样本
            new_child =  [np.random.choice([i,j]) for i,j in zip(populations[choice_id[0],:] ,populations[choice_id[1],:])]  # 按照离散重组进行繁衍
            childs.append(new_child)  # 添加新族群 
        childs = np.array(childs)
        return childs
    
    def mutation(self,populations):  # 变异函数 
        '''
        通过增加-3,3进行变异 
        '''
        for i in range(self.populationsNum):
            if np.random.rand() < self.mutationRate:
                populations[i,:] += np.random.randint(-3,3,self.DNALen)
        populations = np.clip(populations,lb,ub)
        return populations

    def run(self):
        '''
        遗传算法启动函数 
        '''
        re_ = []
        pop = self.init_populations() # 初始族群
        fit_ = self.fitness(pop)  # 初始适应度
        best_fit =  fit_.max()  # 最大适应度
        best_p = pop[fit_.argmax()]  # 最佳适应的个体 
        for i in range(self.maxiter):
            re_.append(pop)
            pop = self.crossover(pop,fit_)  # 族群繁衍
            pop = self.mutation(pop)  # 族群变异
            fit_ = self.fitness(pop)  # 计算新的适应度
            g_best_fit = fit_.max()  # 计算当前族群最佳适应度 
            print(g_best_fit)
            # print(fit_)
            if g_best_fit > best_fit:  # 更新适应度 
                best_fit = g_best_fit
                best_p = pop[fit_.argmax()] 
        return best_p,re_
        
def target(x):
    return x[0]**2 - x[1]**3 + x[2]
lb = [-10] *3 
ub = [10] *3 

ga = GeneticAlgorithm(target,20,3,20,0.05,0.05,0.2,lb,ub)
x,y = ga.run()

print(x)