python有没有简单的遗传算法库

发布网友发布时间：2022-04-20 04:18

我来回答

共3个回答

懂视网时间：2022-04-18 19:39

本篇文章主要介绍了Python 遗传算法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

写在前面

之前的文章中已经讲过了遗传算法的基本流程，并且用MATLAB实现过一遍了。这一篇文章主要面对的人群是看过了我之前的文章，因此我就不再赘述遗传算法是什么以及基本的内容了，假设大家已经知道我是怎么写遗传算法的了。

Python的遗传算法主函数

我的思想是，创建一个染色体的类，其中包括了两个变量：染色体chrom与适应度fitness。因此我们就可以通过直接建立对象来作为种群中的个体。

#染色体的类
class Chrom:
 chrom = []
 fitness = 0
 def showChrom(self):
 print(self.chrom)
 def showFitness(self):
 print(self.fitness)

所以我们开始设置基础参数。其中种群的表达方式我用的是字典，也就是用一个字典来保存种群内的所有个体，这个也是我想出来的创建多个对象的方法。

将字典的索引为个体的标号，如：chrom1, chrom2等。字典索引的值就是一个对象。这个对象拥有两个属性，就是染色体与适应度。

其实在这一方便来说，我觉得在思路上是优于利用MATLAB的矩阵式编程的。因为这样可以很直观的将个体与个体的属性这一种思想给表达出来，相比一堆矩阵来说，在逻辑上比较容易接受。

#基础参数
N = 200 #种群内个体数目
mut = 0.2 #突变概率
acr = 0.2 #交叉概率

pop = {} #存储染色体的字典
for i in range(N):
 pop['chrom'+str(i)] = Chrom()
chromNodes = 2 #染色体节点数（变量个数）
iterNum = 10000 #迭代次数
chromRange = [[0, 10], [0, 10]] #染色体范围
aveFitnessList = [] #平均适应度
bestFitnessList = [] #最优适应度

之后就是初始染色体了，其中就牵扯到了各种用来初始化种群、计算适应度、找最优等函数，我在这里分出了两个文件，分别为Genetic.py与Fitness.py。

Genetic.py里面有八个函数，主要包含了作用于种群或者染色体操作的函数，分别为：

findBest函数，用于寻找种群中的最优染色体；
findworse函数，用于寻找种群中的最劣染色体；
initialize函数，用于初始化种群；
calAveFitness函数，用于计算种群的平均适应度；
mutChrom函数，用于对染色体进行变异；
inRange函数，用于判断染色体节点值是否越界；
acrChrom函数，用于对染色体进行交叉；
compareChrom函数，用于比较两个染色体孰优孰劣。

Fitness.py里面有两个函数，主要包含了对适应度操作的函数，分别为：

calFitness函数，用来迭代每一个个体，并计算适应度（利用funcFitness函数计算）；
funcFitness函数，计算单个个体的适应度。

因此可以列出初始化代码为

#初始染色体
pop = Genetic.initialize(pop, chromNodes, chromRange)
pop = Fitness.calFitness(pop) #计算适应度
bestChrom = Genetic.findBest(pop) #寻找最优染色体
bestFitnessList.append(bestChrom[1]) #将当前最优适应度压入列表中
aveFitnessList.append(Genetic.calAveFitness(pop, N)) #计算并存储平均适应度

迭代过程的思路和逻辑与MATLAB无异

#开始迭代
for t in range(iterNum):
 #染色体突变
 pop = Genetic.mutChrom(pop, mut, chromNodes, bestChrom, chromRange)
 #染色体交换
 pop = Genetic.acrChrom(pop, acr, chromNodes)
 #寻找最优
 nowBestChrom = Genetic.findBest(pop)
 #比较前一个时间的最优和现在的最优
 bestChrom = Genetic.compareChrom(nowBestChrom, bestChrom)
 #寻找与替换最劣
 worseChrom = Genetic.findWorse(pop)
 pop[worseChrom[0]].chrom = pop[bestChrom[0]].chrom.copy()
 pop[worseChrom[0]].fitness = pop[bestChrom[0]].fitness
 #存储最优与平均
 bestFitnessList.append(bestChrom[1])
 aveFitnessList.append(Genetic.calAveFitness(pop, N))

