基因表达式编程(GEP)自学 第【6】天 Python 实现（代码）

1. 基因表达式编程 GEP Python 代码实现【★★★★★】

今天将用python实现GEP算法中，染色体选择，复制，变异等的内容
【PS：注意结合前边内容，今天的内容比较多，包括染色体选择、复制、变异等内容，需要对GEP的基本知识内容认识。】

基因表达式编程(GEP)自学 第【1】天 Python 实现
基因表达式编程(GEP)自学 第【2】天 Python 实现
基因表达式编程(GEP)自学 第【3】天 Python 实现
基因表达式编程(GEP)自学 第【4】天 Python 实现（代码）
基因表达式编程(GEP)自学 第【5】天 Python 实现（代码）

2. 轮盘赌算法 实现染色体的选择

2.1. 基本思想：

个体被选中的概率与其适应度函数值成正比
设群体大小为n，个体i的适应度为Fi，则个体i被选中遗传到下一代群体的概率为

设想群体全部个体的适当性分数由一张饼图来代表 ，如下图：

群体中每一染色体指定饼图中一个小块。块的大小与染色体的适应性分数成比例，适应性分数愈高，它在饼图中对应的小块所占面积也愈大。为了选取一个染色体，要做的就是旋转这个轮子，直到轮盘停止时，看指针停止在哪一块上，就选中与它对应的那个染色体。

2.2. 代码实现：

Environment 类：

 def select(self, sum_fitness,NowBestChromosome):
        '''
        :param sum_fitness:         总的适应度
        :param NowBestChromosome:   用于保存当代最佳染色体
        :return: selected           用于保存赌盘选择出的染色体
        '''

        accumulator = 0  # 设置累加器
        roulette=[]     # 设置轮盘
        selected=[]

        #制作赌盘，如果percentage  区间为0的
        for i in range(len(self.population)):
            percentage = self.population[i][1] / sum_fitness * 10
            if percentage != 0:
                roulette.append(percentage + accumulator)
                accumulator = accumulator + percentage
            else:
                roulette.append(0)

        #一共选择 len(self.population)-1 条染色体体，最后一条保存最佳染色体。
        for i in range(len(self.population)-1):
            #产生随机数
            ranNumber=random.uniform(0,10)
            #进行选择染色体
            for i_pos in range(len(self.population)):
                if ranNumber <= roulette[i_pos]:
                    selected.append(self.population[i_pos][0])
                    break
        #最后一条保存最佳染色体
        selected.append(NowBestChromosome)
        return  selected

3. 染色体 复制更新

PS: 将赌盘后选择种群染色体，进行染色体复制，保证更新在 self.population

Environment 类：

    def replicate(self, chromosomes):
        '''
        进行染色体复制，保证更新在 self.population
        :param chromosomes:       赌盘后选择种群染色体
        :return:
        '''
        self.population = []
        for chromosome in chromosomes:
            self.population.append(chromosome.replicate())
       

Chromosome 类：

def replicate(self):
        '''
        基因复制
        newGenes        保存新的基因
        newHomeotics    保存新的连接基因
        newChromosome   创建新的染色体，并赋值
        :return: newChromosome 返回新的染色体
        '''
        newGenes = []
        newHomeotics = []
        # 基因复制
        for gene in self.genes:
            newGenes.append(gene.replicate())
        # 连接基因复制 
        for homeotic in self.homeotics:
            newHomeotics.append(homeotic.replicate())
        # 创建新的染色体
        newChromosome = Chromosome()
        newChromosome.genes = newGenes
        newChromosome.homeotics = newHomeotics
        return newChromosome

Gene 类：

def replicate(self):
        '''
        创建新的基因，并对基因内的元素进行复制
        :return: newGene    返回新的基因
        '''
        newGene = Gene(self.genome, self.homeotic_flag)
        newGene.head = self.head[:]
        newGene.tail = self.tail[:]
        return newGene

4. 染色体修饰

包括：

• mutation: 突变
• ISTransposition IS转座
• RISTransposition RIS转座
• geneTransposition 基因转座
• onePointRecombination 单点重组
• twoPointRecombination 两点重组
• geneRecombination 基因重组

4.1 Environment 类：

