Python 实现遗传算法求解函数极值

季宁

发布时间：2026-10-12 | 4人浏览过

原创

本文介绍如何使用 Python 复现遗传算法以寻找函数极值。通过定义种群、适应度计算、选择、交叉和变异等核心步骤，实现对目标函数的优化求解。代码包含完整的类封装与可视化展示，旨在帮助开发者理解算法逻辑并加深技术印象。

Python 遗传算法求函数极值的实现代码

为了深入理解遗传算法的运行机制，这里使用 Python 语言对经典的遗传算法流程进行了复现。该实现参考了 MATLAB 的相关逻辑，主要目的是通过代码实践来巩固对算法原理的认识。核心目标是通过迭代进化过程，寻找给定数学函数的极大值。

算法核心逻辑与参数设置

遗传算法的实现依赖于几个关键参数的设定，包括变量范围、编码精度、种群规模以及进化代数。在代码中，我们定义了一个 Ga 类来封装这些逻辑。初始参数设置如下：

变量范围：设定为 [-2, 3]。
运算精度：设定为 0.0001，据此计算二进制编码的染色体长度。
种群大小：初始种群包含 50 个个体。
最大进化代数：设定为 12 代。
概率控制：交叉概率设为 0.90，变异概率设为 0.2。

初始种群通过随机生成二进制串产生，每个个体的长度由编码精度和变量范围决定。

关键步骤实现

算法的执行过程主要包含以下几个核心模块：

1. 适应度计算

首先将二进制编码的个体转换为十进制数值，并映射到指定的变量区间。随后，通过目标函数计算每个个体的适应度值。为了进行轮盘赌选择，需要计算每个个体的选择概率，并生成累积概率序列，以便后续的选择操作。

2. 选择操作

基于累积概率，采用轮盘赌策略从种群中挑选两个个体进行繁殖。通过生成随机数并与累积概率比较，确定被选中的个体索引，从而保留适应度较高的基因片段。

3. 交叉与变异

交叉：以设定的概率执行单点交叉。随机选择一个交叉点，交换两个选中个体的后半部分基因序列，生成新的子代染色体。
变异：以设定的概率对子代个体进行变异。随机选择一个基因位，将其值翻转（0 变 1，1 变 0），以增加种群的多样性，防止陷入局部最优。

4. 主循环与结果输出

在主程序中，通过迭代执行选择、交叉和变异操作来更新种群。每一代结束后，记录当前种群中的最大适应度值及其对应的变量值。经过设定的代数后，输出最优解的变量值和函数极值。

完整代码实现

以下是完整的 Python 实现代码，包含算法逻辑及结果可视化部分：

"""遗传算法实现求函数极大值—Zjh"""
import numpy as np
import random
import matplotlib.pyplot as plt
class Ga():
 """求出二进制编码的长度"""
 def __init__(self):
  self.boundsbegin = -2
  self.boundsend = 3
  precision = 0.0001 # 运算精确度
  self.Bitlength = int(np.log2((self.boundsend - self.boundsbegin)/precision))+1#%染色体长度
  self.popsize = 50# 初始种群大小
  self.Generationmax = 12# 最大进化代数
  self.pcrossover = 0.90# 交叉概率
  self.pmutation = 0.2# 变异概率
  self.population=np.random.randint(0,2,size=(self.popsize,self.Bitlength))
 
 """计算出适应度"""
 def fitness(self,population):
  Fitvalue=[]
  cumsump = []
  for i in population:
   x=self.transform2to10(i)#二进制对应的十进制
   xx=self.boundsbegin + x * (self.boundsend - self.boundsbegin) / (pow(2,self.Bitlength)-1)
   s=self.targetfun(xx)
   Fitvalue.append(s)
  fsum=sum(Fitvalue)
  everypopulation=[x/fsum for x in Fitvalue]
  cumsump.append(everypopulation[0])
  everypopulation.remove(everypopulation[0])
  for j in everypopulation:
   p=cumsump[-1]+j
   cumsump.append(p)
  return Fitvalue,cumsump
 """选择两个基因，准备交叉"""
 def select(self,cumsump):
  seln=[]
  for i in range(2):
   j = 1
   r=np.random.uniform(0,1)
   prand =[x-r for x in cumsump]
   while prand[j] < 0:
    j = j + 1
   seln.append(j)
  return seln
 """交叉"""
 def crossover(self, seln, pc):
  d=self.population[seln[1]].copy()
  f=self.population[seln[0]].copy()
  r=np.random.uniform()
  if r<pc:
   print('yes')
   c=np.random.randint(1,self.Bitlength-1)
   print(c)
   a=self.population[seln[1]][c:]
   b=self.population[seln[0]][c:]
   d[c:]=b
   f[c:]=a
   print(d)
   print(f)
   g=d
   h=f
  else:
   g=self.population[seln[1]]
   h=self.population[seln[0]]
  return g,h
 """变异操作"""
 def mutation(self,scnew,pmutation):
  r=np.random.uniform(0, 1)
  if r < pmutation:
   v=np.random.randint(0,self.Bitlength)
   scnew[v]=abs(scnew[v]-1)
  else:
   scnew=scnew
  return scnew
 
 """二进制转换为十进制"""
 def transform2to10(self,population):
  #x=population[-1] #最后一位的值
  x=0
  #n=len(population)
  n=self.Bitlength
  p=population.copy()
  p=p.tolist()
  p.reverse()
  for j in range(n):
   x=x+p[j]*pow(2,j)
  return x #返回十进制的数
 """目标函数"""
 def targetfun(self,x):
  #y = x∗(np.sin(10∗(np.pi)∗x))+ 2
  y=x*(np.sin(10*np.pi*x))+2
  return y
 
if __name__ == '__main__':
 Generationmax=12
 gg=Ga()
 scnew=[]
 ymax=[]
 #print(gg.population)
 Fitvalue, cumsump=gg.fitness(gg.population)
 Generation = 1
 while Generation < Generationmax +1:
  Fitvalue, cumsump = gg.fitness(gg.population)
  for j in range(0,gg.popsize,2):
   seln = gg.select( cumsump) #返回选中的2个个体的序号
   scro = gg.crossover(seln, gg.pcrossover) #返回两条染色体
   s1=gg.mutation(scro[0],gg.pmutation)
   s2=gg.mutation(scro[1],gg.pmutation)
   scnew.append(s1)
   scnew.append(s2)
  gg.population = scnew
  Fitvalue, cumsump = gg.fitness(gg.population)
  fmax=max(Fitvalue)
  d=Fitvalue.index(fmax)
  ymax.append(fmax)
  x = gg.transform2to10(gg.population[d])
  xx = gg.boundsbegin + x * (gg.boundsend - gg.boundsbegin) / (pow(2, gg.Bitlength) - 1)
  Generation = Generation + 1
 Bestpopulation = xx
 Targetmax = gg.targetfun(xx)
 print(xx)
 print(Targetmax)
 
x=np.linspace(-2,3,30)
y=x*(np.sin(10*np.pi*x))+2
plt.scatter(2.65,4.65,c='red')
plt.xlim(0,5)
plt.ylim(0,6)
plt.plot(x,y)
plt.annotate('local max', xy=(2.7,4.8), xytext=(3.6, 5.2),arrowprops=dict(facecolor='black', shrink=0.05))
plt.show()