最后再做一下迭代的的图像

plt.figure(1)
plt.plot(x, aveFitnessList)
plt.plot(x, bestFitnessList)
plt.show()

最后再在最前面加上各种库和文件就可以运行了。

import Genetic
import Fitness
import matplotlib.pyplot as plt
import numpy as np

感悟

可以说最主要的感悟就是染色体这一个类。其实那个Genetic.py与Fitness.py这两个文件也可以直接包装成类，但是这样一来我就嫌主文件太臃肿，在其他里面再包装成类又多此一举，毕竟这只是一个小程序，所以我就这样写了。

深刻感悟到了面向对象编程的优点，在编程逻辑的处理上真是一种享受，只需要思考对象的属性即可，省去了许多复杂的思考。

另一个感悟就是创建多个对象时，利用字典的方法来创建对象。当初我也是困惑怎么建立一个类似于C++中的对象数组，上网查找了各种方法，结果都避而不谈（当然，也可能是我搜索能力太差没找到），所以经过尝试中遇到到了这种方法。

等有空我再详细说一下这个方法吧，这一次就先到这里。

剩余的函数补充

首先是Genetic.py里面的八个函数

import random

#寻找最优染色体
def findBest(pop):
 best = ['1', 0.0000001]
 for i in pop:
 if best[1] < pop[i].fitness:
 best = [i, pop[i].fitness]
 return best

#寻找最劣染色体
def findWorse(pop):
 worse = ['1', 999999]
 for i in pop:
 if worse[1] > pop[i].fitness:
 worse = [i, pop[i].fitness]
 return worse

#赋初始值
def initialize(pop, chromNodes, chromRange):
 for i in pop:
 chromList = []
 for j in range(chromNodes):
 chromList.append(random.uniform(chromRange[j][0], chromRange[j][1]+1))
 pop[i].chrom = chromList.copy()
 return pop

#计算平均适应度
def calAveFitness(pop, N):
 sumFitness = 0
 for i in pop:
 sumFitness = sumFitness + pop[i].fitness
 aveFitness = sumFitness / N
 return aveFitness

#进行突变
def mutChrom(pop, mut, chromNodes, bestChrom, chromRange):
 for i in pop:
 #如果随机数小于变异概率（即可以变异)
 if mut > random.random():
 mutNode = random.randrange(0,chromNodes)
 mutRange = random.random() * (1-pop[i].fitness/bestChrom[1])**2
 pop[i].chrom[mutNode] = pop[i].chrom[mutNode] * (1+mutRange)
 #判断变异后的范围是否在要求范围内
 pop[i].chrom[mutNode] = inRange(pop[i].chrom[mutNode], chromRange[mutNode])
 return pop

#检验便宜范围是否在要求范围内
def inRange(mutNode, chromRange):
 if chromRange[0] < mutNode < chromRange[1]:
 return mutNode
 elif mutNode-chromRange[0] > mutNode-chromRange[1]:
 return chromRange[1]
 else:
 return chromRange[0]

#进行交叉
def acrChrom(pop, acr, chromNodes):
 for i in pop:
 for j in pop:
 if acr > random.random():
 acrNode = random.randrange(0, chromNodes)
 #两个染色体节点进行交换
 pop[i].chrom[acrNode], pop[j].chrom[acrNode] = pop[j].chrom[acrNode], pop[i].chrom[acrNode]
 return pop

#进行比较
def compareChrom(nowbestChrom, bestChrom):
 if bestChrom[1] > nowbestChrom[1]:
 return bestChrom
 else:
 return nowbestChrom

然后是Fitness.py的两个函数

import math

def calFitness(pop):
 
 for i in pop:
 #计算每个染色体的适应度
 pop[i].fitness = funcFitness(pop[i].chrom)

 return pop