def modify(self):
        '''
        染色体修饰
        mutation:           突变
        ISTransposition     IS转座
        RISTransposition    RIS转座
        geneTransposition   基因转座
        onePointRecombination   单点重组
        twoPointRecombination   两点重组
        geneRecombination       基因重组
        :return:
        '''
        for i in range(len(self.population)):
            chromosome = self.population[i]
            chromosome.mutation(self.mutationRate, self.homeoticRate)
            chromosome.ISTransposition(self.ISTranspositionRate, self.homeoticRate)
            chromosome.RISTransposition(self.RISTranspositionRate, self.homeoticRate)
            chromosome.geneTransposition(self.geneTranspositionRate, self.homeoticRate)
            #选择于i不同的染色体的，otherIndex
            otherIndex = i
            while otherIndex == i:
                otherIndex = random.randint(0, len(self.population) - 1)
            chromosome.onePointRecombination(self.onePointRecombinationRate, self.homeoticRate, self.population[otherIndex])

            otherIndex = i
            while otherIndex == i:
                otherIndex = random.randint(0, len(self.population) - 1)
            chromosome.twoPointRecombination(self.twoPointRecombinationRate, self.homeoticRate, self.population[otherIndex])

            otherIndex = i
            while otherIndex == i:
                otherIndex = random.randint(0, len(self.population) - 1)
            chromosome.geneRecombination(self.geneRecombinationRate, self.homeoticRate, self.population[otherIndex])

4.2. Chromosome类：

4.2.1. 突变 mutation

变异（突变）可以发生在染色体内的任何位置。然而，染色体的结构组织必须保持完整。所以在头部中，任何符号都可以变成符号或者终点;在尾部中，终点只能够变成终点。通过这种方法，染色体的结构组织得以保持，而且由变异产生的新个体是结构上正确的程序。

def mutation(self, rate, homeoticRate):
        '''
        :param rate:            基因突变的概率
        :param homeoticRate:    连接基因突变的概率
        :return:
        head：           保存基因头部
        tail            保存基因尾部
        functions       保存操作符如：【“+”，“-”，“*”，“/”】
        '''
        for gene in self.genes:
            head = gene.head
            tail = gene.tail
            functions = list(gene.genome.functions.keys())
            functions.pop(functions.index("max_arity"))
            # 基因头部突变
            for i in range(len(head)):
                if random.random() < rate:
                    head[i] = random.choice(functions + gene.genome.terminals)

            # 基因尾部突变
            for i in range(len(tail)):
                if random.random() < rate:
                    tail[i] = random.choice(gene.genome.terminals)
        #连接基因的突变为 rate = homeoticRate*rate
        rate *= homeoticRate
        for homeotic in self.homeotics:
            head = homeotic.head
            tail = homeotic.tail
            functions = list(homeotic.genome.functions.keys())
            functions.pop(functions.index("max_arity"))
            # 连接基因头部突变，突变的选择有些不同：functions + list(range(len(self.genes)))
            for i in range(len(head)):
                if random.random() < rate:
                    head[i] = random.choice(functions + list(range(len(self.genes))))
            # 连接基因尾部部突变
            for i in range(len(tail)):
                if random.random() < rate:
                    tail[i] = random.randint(0, len(self.genes) - 1)

4.2.2 IS转座 ISTransposition

