遗传算法解简单的函数极值问题

作者：邬杨明

  1 import numpy
import matplotlib.pyplot as plt
import random
import operator

x_label=[]
y_label=[]#将每一步迭代的结果存储到列表中,便于画图
class GA(object):
    def __init__(self,length,number,lower_boundary,upper_boundary,iter_number):
        self.length = length#确定染色体编码长度
        self.number = number#确定初始化种群数量
        self.lower_boundary = lower_boundary#定义域下界
        self.upper_boundary = upper_boundary#定义域上届
        self.population = self.initial_population(length,number)
        self.iteration(iter_number)
    def initial_population(self,length,number):#初始化种群
        return [self.initial_chromosome(length) for i in range(number)]
    def initial_chromosome(self,length):#编码
            """
            随机生成长度为length的染色体，每个基因的取值是0或1
            这里用一个bit表示一个基因
            """
            chromosome = 0
            for i in range(self.length):
                chromosome |= (1 << i) * random.randint(0, 1)
                # print(chromosome)
                # print(num)
            return chromosome
    def decode(self,chromosome):#解码
        x = chromosome*(self.upper_boundary-self.lower_boundary)/(2**self.length-1)
        return x
    def fitness_function(self,chromosome):#适应度函数
        x = self.decode(chromosome)
        y = x + 10 * numpy.sin(5 * x) + 7 * numpy.cos(4 * x)
        return y
    def evolution(self, retain_rate=0.2, random_select_rate=0.5, mutation_rate=0.01):
        """
        对当前种群依次进行选择、交叉并生成新一代种群，然后对新一代种群进行变异
        """
        parents = self.selection(retain_rate, random_select_rate)
        self.crossover(parents)
        self.mutation(mutation_rate)
    def selection(self,retain_rate, random_select_rate):
        graded = [(self.fitness_function(chromosome), chromosome) for chromosome in self.population]
        sort = [x[1] for x in sorted(graded, reverse=True)]
        retain_length=int(len(sort)*retain_rate)
        #选出适应性强的个体，精英选择
        parents=sort[:retain_length]
        for chromosome in sort[retain_length:]:
            if random.random() < random_select_rate:
                parents.append(chromosome)
        return parents
    def crossover(self,parents):#交叉
        children=[]
        #需要繁殖的子代数量
        target_number=len(self.population)-len(parents)
        #开始繁殖
        while len(children) < target_number:
            father = random.randint(0, len(parents) - 1)
            mother = random.randint(0, len(parents) - 1)
            if father != mother:
                # 随机选取交叉点
                cross_point = random.randint(0, self.length)
                # 生成掩码，方便位操作
                mark = 0
                for i in range(cross_point):
                    mark |= (1 << i)
                father = parents[father]
                mother = parents[mother]
                # 孩子将获得父亲在交叉点前的基因和母亲在交叉点后（包括交叉点）的基因
                child = ((father & mark) | (mother & ~mark)) & ((1 << self.length) - 1)
                children.append(child)
                # 经过繁殖后，孩子和父母的数量与原始种群数量相等，在这里可以更新种群。
        self.population = parents + children
    def mutation(self,rate):
        for i in range(len(self.population)):
            if random.random() < rate:
                j = random.randint(0, self.length - 1)#s随机产生变异位置
                self.population[i] ^= 1 << j  #产生变异
    def result(self):
        '''
        获得近优值
        '''
        graded = [(self.fitness_function(chromosome), chromosome) for chromosome in self.population]
        graded = [x[1] for x in sorted(graded, reverse=True)]
        # print('近优的x值为：', self.decode(graded[0]),
        #       '近优的y值为：', self.fitness_function(graded[0]))
        #将每一步迭代的结果存储到列表中
        y_label.append(self.fitness_function(graded[0]))
        return self.decode(graded[0])
    def iteration(self,iter_number):
        for i in range(iter_number):
            self.evolution()
            self.result()
            x_label.append(i)
g1=GA(17,300,0,9,30)#建立一个实例

plt.plot(x_label,y_label)
plt.show()
g1.result()