def funcFitness(chrom):
 #适应度函数
 fitness = math.sin(chrom[0])+math.cos(chrom[1])+0.1*(chrom[0]+chrom[1])

热心网友时间：2022-04-18 16:47

首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。

以目标式子 y = 10 * sin(5x) + 7 * cos(4x)为例，计算其最大值

首先是初始化，包括具体要计算的式子、种群数量、染色体长度、交配概率、变异概率等。并且要对基因序列进行初始化

[python] view plain copy

pop_size = 500 # 种群数量

max_value = 10 # 基因中允许出现的最大值

chrom_length = 10 # 染色体长度

pc = 0.6 # 交配概率

pm = 0.01 # 变异概率

results = [[]] # 存储每一代的最优解，N个二元组

fit_value = [] # 个体适应度

fit_mean = [] # 平均适应度

pop = geneEncoding(pop_size, chrom_length)

其中genEncodeing是自定义的一个简单随机生成序列的函数，具体实现如下

[python] view plain copy

def geneEncoding(pop_size, chrom_length):

pop = [[]]

for i in range(pop_size):

temp = []

for j in range(chrom_length):

temp.append(random.randint(0, 1))

pop.append(temp)

return pop[1:]

编码完成之后就是要进行个体评价，个体评价主要是计算各个编码出来的list的值以及对应带入目标式子的值。其实编码出来的就是一堆2进制list。这些2进制list每个都代表了一个数。其值的计算方式为转换为10进制，然后除以2的序列长度次方减一，也就是全一list的十进制减一。根据这个规则就能计算出所有list的值和带入要计算式子中的值，代码如下

[python] view plain copy

# 0.0 coding:utf-8 0.0

# 解码并计算值

import math

def decodechrom(pop, chrom_length):

temp = []

for i in range(len(pop)):

t = 0

for j in range(chrom_length):

t += pop[i][j] * (math.pow(2, j))

temp.append(t)

return temp

def calobjValue(pop, chrom_length, max_value):

temp1 = []

obj_value = []

temp1 = decodechrom(pop, chrom_length)

for i in range(len(temp1)):

x = temp1[i] * max_value / (math.pow(2, chrom_length) - 1)

obj_value.append(10 * math.sin(5 * x) + 7 * math.cos(4 * x))

return obj_value

有了具体的值和对应的基因序列，然后进行一次淘汰，目的是淘汰掉一些不可能的坏值。这里由于是计算最大值，于是就淘汰负值就好了

[python] view plain copy

# 0.0 coding:utf-8 0.0

# 淘汰（去除负值）

def calfitValue(obj_value):

fit_value = []

c_min = 0

for i in range(len(obj_value)):

if(obj_value[i] + c_min > 0):

temp = c_min + obj_value[i]

else:

temp = 0.0

fit_value.append(temp)

return fit_value

然后就是进行选择，这是整个遗传算法最核心的部分。选择实际上模拟生物遗传进化的优胜劣汰，让优秀的个体尽可能存活，让差的个体尽可能的淘汰。个体的好坏是取决于个体适应度。个体适应度越高，越容易被留下，个体适应度越低越容易被淘汰。具体的代码如下

[python] view plain copy

# 0.0 coding:utf-8 0.0

# 选择

import random

def sum(fit_value):

total = 0

for i in range(len(fit_value)):

total += fit_value[i]

return total

def cumsum(fit_value):

for i in range(len(fit_value)-2, -1, -1):

t = 0

j = 0

while(j <= i):

t += fit_value[j]

j += 1

fit_value[i] = t

fit_value[len(fit_value)-1] = 1

def selection(pop, fit_value):

newfit_value = []

# 适应度总和

total_fit = sum(fit_value)

for i in range(len(fit_value)):

newfit_value.append(fit_value[i] / total_fit)

# 计算累计概率

cumsum(newfit_value)

ms = []

pop_len = len(pop)

for i in range(pop_len):

ms.append(random.random())

ms.sort()

fitin = 0