【PS：IS转座是从种群中随机选择一个染色体，然后随机从IS转座长度中选择IS长度，然后在染色体中选择IS长度的基因片段，并随机选择基因，插入到除基因首元素之外的头部部分中】

    def ISTransposition(self, rate, homeoticRate):
        '''
        IS转座是从种群中随机选择一个染色体，然后随机从IS转座长度中选择IS长度，
        然后在染色体中选择IS长度的基因片段，并随机选择基因，插入到除基因首元素之外的头部部分中。
        :param rate:            基因IS概率
        :param homeoticRate:    连接基因IS概率
        :return:
        seq             将所有基因进行连接保存
        start           选择一小段的起点
        stop            选择一小段的终点
        ISSeq           保存选出的小段
        insertPoint     插入点
        '''
        # 出现IS转座
        if random.random() < rate:
            seq = []
            for gene in self.genes:
                seq = seq + gene.head + gene.tail

            #   随机选择一个基因
            gene = random.choice(self.genes)
            headLength = len(gene.head)

            #   选择截取一小断保存在 ISSeq 中
            start = random.randint(0, len(seq) - 1)
            stop = random.randint(start, start + headLength)
            ISSeq = seq[start:stop + 1]

            #   选择一个插入点，进行插入，并且去掉超过长度的部分
            insertPoint = random.randint(1, headLength - 1)
            for i in range(len(ISSeq)):
                gene.head.insert(insertPoint + i, ISSeq[i])
            gene.head = gene.head[:headLength]

        #连接基因的IS转座为 rate = homeoticRate*rate
        rate *= homeoticRate
        if random.random() < rate:
            seq = []
            for homeotic in self.homeotics:
                seq = seq + homeotic.head + homeotic.tail
            #   随机选择一个基因
            homeotic = random.choice(self.homeotics)
            headLength = len(homeotic.head)

            #   选择截取一小断保存在 ISSeq 中
            start = random.randint(0, len(seq) - 1)
            stop = random.randint(start, start + headLength)
            ISSeq = seq[start:stop + 1]
            insertionPoint = random.randint(1, headLength - 1)

            #   选择一个插入点，进行插入，并且去掉超过长度的部分
            for i in range(len(ISSeq)):
                homeotic.head.insert(insertionPoint + i, ISSeq[i])
            homeotic.head = homeotic.head[:headLength]

4.2.2 RIS转座 RISTransposition

【PS：所有的RIS元素都是从一个函数开始，因此是选自头部分中的序列。因此在头中任选一点，沿基因向后查找，直到发现一个函数为止。该函数成为RIS元素的起始位置。如果找不到任何函数，则变换不执行任何操作。该算子随机选取染色体，需要修饰的基因，RIS元素以及其长度。】

 def RISTransposition(self, rate, homeoticRate):
        '''
        :param rate:            基因RIS转座概率
        :param homeoticRate:    连接基因RIS转座概率
        :return:
        seq             将所有基因进行连接保存
        functions       保存操作符如：【“+”，“-”，“*”，“/”】
        start           选择一小段的起点
        end             选择一小段的终点
        RISSeq           保存选出的小段
        insertPoint     插入点
        '''
        # 进行RIS转座
        if random.random() < rate:
            seq = []
            for gene in self.genes:
                seq = seq + gene.head + gene.tail

            #   随机选择一个基因
            gene = random.choice(self.genes)
            headLength = len(gene.head)

            functions = list(gene.genome.functions.keys())
            functions.pop(functions.index("max_arity"))

            #   选择截取一小断保存在 RISSeq 中
            start = random.randint(0, len(seq) - 1)

            #直到发现一个函数为止
            while seq[start] not in functions:
                if start == len(seq) - 1:
                    break
                start += 1
            stop = random.randint(start, start + headLength)
            RISSeq = seq[start:stop + 1]

            #进行插入，并且去掉超过长度的部分
            for i in range(len(RISSeq)):
                gene.head.insert(i, RISSeq[i])
            gene.head = gene.head[:headLength]

        #连接基因的RIS转座为 rate = homeoticRate*rate
        rate *= homeoticRate
        if random.random() < rate:
            seq = []
            for homeotic in self.homeotics:
                seq = seq + homeotic.head + homeotic.tail

            #   随机选择一个基因
            homeotic = random.choice(self.homeotics)
            headLength = len(homeotic.head)

            functions = list(homeotic.genome.functions.keys())
            functions.pop(functions.index("max_arity"))

            #   选择截取一小断保存在 RISSeq 中
            start = random.randint(0, len(seq) - 1)
            while seq[start] not in functions:
                if start == len(seq) - 1:
                    break
                start += 1
            stop = random.randint(start, start + headLength)

            #进行插入，并且去掉超过长度的部分
            RISSeq = seq[start:stop + 1]
            for i in range(len(RISSeq)):
                homeotic.head.insert(i, RISSeq[i])
            homeotic.head = homeotic.head[:headLength]

4.2.3 基因转座 geneTransposition

