Python遗传和进化算法框架（一）Geatpy快速入门[通俗易懂]

pip install geatpy

pip install --upgrade geatpy

pip install --user --upgrade geatpy

"""demo.py"""
import numpy as np
import geatpy as ea # 导入geatpy库
import matplotlib.pyplot as plt
import time

"""============================目标函数============================"""
def aim(x):                    # 传入种群染色体矩阵解码后的基因表现型矩阵
    return x * np.sin(10 * np.pi * x) + 2.0
x = np.linspace(-1, 2, 200)
plt.plot(x, aim(x)) # 绘制目标函数图像
"""============================变量设置============================"""
x1 = [-1, 2]                   # 自变量范围
b1 = [1, 1]                    # 自变量边界
varTypes = np.array([0])       # 自变量的类型，0表示连续，1表示离散
Encoding = 'BG'                # 'BG'表示采用二进制/格雷编码
codes = [1]                    # 变量的编码方式，2个变量均使用格雷编码
precisions =[4]                # 变量的编码精度
scales = [0]                   # 采用算术刻度
ranges=np.vstack([x1]).T       # 生成自变量的范围矩阵
borders=np.vstack([b1]).T      # 生成自变量的边界矩阵
"""=========================遗传算法参数设置========================="""
NIND = 40;                     # 种群个体数目
MAXGEN = 25;                   # 最大遗传代数
FieldD = ea.crtfld(Encoding,varTypes,ranges,borders,precisions,codes,scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :]))          # 计算编码后的染色体长度
obj_trace = np.zeros((MAXGEN, 2))         # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind))      # 定义染色体记录器，记录每一代最优个体的染色体
"""=========================开始遗传算法进化========================"""
start_time = time.time()                             # 开始计时
Chrom = ea.crtbp(NIND, Lind)                         # 生成种群染色体矩阵
variable = ea.bs2ri(Chrom, FieldD)                 # 对初始种群进行解码
ObjV = aim(variable)                                 # 计算初始种群个体的目标函数值
best_ind = np.argmax(ObjV)                           # 计算当代最优个体的序号
# 开始进化
for gen in range(MAXGEN):
    FitnV = ea.ranking(-ObjV)                        # 根据目标函数大小分配适应度值(由于遵循目标最小化约定，因此最大化问题要对目标函数值乘上-1)
    SelCh=Chrom[ea.selecting('rws', FitnV, NIND-1), :] # 选择，采用'rws'轮盘赌选择
    SelCh=ea.recombin('xovsp', SelCh, 0.7)           # 重组(采用两点交叉方式，交叉概率为0.7)
    SelCh=ea.mutbin(Encoding, SelCh)                 # 二进制种群变异
    # 把父代精英个体与子代合并
    Chrom = np.vstack([Chrom[best_ind, :], SelCh])
    variable = ea.bs2ri(Chrom, FieldD)             # 对育种种群进行解码(二进制转十进制)
    ObjV = aim(variable)                             # 求育种个体的目标函数值
    # 记录
    best_ind = np.argmax(ObjV)                       # 计算当代最优个体的序号
    obj_trace[gen, 0] = np.sum(ObjV) / NIND          # 记录当代种群的目标函数均值
    obj_trace[gen, 1] = ObjV[best_ind]               # 记录当代种群最优个体目标函数值
    var_trace[gen, :] = Chrom[best_ind, :]           # 记录当代种群最优个体的变量值
# 进化完成
end_time = time.time() # 结束计时
"""============================输出结果及绘图================================"""
best_gen = np.argmax(obj_trace[:, [1]])
print('目标函数最大值：', obj_trace[best_gen, 1]) # 输出目标函数最大值
variable = ea.bs2ri(var_trace[[best_gen], :], FieldD) # 解码得到表现型
print('对应的决策变量值为：')
print(variable[0][0]) # 因为此处variable是一个矩阵，因此用[0][0]来取出里面的元素
print('用时：', end_time - start_time)
plt.plot(variable, aim(variable),'bo')
ea.trcplot(obj_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']])

import geatpy as ga
help(ga.ranking)

# -*- coding: utf-8 -*-
"""MyProblem.py"""
import numpy as np
import geatpy as ea

class MyProblem(ea.Problem): # 继承Problem父类
    def __init__(self):
        name = 'ZDT1' # 初始化name（函数名称，可以随意设置）
        M = 2 # 初始化M（目标维数）
        maxormins = [1] * M # 初始化maxormins（目标最小最大化标记列表，1：最小化该目标；-1：最大化该目标）
        Dim = 30 # 初始化Dim（决策变量维数）
        varTypes = [0] * Dim # 初始化varTypes（决策变量的类型，0：实数；1：整数）
        lb = [0] * Dim # 决策变量下界
        ub = [1] * Dim # 决策变量上界
        lbin = [1] * Dim # 决策变量下边界
        ubin = [1] * Dim # 决策变量上边界
        # 调用父类构造方法完成实例化
        ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin)
    
    def aimFunc(self, pop): # 目标函数
        Vars = pop.Phen # 得到决策变量矩阵
        ObjV1 = Vars[:, 0]
        gx = 1 + 9 * np.mean(Vars[:, 1:30], 1)
        hx = 1 - np.sqrt(ObjV1 / gx)
        ObjV2 = gx * hx
        pop.ObjV = np.array([ObjV1, ObjV2]).T # 把结果赋值给ObjV
    
    def calReferObjV(self): # 计算全局最优解作为目标函数参考值
        N = 10000 # 生成10000个参考点
        ObjV1 = np.linspace(0, 1, N)
        ObjV2 = 1 - np.sqrt(ObjV1)
        globalBestObjV = np.array([ObjV1, ObjV2]).T
        
        return globalBestObjV

# -*- coding: utf-8 -*-
import geatpy as ea  # import geatpy
from MyProblem import MyProblem

if __name__ == '__main__':
    problem = MyProblem()  # 生成问题对象
    # 构建算法
    algorithm = ea.moea_NSGA2_templet(problem,
                                      ea.Population(Encoding='RI', NIND=50),
                                      MAXGEN=200,  # 最大进化代数。
                                      logTras=1)  # 表示每隔多少代记录一次日志信息，0表示不记录。
    # 求解
    res = ea.optimize(algorithm, verbose=True, drawing=1, outputMsg=True, drawLog=False, saveFlag=False, dirName='result')