newin = 0

newpop = pop

# 转轮盘选择法

while newin < pop_len:

if(ms[newin] < newfit_value[fitin]):

newpop[newin] = pop[fitin]

newin = newin + 1

else:

fitin = fitin + 1

pop = newpop

选择完后就是进行交配和变异，这个两个步骤很好理解。就是对基因序列进行改变，只不过改变的方式不一样

交配：

[python] view plain copy

# 0.0 coding:utf-8 0.0

# 交配

import random

def crossover(pop, pc):

pop_len = len(pop)

for i in range(pop_len - 1):

if(random.random() < pc):

cpoint = random.randint(0,len(pop[0]))

temp1 = []

temp2 = []

temp1.extend(pop[i][0:cpoint])

temp1.extend(pop[i+1][cpoint:len(pop[i])])

temp2.extend(pop[i+1][0:cpoint])

temp2.extend(pop[i][cpoint:len(pop[i])])

pop[i] = temp1

pop[i+1] = temp2

[python] view plain copy

# 0.0 coding:utf-8 0.0

# 基因突变

import random

def mutation(pop, pm):

px = len(pop)

py = len(pop[0])

for i in range(px):

if(random.random() < pm):

mpoint = random.randint(0, py-1)

if(pop[i][mpoint] == 1):

pop[i][mpoint] = 0

else:

pop[i][mpoint] = 1

[python] view plain copy

# 0.0 coding:utf-8 0.0

import matplotlib.pyplot as plt

import math

from calobjValue import calobjValue

from calfitValue import calfitValue

from selection import selection

from crossover import crossover

from mutation import mutation

from best import best

from geneEncoding import geneEncoding

print 'y = 10 * math.sin(5 * x) + 7 * math.cos(4 * x)'

# 计算2进制序列代表的数值

def b2d(b, max_value, chrom_length):

t = 0

for j in range(len(b)):

t += b[j] * (math.pow(2, j))

t = t * max_value / (math.pow(2, chrom_length) - 1)

return t

pop_size = 500 # 种群数量

max_value = 10 # 基因中允许出现的最大值

chrom_length = 10 # 染色体长度

pc = 0.6 # 交配概率

pm = 0.01 # 变异概率

results = [[]] # 存储每一代的最优解，N个二元组

fit_value = [] # 个体适应度

fit_mean = [] # 平均适应度

# pop = [[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] for i in range(pop_size)]

pop = geneEncoding(pop_size, chrom_length)

for i in range(pop_size):

obj_value = calobjValue(pop, chrom_length, max_value) # 个体评价

fit_value = calfitValue(obj_value) # 淘汰

best_indivial, best_fit = best(pop, fit_value) # 第一个存储最优的解, 第二个存储最优基因

results.append([best_fit, b2d(best_indivial, max_value, chrom_length)])

selection(pop, fit_value) # 新种群复制

crossover(pop, pc) # 交配

mutation(pop, pm) # 变异

results = results[1:]

results.sort()

X = []

Y = []

for i in range(500):

X.append(i)

t = results[i][0]

Y.append(t)

plt.plot(X, Y)

plt.show()

完整代码可以在github 查看

欢迎访问我的个人博客

阅读全文

热心网友时间：2022-04-18 18:05

建议使用Python高性能遗传算法库：Geatpy。提供框架方法，几行代码就可以解决复杂的进化优化问题。代码风格与Matlab的类似，容易上手。
https://blog.csdn.net/qq_33353186/article/details/82014986

一个易用、易部署的Python遗传算法库

介绍一个功能强大且易于部署的Python遗传算法库，它封装了包括差分进化、遗传、粒子群、模拟退火、蚁群、鱼群和免疫优化在内的七种启发式算法。安装方法灵活，可以选择直接下载库中的'sko'文件夹，或者按照文档步骤进行。该库的一大特色是支持用户自定义（UDF）操作，你可以创建并注册新的算子，如:pythonimp...

python 哪个包里有遗传算法