基因转座仅仅改变基因在同一染色体中的位置，如图所示：

     def geneTransposition(self, rate, homeoticRate):
        '''
        基因转座仅仅改变基因在同一染色体中的位置
        :param rate:            基因转座概率
        :param homeoticRate:    连接基因转座概率
        :return:
        '''
        if random.random() < rate:
            self.genes[random.randint(0,len(self.genes)-1)] = random.choice(self.genes).replicate()

        rate *= homeoticRate
        if random.random() < rate:
            self.homeotics[random.randint(0,len(self.homeotics)-1)] = random.choice(self.homeotics).replicate()

4.2.4 单点重组 onePointRecombination

进行单点重组的时候，父代染色体相互配对并在相同的位置切断，两个染色体相互交换重组点之后的部分。

def onePointRecombination(self, rate, homeoticRate, otherChromosome):
        '''
        进行单点重组的时候，父代染色体相互配对并在相同的位置切断，两个染色体相互交换重组点之后的部分
        :param rate:                单点重组概率
        :param homeoticRate:        连接基因单点重组概率
        :param otherChromosome:     染色体
        :return:
        seq             当前染色体将所有基因进行连接保存
        otherSeq        不同于当前染色体将所有基因进行连接保存
        recombinationPoint       重组结点
        '''
        # 进行单点重组
        if random.random() < rate:
            seq = []
            otherSeq = []
            for gene in self.genes:
                seq = seq + gene.head + gene.tail
            for otherGene in otherChromosome.genes:
                otherSeq = otherSeq + otherGene.head + otherGene.tail
            if len(seq) != len(otherSeq):
                return
            # 进行单点重组（交换）
            recombinationPoint = random.randint(0, len(seq) - 1)
            seq[recombinationPoint:], otherSeq[recombinationPoint:] = otherSeq[recombinationPoint:], seq[recombinationPoint:]

            # 单点重组后,当前染色体进行保存
            for gene in self.genes:
                gene.head = seq[:len(gene.head)]
                del seq[0:len(gene.head)]
                gene.tail = seq[:len(gene.tail)]
                del seq[0:len(gene.tail)]

            # 单点重组后,不同于当前染色体进行保存
            for otherGene in otherChromosome.genes:
                otherGene.head = otherSeq[:len(otherGene.head)]
                del otherSeq[0:len(otherGene.head)]
                otherGene.tail = otherSeq[:len(otherGene.tail)]
                del otherSeq[0:len(otherGene.tail)]

        #连接基因的单点重组为 rate = homeoticRate*rate
        rate *= homeoticRate
        if random.random() < rate:
            seq = []
            otherSeq = []
            for homeotic in self.homeotics:
                seq = seq + homeotic.head + homeotic.tail
            for otherHomeotic in otherChromosome.homeotics:
                otherSeq = otherSeq + otherHomeotic.head + otherHomeotic.tail
            if len(seq) != len(otherSeq):
                return
            # 进行单点重组（交换）
            recombinationPoint = random.randint(0, len(seq) - 1)
            seq[recombinationPoint:], otherSeq[recombinationPoint:] = otherSeq[recombinationPoint:], seq[recombinationPoint:]
            # 单点重组后,当前染色体进行保存
            for homeotic in self.homeotics:
                homeotic.head = seq[:len(homeotic.head)]
                del seq[0:len(homeotic.head)]
                homeotic.tail = seq[:len(homeotic.tail)]
                del seq[0:len(homeotic.tail)]

            # 单点重组后,不同于当前染色体进行保存
            for otherHomeotic in otherChromosome.homeotics:
                otherHomeotic.head = otherSeq[:len(otherHomeotic.head)]
                del otherSeq[0:len(otherHomeotic.head)]
                otherHomeotic.tail = otherSeq[:len(otherHomeotic.tail)]
                del otherSeq[0:len(otherHomeotic.tail)]

4.2.5 两点重组 twoPointRecombination

进行两点重组的时候，父代染色体相互配对，在染色体中随机选择两个点，将染色体切断。两个染色体相互交换重组点之间的部分，形成两个新的子代染色体。

    def twoPointRecombination(self, rate, homeoticRate, otherChromosome):
        '''
        进行两点重组的时候，父代染色体相互配对，在染色体中随机选择两个点，将染色体切断。
        两个染色体相互交换重组点之间的部分，形成两个新的子代染色体
        :param rate:                两点重组概率
        :param homeoticRate:        连接基因两点重组概率
        :param otherChromosome:     不同于当前的染色体
        :return:
        seq             当前染色体将所有基因进行连接保存
        otherSeq        不同于当前染色体将所有基因进行连接保存
        recombinationPoint       重组结点
        otherPoint               另一个重组结点
        '''
        # 进行两点重组
        if random.random() < rate:
            seq = []
            otherSeq = []
            for gene in self.genes:
                seq = seq + gene.head + gene.tail
            for otherGene in otherChromosome.genes:
                otherSeq = otherSeq + otherGene.head + otherGene.tail
            if len(seq) != len(otherSeq):
                return
            # 进行两点重组（交换）
            recombinationPoint = random.randint(0, len(seq) - 1)
            otherPoint = random.randint(recombinationPoint, len(seq) - 1)
            seq[recombinationPoint:], otherSeq[recombinationPoint:] = otherSeq[recombinationPoint:], seq[recombinationPoint:]
            seq[:otherPoint], otherSeq[:otherPoint] = otherSeq[:otherPoint], seq[:otherPoint]

            # 两点重组后,当前染色体进行保存
            for gene in self.genes:
                gene.head = seq[:len(gene.head)]
                del seq[0:len(gene.head)]
                gene.tail = seq[:len(gene.tail)]
                del seq[0:len(gene.tail)]

            # 两点重组后,不同于当前染色体进行保存
            for otherGene in otherChromosome.genes:
                otherGene.head = otherSeq[:len(otherGene.head)]
                del otherSeq[0:len(otherGene.head)]
                otherGene.tail = otherSeq[:len(otherGene.tail)]
                del otherSeq[0:len(otherGene.tail)]

        #连接基因的两点重组为 rate = homeoticRate*rate
        rate *= homeoticRate
        # 进行两点重组
        if random.random() < rate:
            seq = []
            otherSeq = []
            for homeotic in self.homeotics:
                seq = seq + homeotic.head + homeotic.tail
            for otherHomeotic in otherChromosome.homeotics:
                otherSeq = otherSeq + otherHomeotic.head + otherHomeotic.tail
            if len(seq) != len(otherSeq):
                return

            # 进行两点重组（交换）
            recombinationPoint = random.randint(0, len(seq) - 1)
            otherPoint = random.randint(recombinationPoint, len(seq) - 1)
            seq[recombinationPoint:], otherSeq[recombinationPoint:] = otherSeq[recombinationPoint:], seq[recombinationPoint:]
            seq[:otherPoint], otherSeq[:otherPoint] = otherSeq[:otherPoint], seq[:otherPoint]

            # 两点重组后,当前染色体进行保存
            for homeotic in self.homeotics:
                homeotic.head = seq[:len(homeotic.head)]
                del seq[0:len(homeotic.head)]
                homeotic.tail = seq[:len(homeotic.tail)]
                del seq[0:len(homeotic.tail)]


            # 两点重组后,不同于当前染色体进行保存
            for otherHomeotic in otherChromosome.homeotics:
                otherHomeotic.head = otherSeq[:len(otherHomeotic.head)]

                del otherSeq[0:len(otherHomeotic.head)]
                otherHomeotic.tail = otherSeq[:len(otherHomeotic.tail)]

                del otherSeq[0:len(otherHomeotic.tail)]

4.2.5 基因重组 geneRecombination

在 GEP 的第三种重组中，两个染色体中的整个基因相互交换，形成的两个子代染色体含有来自两个父体的基因。