scikit-opt 调研过很多遗传算法库，这个挺好用的。目标函数def demo_func(x): x1, x2, x3 = x return x1 ** 2 + (x2 - 0.05) ** 2 + x3 ** 2from ga import GA调用遗传算法求解：ga = GA(func=demo_func, lb=[-1, -10, -5], ub=[2, 10, 2], max_iter=500)...

遗传算法的Python代码实现

通过一个具体的例子，我们可以看到如何用Python实现遗传算法。比如，我们有6个输入和6个权重，目标是找到使方程输出最大的权重组合。首先，定义输入变量和权重数量。然后，初始化一个包含随机权重值的人口，每个个体由6个基因（权重）组成。接下来，定义适应度函数，它通过计算输入与权重的乘积之和来评估解...

[1] 遗传算法--附Python代码

在Python中，例如用于TSP问题的遗传算法，首先导入所需库，设定参数，然后构建算法模型，模拟实验场景，执行主函数以求解并可视化结果。通过这些步骤，遗传算法能够在各种优化问题中寻找潜在的最优解。

[1] 遗传算法--附Python代码

遗传算法的重组算子里包含交叉算子等其他重组算子，由于遗传算法中有二进制编码、实值编码、排列编码、树编码等编码方式，因此也必须有与编码方式相适应的不同的交叉算子。二进制编码中常见的有一点交叉、二点交叉等重组算子。交叉概率通常用 [公式] 来表示，它是指两个染色体之间发生交叉重组的概率。交叉...

遗传算法自习笔记附代码(python语言实现)

通过迭代操作，遗传算法最终会收敛于一个近似最优解。Python实现的完整代码展示了这一过程，包括目标函数、适应度函数、转换函数、变异和交叉操作等。遗传算法在优化问题中具有广泛的应用，但其结果往往为近似最优解。为了提高算法的性能，可以考虑优化选择策略、增加种群数量或增加迭代次数。完整Python代码如下...

使用流行的遗传算法python库是哪个

建议使用由华南农业大学、暨南大学、华南理工大学高校硕博学生联合团队推出的Python高性能遗传和进化算法工具箱：Geatpy。它是目前进化计算领域与platemo、matlab遗传算法工具箱等有相当的权威和影响力的高性能实用型进化算法工具箱，而其效率和易用性居于领先地位。目前已得到多所高校研究生实验室以及企业采用，...

python:遗传算法(Genetic Algorithm,GA)求解23个测试函数

Python中的遗传算法（Genetic Algorithm, GA）：解决23个测试函数实例遗传算法，一种源自生物进化模拟的高效全局优化工具，模仿了自然选择和遗传过程中的关键机制，如复制、交叉与变异。它以初始种群为起点，通过随机选择、交叉和变异操作，逐步引导群体在搜索空间中探寻更优解。这种方法旨在通过迭代迭代，让...

用python写个云顶之弈阵容助手,助你今晚“吃鸡”(遗传算法)

于是，我灵机一动，想要编写一个阵容助手（Python），根据你想要玩的英雄，基于遗传算法为你推荐阵容。目前该助手适配9.19版本，如果有新的阵容出现，修改起来也很方便。另外，增加了铲子功能，但只能增加一个（增加两个计算量大，不够实时）。爬取相关网站内容获取英雄信息这一步可以通过手动输入来实现...

【Python机器学习】用遗传算法实现符号回归——浅析gplearn

在Python机器学习领域，gplearn作为符号回归算法的代表，以其成熟度超越了同类工具。它利用遗传算法寻找隐藏的数学公式，以更复杂的方式处理特征变量与目标变量之间的关系。不同于线性模型的简单表达，符号回归探索的是潜在的非线性规律。遗传算法的核心是通过随机生成并演化公式，每一代通过适应度评估筛选出最...

python遗传算法pygmo python遗传算法有多慢 python遗传算法库遗传算法和蚁群算法哪个简单遗传算法python代码 python遗传算法求解货位分配 python遗传算法工具包简单遗传算法的三种遗传算法Python