def geneRecombination(self, rate, homeoticRate, otherChromosome):
        '''
        在 GEP 的第三种重组中，两个染色体中的整个基因相互交换，
        形成的两个子代染色体含有来自两个父体的基因。
        :param rate:            基因重组概率
        :param homeoticRate:    连接基因重组概率
        :param otherChromosome: 不同于当前的染色体
        :return:
        '''
        # 进行基因重组
        if random.random() < rate:
            if len(self.genes) != len(otherChromosome.genes):
                return
            recombinationPoint = random.randint(0, len(self.genes) - 1)
            self.genes[recombinationPoint:recombinationPoint+1], otherChromosome.genes[recombinationPoint:recombinationPoint+1] = otherChromosome.genes[recombinationPoint:recombinationPoint+1], self.genes[recombinationPoint:recombinationPoint+1]

        #连接基因的基因重组为 rate = homeoticRate*rate
        rate *= homeoticRate
        if random.random() < rate:
            if len(self.homeotics) != len(otherChromosome.homeotics):
                return
            recombinationPoint = random.randint(0, len(self.homeotics) - 1)
            self.homeotics[recombinationPoint:recombinationPoint+1], otherChromosome.homeotics[recombinationPoint:recombinationPoint+1] = otherChromosome.homeotics[recombinationPoint:recombinationPoint+1], self.homeotics[recombinationPoint:recombinationPoint+1]

5. 打印染色体

Chromosome 类

def printChromosome(self):
        for gene in self.genes:
            print(gene.head + gene.tail, end=':\n')
        for homeotic in self.homeotics:
            print(homeotic.head + homeotic.tail, end=';\n')
        print()
        

6. 将以上功能更新到run上

Environment类：

def run(self, inputsOutputs, evalFunction,generationCount=200,M=100,DataCount=10):
        '''
        :param inputsOutputs:   保存输入与输出集合
        :param evalFunction:    适应度函数
        :param generationCount: 执行代数
        :return:
        generation:             表示第几代种群
        i_chromosome            用于保存当代种群第i条染色体
        C_valueList             表示染色体,样本输出值
        fitness                 保存当前染色体的适应度
        maxFitness_flag=True    为True,返回的maxFitness:M*DataCount
        '''

        ResultBestFitness=float("-inf")
        ResultBestChromosome=[]

        generation = 0
        while True:

            sum_fitness=0
            NowBestFitness=float("-inf")
            NowBestChromosome=[]
            #进行种群打印
            print("generation: ",generation)
            # 可以打印每一染色出来看。。。
            # self.printChromosomes(generation)
            generation += 1
            for i in range(len(self.population)):
                C_valueList = []
                i_chromosome = self.population[i]

                #计算每个染色体对应的 C_value
                # print(inputsOutputs[0])
                for inputs in inputsOutputs[0]:
                    C_valueList.append(i_chromosome.eval(inputs))
                #evalFunction 进行适应度评估
                fitness = evalFunction(C_valueList, inputsOutputs[1], M=M, DataCount=DataCount)
                sum_fitness=sum_fitness+fitness

                #保存当代种群最佳适应度的值,与对应的染色体
                if fitness > NowBestFitness:
                    NowBestFitness = fitness
                    NowBestChromosome=i_chromosome

                # 完美解停止执行
                if fitness == evalFunction([], [], maxFitness_flag=True,M=M,DataCount=DataCount):
                    print("*" * 46, "  完美解  ", "*" * 46)
                    i_chromosome.printChromosome()
                    return i_chromosome

                ##-----输出测试-----##
                # print("[",i,"] ","   Fitness=",fitness)
                ####----------输出测试----------####
                self.population[i] = (i_chromosome, fitness)

            # 打印当代最佳染色体
            print("NowBestFitness=",NowBestFitness)
            NowBestChromosome.printChromosome()
            print("*"*46)

            # 保存最终最佳解，与对应的染色体
            if ResultBestFitness<NowBestFitness:
                ResultBestFitness=NowBestFitness
                ResultBestChromosome=NowBestChromosome

            # 繁衍代数大于generationCount退出, 并输出最佳解
            if generation >= generationCount:
                print("*"*46,"  ",generationCount,"代后最佳解  ","*"*46)
                print("result_fitness=  ", ResultBestFitness)
                ResultBestChromosome.printChromosome()
                return ResultBestChromosome

            selected=self.select(sum_fitness,NowBestChromosome)
            self.replicate(selected)
            self.modify()
            self.population[0]=NowBestChromosome

6. 输出测试

if __name__=='__main__':

    #---------------操作数设置 Begin--------------#
    genome = Genome()
    genome.functions.update(Genome.linker_set)
    genome.terminals = ['a','b']
    genome.symbols()
    my_link_genome=Genome()
    my_link_genome.functions.update(Genome.linker_set)
    #----------------操作数设置 end---------------#


    #---------------种群初始化 Begin--------------#
    environment = Environment()
    environment.init(populationSize=20,numGenes=3,numHomeotics=1,headLength=4,homeoticHeadLength=5,genome=genome,link_genome=my_link_genome)
    environment.setRates(homeoticRate=0.5, mutationRate=0.044,ISTranspositionRate=0.1,
                         RISTranspositionRate=0.1, geneTranspositionRate=0.1,onePointRecombinationRate=0.3,
                         twoPointRecombinationRate=0.3, geneRecombinationRate=0.1)
    # ##----------输出测试----------##
    #----------------种群初始化 end---------------#

    #---------------Run Begin--------------#
    M=100
    DataCount=10
    generationCount=1000
    inputsOutputs=GenerateData(DataCount=DataCount)
    result=environment.run(inputsOutputs,evalFunction,M=M,generationCount=generationCount)
    #----------------Run end---------------#

输出结果：
部分结果

**********************************************
generation:  999
0 :['b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b']:['+', '+', '+', 'b', 'b', 'b', 'a', 'a', 'b']:['+', '+', 'b', '+', 'a', 'a', 'a', 'a', 'a']:['+', 1, '+', '+', 1, 1, 0, 0, 0, 1, 2]:
1 :['*', '+', '+', '+', 'a', 'b', 'b', 'b', 'b']:['+', 'a', 'b', 'b', 'b', 'a', 'a', 'b', 'a']:['+', '+', '+', 'a', 'a', 'a', 'a', 'a', 'a']:[1, 0, '+', 1, '+', 1, 2, 0, 0, 1, 2]:
2 :['+', '+', '+', '/', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'a', 'b', 'b', 'b', 'a', 'a', 'b']:['+', '+', '+', 'a', 'a', 'a', 'a', 'a', 'a']:[0, '+', 0, '-', 0, 1, 2, 2, 0, 0, 0]:
3 :['+', 'a', '/', 'a', 'a', 'b', 'b', 'b', 'b']:['b', 'b', '/', 'a', 'b', 'a', 'a', 'a', 'a']:['+', 'a', 'b', 'a', 'a', 'b', 'b', 'b', 'a']:['+', 0, '/', 0, 1, 1, 2, 2, 0, 0, 0]:
4 :['*', '+', '+', '+', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'a', '+', 'b', 'a', 'a', 'a', 'b']:['+', 'b', '+', '/', 'a', 'a', 'a', 'a', 'b']:[0, '+', 0, '-', 0, 1, 2, 2, 0, 0, 0]:
5 :['/', '*', 'a', 'a', 'a', 'b', 'b', 'b', 'b']:['/', 'a', 'b', 'b', 'a', 'b', 'b', 'b', 'b']:['a', 'a', 'b', '+', 'b', 'b', 'a', 'a', 'a']:['+', 0, '+', 0, 2, 1, 2, 2, 0, 0, 0]:
6 :['*', 'a', 'a', '/', 'a', 'b', 'b', 'b', 'b']:['*', 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'b']:['+', 'b', '+', '+', 'b', 'b', 'b', 'a', 'a']:[2, 1, '+', 0, 0, 1, 2, 1, 0, 1, 0]:
7 :['+', '-', 'a', 'b', 'a', 'a', 'a', 'b', 'b']:['b', 'b', '/', '/', 'b', 'a', 'a', 'a', 'b']:['+', '+', '+', '+', 'a', 'a', 'a', 'a', 'a']:[0, '+', 2, '+', 0, 1, 2, 2, 2, 0, 0]:
8 :['+', '-', 'a', 'b', 'a', 'a', 'a', 'b', 'b']:['b', 'b', '/', 'a', 'b', 'a', 'a', 'a', 'a']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 0, '+', 0, 2, 1, 2, 2, 0, 0, 0]:
9 :['+', '+', 'a', 'b', 'a', 'a', 'a', 'b', 'a']:['+', 'a', 'a', 'a', 'b', 'a', 'a', 'b', 'b']:['+', '+', '+', '+', 'a', 'a', 'b', 'a', 'a']:['+', 1, '+', 1, 0, 1, 0, 0, 0, 1, 0]:
10 :['+', 'a', 'a', '-', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'a', 'b', 'b', 'b', 'a', 'a', 'b']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 1, 2, '+', 0, 1, 2, 2, 0, 0, 0]:
11 :['+', 'a', 'a', '-', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'a', 'b', 'b', 'a', 'a', 'a', 'b']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 1, 2, '+', 0, 1, 2, 0, 0, 0, 0]:
12 :['+', 'a', 'a', '-', 'a', 'b', 'b', 'b', 'b']:['+', 'a', 'b', 'a', 'b', 'b', 'a', 'b', 'a']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 1, 2, '+', 0, 1, 2, 2, 0, 0, 0]:
13 :['-', '+', 'b', 'b', 'b', 'a', 'a', 'b', 'a']:['a', '+', '/', 'a', 'b', 'b', 'a', 'a', 'a']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 0, '+', 0, '+', 1, 2, 2, 0, 1, 0]:
14 :['+', 'a', 'a', 'a', 'a', 'b', 'a', 'b', 'b']:['a', '+', 'b', 'a', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'b', '+', 'b', 'a', 'b', 'a', 'a']:[2, 1, '+', 0, 0, 1, 2, 1, 0, 1, 2]:
15 :['+', '+', '/', 'a', 'a', 'b', 'b', 'b', 'b']:['b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b']:['a', '+', '+', '+', 'b', 'a', 'b', 'b', 'b']:[0, '+', 0, '+', 2, 1, 0, 0, 0, 2, 0]:
16 :['+', '+', '+', '/', 'b', 'b', 'a', 'b', 'b']:['+', '+', 'a', '+', 'b', 'a', 'a', 'b', 'b']:['a', '+', 'b', '+', 'a', 'a', 'a', 'a', 'b']:[0, '+', 1, '+', 0, 1, 0, 0, 2, 1, 0]:
17 :['+', 'a', 'a', '-', 'a', 'b', 'a', 'b', 'b']:['+', '+', 'a', 'b', 'b', 'b', 'a', 'b', 'b']:['+', '+', '+', '/', 'a', 'a', 'b', 'b', 'b']:['+', 1, 2, '+', 0, 1, 2, 2, 0, 0, 0]:
18 :['b', '+', 'a', 'b', 'a', 'a', 'b', 'b', 'b']:['b', 'b', 'b', 'a', 'a', 'a', 'a', 'a', 'b']:['*', 'a', '/', 'a', 'a', 'a', 'a', 'a', 'b']:[0, 0, '+', 0, '+', 1, 0, 0, 0, 1, 2]:
19 :['+', '*', '+', 'a', 'a', 'a', 'a', 'b', 'b']:['+', 'a', 'a', 'a', 'b', 'a', 'a', 'b', 'b']:['+', '+', '+', 'a', 'a', 'a', 'b', 'b', 'b']:['+', 1, '+', 1, 0, 1, 0, 2, 0, 0, 0]:

NowBestFitness= 906
['*', '+', '+', '+', 'a', 'b', 'a', 'b', 'b']:
['+', '+', 'a', '+', 'b', 'a', 'a', 'a', 'b']:
['+', 'b', '+', '/', 'a', 'a', 'a', 'a', 'b']:
[0, '+', 0, '-', 0, 1, 2, 2, 0, 0, 0];
**********************************************    1000 代后最佳解   **********************************************
result_fitness=   988.0
['+', '+', 'b', 'a', 'a', 'a', 'b', 'b', 'b']:
['a', '+', '/', 'a', 'b', 'a', 'b', 'a', 'b']:
['+', '+', '*', '/', 'b', 'a', 'b', 'b', 'b']:
['+', '+', '+', '+', '+', 0, 0, 0, 1, 2, 2];

7. 代码实现整合

为了方便演示，我将每个类整合到一个py文件上，GEP-6 复制修饰实现（GEP基本实现了）

本文作者：九重！
本文链接：https://blog.csdn.net/weixin_43798572/article/details/122860091
关于博主：评论和私信会在第一时间回复。或者直接私信我。
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【点赞】【收藏】一下。您的鼓励是博主的最大动力！