精华内容
下载资源
问答
  • 包括5个章节内容,分别是:一、Geatpy 总览;二、Geatpy 数据结构;三、快速入门;四、进化算法模板;五、多染色体混合编码。
  • Geatpy 遗传算法库介绍和使用方法,包括5个部分,包括是进化算法模板的相关实现介绍以及调用的函数声明。
  • python的第三方遗传算法库Geatpy,内置demo和说明文档都很详细
  • Geatpy2 适用于Python的高性能遗传进化算法工具箱。 介绍 网站(包括文档) : : 演示: : Pypi页面: : //pypi.org/project/geatpy/ 与我们联系: : 错误报告: : 注意: : 常见问题解答: : Geatpy的...
  • Geatpy自定义初始种群

    2021-05-11 15:38:45
    首先先用Geatpy写一个没有做自定义初始化的程序,确保能跑通哟,或是直接使用官网的demo也行 自定义初始种群 自定义初始种群与要求解的问题无关,所以不需要管Myproblem怎么写的。只需要查看Main.py,这是我自己的...

    首先先用Geatpy写一个没有做自定义初始化的程序,确保能跑通哟,或是直接使用官网的demo也行

    自定义初始种群

    1. 自定义初始种群与要求解的问题无关,所以不需要管Myproblem怎么写的。只需要查看Main.py,这是我自己的代码:
    # -*- coding: utf-8 -*-
    import geatpy as ea  # import geatpy
    from Myproblem import MyProblem
    import numpy as np
    
    if __name__ == '__main__':
        """================================实例化问题对象==========================="""
        problem = MyProblem()  # 生成问题对象
        """==================================种群设置=============================="""
        Encoding = 'RI'  # 编码方式
        NIND = 50  # 种群规模
        Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges, problem.borders)  # 创建区域描述器
        population = ea.Population(Encoding, Field, NIND)  # 实例化种群对象(此时种群还没被初始化,仅仅是完成种群对象的实例化)
        """================================算法参数设置============================="""
        myAlgorithm = ea.soea_DE_currentToBest_1_L_templet(problem, population)  # 实例化一个算法模板对象
        # myAlgorithm = ea.moea_psy_NSGA2_templet(problem, population)  # 实例化一个算法模板对象
        myAlgorithm.MAXGEN = 5000  # 最大进化代数
        myAlgorithm.mutOper.F = 0.5  # 差分进化中的参数F
        myAlgorithm.recOper.XOVR = 0.3  # 重组概率
        myAlgorithm.logTras = 1  # 设置每隔多少代记录日志,若设置成0则表示不记录日志
        myAlgorithm.verbose = True  # 设置是否打印输出日志信息
        myAlgorithm.drawing = 1  # 设置绘图方式(0:不绘图;1:绘制结果图;2:绘制目标空间过程动画;3:绘制决策空间过程动画)
        """===========================调用算法模板进行种群进化========================"""
        [BestIndi, population] = myAlgorithm.run()  # 执行算法模板,得到最优个体以及最后一代种群
        BestIndi.save()  # 把最优个体的信息保存到文件中
        """==================================输出结果=============================="""
        print('评价次数:%s' % myAlgorithm.evalsNum)
        print('时间已过 %s 秒' % myAlgorithm.passTime)
        if BestIndi.sizes != 0:
            print('最优的目标函数值为:%s' % BestIndi.ObjV[0][0])
            print('最优的控制变量值为:')
            for i in range(BestIndi.Phen.shape[1]):
                print(BestIndi.Phen[0, i])
        else:
            print('没找到可行解。')
    
    1. 由于新版的geatpy使用先验知识作为初始化染色体的方法,因此需要在算法参数设置之后添加这些内容:
        """===========================根据先验知识创建先知种群========================"""
        prophetChrom = np.zeros((NIND,123))  # 我的Problem里有123个未知数,这里将全0值作为先知种群,
        prophetPop = ea.Population(Encoding, Field, NIND, prophetChrom)  # 实例化种群对象
        myAlgorithm.call_aimFunc(prophetPop)  # 计算先知种群的目标函数值及约束(假如有约束)
    
    1. 最后把先知种群传进去,修改调用算法模板进行种群进化的第一行就行:
        [BestIndi, population] = myAlgorithm.run(prophetPop)  # 执行算法模板,得到最优个体以及最后一代种群
    

    注意:prophetChrom这个值的shape需要为(种群规模,x的数量),并且为ndarry格式的数据

    全部案例代码

    # -*- coding: utf-8 -*-
    import geatpy as ea  # import geatpy
    from Myproblem import MyProblem
    import numpy as np
    
    if __name__ == '__main__':
        """================================实例化问题对象==========================="""
        problem = MyProblem()  # 生成问题对象
        """==================================种群设置=============================="""
        Encoding = 'RI'  # 编码方式
        NIND = 180  # 种群规模
        Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges, problem.borders)  # 创建区域描述器
        population = ea.Population(Encoding, Field, NIND)  # 实例化种群对象(此时种群还没被初始化,仅仅是完成种群对象的实例化)
        """================================算法参数设置============================="""
        myAlgorithm = ea.soea_DE_currentToBest_1_L_templet(problem, population)  # 实例化一个算法模板对象
        # myAlgorithm = ea.moea_psy_NSGA2_templet(problem, population)  # 实例化一个算法模板对象
        myAlgorithm.MAXGEN = 5000  # 最大进化代数
        myAlgorithm.mutOper.F = 0.5  # 差分进化中的参数F
        myAlgorithm.recOper.XOVR = 0.3  # 重组概率
        myAlgorithm.logTras = 1  # 设置每隔多少代记录日志,若设置成0则表示不记录日志
        myAlgorithm.verbose = True  # 设置是否打印输出日志信息
        myAlgorithm.drawing = 1  # 设置绘图方式(0:不绘图;1:绘制结果图;2:绘制目标空间过程动画;3:绘制决策空间过程动画)
        """===========================根据先验知识创建先知种群========================"""
        prophetChrom = np.zeros((NIND, 123))  # 我的Problem里有123个未知数,这里将全0值作为先知种群,
        prophetPop = ea.Population(Encoding, Field, NIND, prophetChrom)  # 实例化种群对象
        myAlgorithm.call_aimFunc(prophetPop)  # 计算先知种群的目标函数值及约束(假如有约束)
        """===========================调用算法模板进行种群进化========================"""
        [BestIndi, population] = myAlgorithm.run(prophetPop)  # 执行算法模板,得到最优个体以及最后一代种群
        BestIndi.save()  # 把最优个体的信息保存到文件中
        """==================================输出结果=============================="""
        print('评价次数:%s' % myAlgorithm.evalsNum)
        print('时间已过 %s 秒' % myAlgorithm.passTime)
        if BestIndi.sizes != 0:
            print('最优的目标函数值为:%s' % BestIndi.ObjV[0][0])
            print('最优的控制变量值为:')
            for i in range(BestIndi.Phen.shape[1]):
                print(BestIndi.Phen[0, i])
        else:
            print('没找到可行解。')
    

    参考资料

    官方soea Demo10:https://github.com/geatpy-dev/geatpy/tree/master/geatpy/demo/soea_demo/soea_demo10
    是什么原因移除Popuplation,setChrom方法? #130:https://github.com/geatpy-dev/geatpy/issues/130

    展开全文
  • geatpy-master.zip

    2020-03-09 12:24:39
    遗传算法python框架,全中文注释。亲测内置nsga2,nsga3速度超过同等情况下的c++以及java。python版遗传算法工具箱,支持已知的单目标,多目标遗传算子。
  • Python遗传和进化算法框架(一)Geatpy快速入门

    万次阅读 多人点赞 2019-08-08 22:16:26
    Geatpy是一个高性能实用型的Python遗传算法工具箱,提供一个面向对象的进化算法框架,经过全面改版后,新版Geatpy2目前由华南农业大学、暨南大学、华南理工等本硕博学生联合团队开发及维护。 Website (including ...

    Geatpy是一个高性能实用型的Python遗传算法工具箱,提供一个面向对象的进化算法框架,经过全面改版后,新版Geatpy2目前由华南农业大学、暨南大学、华南理工等本硕博学生联合团队开发及维护。

    Geatpy提供了许多已实现的遗传和进化算法相关算子的库函数,如初始化种群、选择、交叉、变异、重插入、多目标优化非支配排序等,并且提供诸多已实现的进化算法模板来实现多样化的进化算法。其执行效率高于Matlab、Java和Python编写的一些知名工具箱、平台或框架等,学习成本低、模块高度脱耦、扩展性高。

    Geatpy支持二进制/格雷码编码种群、实数值种群、整数值种群、排列编码种群。支持轮盘赌选择、随机抽样选择、锦标赛选择。提供单点交叉、两点交叉、洗牌交叉、部分匹配交叉(PMX)、顺序交叉(OX)、线性重组、离散重组、中间重组等重组算子。提供简单离散变异、实数值变异、整数值变异、互换变异等变异算子。支持随机重插入、精英重插入。支持awGA、rwGA、nsga2、快速非支配排序等多目标优化的库函数、提供进化算法框架下的常用进化算法模板等。

    关于遗传算法、进化算法的学习资料,在官网中https://www.geatpy.com 有详细讲解以及相关的学术论文链接。同时网上也有很多资料。

    闲话少说……下面讲一下怎么安装和使用:

    先说一下安装方法

    首先是要windows系统,Python要是3.5,3.6或3.7版本 ,并且安装了pip。只需在控制台执行

    pip install geatpy

    即可安装成功。或者到github上下载源码进行编译安装:https://github.com/geatpy-dev/geatpy 。推荐是直接用pip的方式安装。因为这样方便后续的更新。我为了方便运行demo代码以及查看源码和官方教程文档,因此另外在github上也下载了(但仍用pip方式安装)。

    有些初学Python的读者反映还是不知道怎么安装,或者安装之后不知道怎么写代码。这里推荐安装Anaconda,它集成了Python的许多常用的运行库,比如Numpy、Scipy等。其内置的Spyder开发软件的风格跟Matlab类似,给人熟悉的感觉,更容易上手。

    再说一下更新方法

    Geatpy在持续更新。可以通过以下命令使电脑上的版本与官方最新版保持一致:

    pip install --upgrade geatpy

    若在更新过程中遇到"--user"错误的问题,这是用pip进行安装时遇到的常见问题之一。意味着需要以管理员方式运行

    pip install --user --upgrade geatpy

    Geatpy提供2种方式来使用进化算法求解问题。先来讲一下第一种最基本的实现方式:编写编程脚本。

    1. 编写脚本实现遗传算法:

    以一个非常简单的单目标优化问题为例:求f(x)=x*sin(10*pi*x)+2.0 在 x∈[-1,2] 上的最大值。

    直接编写脚本如下:

    """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, [['种群个体平均目标函数值', '种群最优个体目标函数值']])
    

    运行结果如下:

    目标函数最大值: 3.850272716105895
    对应的决策变量值为:
    1.8505813776055176
    用时: 0.02496051788330078

    仔细查看上述代码,我们会发现Geatpy的书写风格与Matlab大同小异,有Matlab相关编程经验的基本上可以无缝转移到Python上利用Geatpy进行遗传算法程序开发。

    Geatpy提供了详尽的API文档,比如要查看上面代码中的"ranking"函数是干什么的,可以在python中执行

    import geatpy as ga
    help(ga.ranking)

    即可看到"ranking"函数的相关使用方法。

    另外官网上也有更多详尽的Geatpy教程:http://geatpy.com/index.php/details/

    2. 利用框架实现遗传算法。

    Geatpy提供开放的面向对象进化算法框架。即“问题类”+“进化算法模板类+种群类”。对于一些复杂的进化算法,如多目标进化优化、改进的遗传算法等,按照上面所说的编写脚本代码是非常麻烦的,而用框架的方法可以极大提高编程效率

    这里给出一个利用框架实现NSGA-II算法求多目标优化函数ZDT-1的帕累托前沿面的例子:

    第一步:首先编写ZDT1的问题类,写在“MyProblem.py”文件中:

    # -*- 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.sum(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
        

    上面代码中,问题类的构造函数__init__()是用于定义与ZDT1测试问题相关的一些参数,如决策变量范围、类型、边界等等。aimFunc()是待优化的目标函数。calReferObjV()用来计算理论的全局最优解,这个理论最优解可以是通过计算得到的,也可以是通过导入外部文件的数据得到的,如果待求解的问题没有或尚不知道理论最优解是多少,则这个calReferObjV()函数可以省略不写。

    第二步:在同一个文件夹下编写执行脚本,实例化上述问题类的对象,然后调用Geatpy提供的nsga2算法的进化算法模板(moea_NSGA2_templet),最后结合理论全局最优解PF(即俗称的“真实前沿点”)通过计算GD、IGD、HV等指标来分析优化效果:

    # -*- coding: utf-8 -*-
    import geatpy as ea # import geatpy
    from MyProblem import MyProblem
    
    """================================实例化问题对象============================="""
    problem = MyProblem()     # 生成问题对象
    """==================================种群设置================================"""
    Encoding = 'RI'           # 编码方式
    NIND = 50                 # 种群规模
    Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges, problem.borders) # 创建区域描述器
    population = ea.Population(Encoding, Field, NIND) # 实例化种群对象(此时种群还没被初始化,仅仅是完成种群对象的实例化)
    """================================算法参数设置==============================="""
    myAlgorithm = ea.moea_NSGA2_templet(problem, population) # 实例化一个算法模板对象`
    myAlgorithm.MAXGEN = 200  # 最大进化代数
    myAlgorithm.logTras = 1  # 设置每多少代记录日志,若设置成0则表示不记录日志
    myAlgorithm.verbose = True  # 设置是否打印输出日志信息
    myAlgorithm.drawing = 1  # 设置绘图方式(0:不绘图;1:绘制结果图;2:绘制目标空间过程动画;3:绘制决策空间过程动画)
    """==========================调用算法模板进行种群进化=========================
    调用run执行算法模板,得到帕累托最优解集NDSet以及最后一代种群。NDSet是一个种群类Population的对象。
    NDSet.ObjV为最优解个体的目标函数值;NDSet.Phen为对应的决策变量值。
    详见Population.py中关于种群类的定义。
    """
    [NDSet, population] = myAlgorithm.run()  # 执行算法模板,得到非支配种群以及最后一代种群
    NDSet.save()  # 把非支配种群的信息保存到文件中
    """==================================输出结果=============================="""
    print('用时:%f 秒' % myAlgorithm.passTime)
    print('评价次数:%d 次' % myAlgorithm.evalsNum)
    print('非支配个体数:%d 个' % NDSet.sizes) if NDSet.sizes != 0 else print('没有找到可行解!')
    if myAlgorithm.log is not None and NDSet.sizes != 0:
        print('GD', myAlgorithm.log['gd'][-1])
        print('IGD', myAlgorithm.log['igd'][-1])
        print('HV', myAlgorithm.log['hv'][-1])
        print('Spacing', myAlgorithm.log['spacing'][-1])
        """=========================进化过程指标追踪分析========================="""
        metricName = [['igd'], ['hv']]
        Metrics = np.array([myAlgorithm.log[metricName[i][0]] for i in range(len(metricName))]).T
        # 绘制指标追踪分析图
        ea.trcplot(Metrics, labels=metricName, titles=metricName)
    

    运行结果如下:

     

    。。。

    上述代码中已经对各个流程进行了详细的注释。其中进化算法的核心逻辑是写在进化算法模板内部的,可前往查看对应的源代码。此外,我们还可以参考Geatpy进化算法模板的源代码来自定义算法模板,以实现丰富多样的进化算法,如各种各样的改进的进化算法等:

    最后值得注意的是:目标函数aimFunc()那一块地方最容易写错。aimFunc()的输入参数pop是一个种群对象(有关种群对象可以查看工具箱中的Population.py类源码,或者查看Geatpy数据结构)。pop.Phen是种群的表现型矩阵,意思是种群染色体解码后得到的表现型矩阵,它对应的即为问题类中的决策变量。Phen是一个矩阵,每一行对应种群中的一个个体的表现型。在计算目标函数时,可以把这个Phen拆成一行一行,即逐个逐个个体地计算目标函数值,然后再拼成一个矩阵赋值给pop对象的ObjV属性。也可以利用Numpy的矩阵化计算来“一口气”把种群所有个体的目标函数值计算出来。无论采用的是哪种计算方法,最后得到的目标函数值是要保存在pop对象的ObjV属性中的,这个ObjV是“种群目标函数值矩阵”,每一行对应一个个体的所有目标函数值,每一列对应一个目标。比如:

     

    它表示有种群3个个体,待优化目标有2个。

    后面的博客将深入理解Geatpy的数据结构、进化算法框架的用法与扩展,以及探讨框架的核心——进化算法模板的实现。还会讲一些使用Geatpy解决问题的案例。欢迎继续跟进~感谢!

     

    展开全文
  • Geatpy求解TSP问题

    2021-09-06 20:49:36
    Geatpy求解TSP 代码: import geatpy as ea import numpy as np from math import sin, asin, cos, radians, fabs, sqrt import matplotlib.pyplot as plt # TSP坐标点 places=[[117.000923, 36.675807], [115....

    Geatpy求解TSP


    代码:

    import geatpy as ea
    import numpy as np
    from math import sin, asin, cos, radians, fabs, sqrt
    import matplotlib.pyplot as plt
    
    # TSP坐标点
    places=[[117.000923, 36.675807], [115.48333, 38.03333], [125.35, 43.88333], [127.63333, 47.75], [123.38333, 41.8], 
            [111.670801, 41.818311], [87.68333, 43.76667], [103.73333, 36.03333], [106.26667, 37.46667], [112.53333, 37.86667], 
            [108.95, 34.26667], [113.65, 34.76667], [117.283042, 31.86119], [119.78333, 32.05], [120.2, 30.26667], [118.3, 26.08333],
            [113.23333, 23.16667], [115.9, 28.68333], [110.35, 20.01667], [108.320004, 22.82402], [106.71667, 26.56667], [113.0, 28.21667],
            [114.298572, 30.584355], [104.06667, 30.66667], [102.73333, 25.05], [91.0, 30.6], [96.75, 36.56667], [117.2, 39.13333], 
            [121.55333, 31.2], [106.45, 29.56667], [116.41667, 39.91667], [121.3, 25.03], [114.1, 22.2], [113.5, 22.2]]
    #print(len(places))
    def get_distance(position1,position2):
        '''
            获取相邻两个城市的距离
            position1:第一个地区的经纬度,为列表形式
        
            position2:第二个地区的经纬度,为列表形式
        
            传入两个地区的地理坐标,返回二者的距离
        '''
        lng1,lat1,lng2,lat2 = (position1[0],position1[1],position2[0],position2[1])
        lng1, lat1, lng2, lat2 = map(radians, [float(lng1), float(lat1), float(lng2), float(lat2)]) # 经纬度转换成弧度
        dlon=lng2-lng1
        dlat=lat2-lat1
        a=sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
        distance=2*asin(sqrt(a))*6371*1000 # 地球平均半径,6371km
        distance=round(distance/1000,3)
        return distance
    
    # 定义问题
    class MyProblem(ea.Problem):  # 继承Problem父类
        def __init__(self):
            name = 'MyProblem'  # 初始化name(函数名称,可以随意设置)
            M = 1  # 初始化M(目标维数)
            maxormins = [1]  # 初始化maxormins(目标最小最大化标记列表,1:最小化该目标;-1:最大化该目标)
            Dim = len(places) - 1 # 初始化Dim(决策变量维数)
            varTypes = [1] * Dim  # 初始化varTypes(决策变量的类型,元素为0表示对应的变量是连续的;1表示是离散的)
            lb = [1] * Dim  # 决策变量下界
            ub = [Dim] * Dim  # 决策变量上界
            lbin = [1] * Dim  # 决策变量下边界(0表示不包含该变量的下边界,1表示包含)
            ubin = [1] * Dim  # 决策变量上边界(0表示不包含该变量的上边界,1表示包含)
            # 调用父类构造方法完成实例化
            ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin)
            # 新增一个属性存储旅行地坐标
            self.places = np.array(places)
    
        def aimFunc(self, pop):  # 目标函数
            x = pop.Phen.copy()  # 得到决策变量矩阵
            # 添加最后回到出发地
            X = np.hstack([x, x[:, [0]]]).astype(int)
            ObjV = []  # 存储所有种群个体对应的总路程
            for i in range(pop.sizes):
                journey = self.places[X[i], :]  # 按既定顺序到达的地点坐标
                distance = 0.0
                for j in range(len(journey)-1):
                    distance+=get_distance(journey[j],journey[j+1])
                #distance = np.sum(np.sqrt(np.sum(np.diff(journey.T) ** 2, 0)))  # 计算总路程
                #print("dis",distance)
                ObjV.append(distance)
            pop.ObjV = np.array([ObjV]).T
    
    
    """调用模板求解"""
    if __name__ == '__main__':
        """================================实例化问题对象============================"""
        problem = MyProblem()  # 生成问题对象
        """==================================种群设置=============================="""
        Encoding = 'P'  # 编码方式,采用排列编码
        NIND = 100  # 种群规模
        Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges, problem.borders)  # 创建区域描述器
        population = ea.Population(Encoding, Field, NIND)  # 实例化种群对象(此时种群还没被初始化,仅仅是完成种群对象的实例化)
        """================================算法参数设置============================="""
        myAlgorithm = ea.soea_SEGA_templet(problem, population)  # 实例化一个算法模板对象
        myAlgorithm.MAXGEN = 500 # 最大进化代数
        myAlgorithm.mutOper.Pm = 0.8  # 变异概率
        myAlgorithm.logTras = 0  # 设置每隔多少代记录日志,若设置成0则表示不记录日志
        myAlgorithm.verbose = True  # 设置是否打印输出日志信息
        myAlgorithm.drawing = 1  # 设置绘图方式(0:不绘图;1:绘制结果图;2:绘制目标空间过程动画;3:绘制决策空间过程动画)
        """===========================调用算法模板进行种群进化========================"""
        [BestIndi, population] = myAlgorithm.run()  # 执行算法模板,得到最优个体以及最后一代种群
        BestIndi.save()  # 把最优个体的信息保存到文件中
        """==================================输出结果=============================="""
        print('评价次数:%s' % myAlgorithm.evalsNum)
        print('时间已过 %s 秒' % myAlgorithm.passTime)
        if BestIndi.sizes != 0:
            print('最短路程为:%s' % BestIndi.ObjV[0][0])
            print('最佳路线为:')
            best_journey = np.hstack([0, BestIndi.Phen[0, :], 0])
            for i in range(len(best_journey)):
                print(int(best_journey[i]), end=' ')
            print()
            # 绘图
            plt.figure()
            plt.plot(problem.places[best_journey.astype(int), 0], problem.places[best_journey.astype(int), 1], c='black')
            plt.plot(problem.places[best_journey.astype(int), 0], problem.places[best_journey.astype(int), 1], 'o',
                     c='black')
            for i in range(len(best_journey)):
                plt.text(problem.places[int(best_journey[i]), 0], problem.places[int(best_journey[i]), 1],
                         chr(int(best_journey[i]) + 65), fontsize=20)
            plt.grid(True)
            plt.xlabel('x坐标')
            plt.ylabel('y坐标')
            plt.savefig('roadmap.svg', dpi=600, bbox_inches='tight')
        else:
            print('没找到可行解。')
    
    

    运行结果:
    在这里插入图片描述

    import folium
    path = []
    for i in best_journey:
        path.append(places[i])
    m1 = folium.Map(location=[34.26667,108.95000], width=1000, height=500,zoom_start=4,
                   #tiles='http://webst02.is.autonavi.com/appmaptile?style=6&x={x}&y={y}&z={z}', # 高德卫星图
                   #tiles='http://webrd02.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=7&x={x}&y={y}&z={z}', # 高德街道图
                   #attr='default'
                   tiles='OpenStreetMap')
    for i in range(len(path)-1):
        begin = path[i][::-1]
        end = path[i+1][::-1]
        coordinates=[begin,end] 
        aline=folium.PolyLine(locations=coordinates,weight=2,color = 'red') 
        m1.add_child(aline) 
    begin = end
    end = path[0][::-1]
    coordinates=[begin,end] 
    aline=folium.PolyLine(locations=coordinates,weight=2,color = 'red') 
    m1.add_child(aline)
    m1
    

    运行结果:
    在这里插入图片描述

    展开全文
  • Geatpy教程

    千次阅读 2020-04-07 12:25:20
    文章目录Geatpy教程序言简介特色 Geatpy教程 序言 经过长期的不懈努力,新一代高性能实用型进化算法工具箱——Geatpy2正式问世了。在一批优秀硕士毕业生和访学博士离队后,Geatpy团队进行了全面重整,现团队由华南...

    Geatpy教程

    序言

    经过长期的不懈努力,新一代高性能实用型进化算法工具箱——Geatpy2正式问世了。在一批优秀硕士毕业生和访学博士离队后,Geatpy团队进行了全面重整,现团队由华南农业大学、暨南大学、华南理工大学等优秀硕士以及一批优秀校友、优秀本科生组成。团队始终秉持全心全意为人民服务的基本宗旨,旨在研发超高性能、通用性强、能够轻松应用到实际工程项目之中的、能让用户快速上手进化算法的工具箱。新版Geatpy对旧版进行了全面的重构,极大提升了内核的性能,同时提供一个通用性很强的面向对象的进化算法框架,希望借此能够带给广大用户一种良好的体验。

    简介

    Geatpy是一个高性能实用型进化算法工具箱,提供了许多已实现的进化算法各项操作的函数,如初始化种群、选择、交叉、变异、多目标优化参考点生成、非支配排序、多目标优化GD、IGD、HV等指标的计算等等。没有繁杂的深度封装,可以清晰地看到其基本结构及相关算法的实现,并利用Geatpy函数方便地进行自由组合,实现和研究多种改进的进化算法、多目标优化、并行进化算法等,解决传统优化算法难以解决的问题。

    Geatpy在Python上提供简便易用的面向对象的进化算法框架。通过继承问题类,可以轻松把实际问题与进化算法相结合。Geatpy还提供多种进化算法模板类,涵盖遗传算法、差分进化算法、进化策略、多目标进化优化算法等,可以通过调用算法模板,轻松解决单目标优化、多目标优化、组合优化、约束优化等问题。这些都是开源的,你可以参照这些模板,加以改进或重构,以便实现效果更好的进化算法,或是让进化算法更好地与当前正在进行的项目进行融合。

    特色

    1. Geatpy是一个功能强大的进化算法工具箱,并提供耦合度很低的进化算法框架。没有过于抽象的复杂封装,入门门槛低。
    2. 提供多种格式的编码方式以及丰富的选择、交叉和变异等算子。你可以在极短的时间里掌握Geatpy的用法,并把Geatpy融合到你正在进行的项目或实际问题的解决方案中。
    3. Geatpy的一大特色是提供众多自由、清晰的进化算法模板。在模板中,你可以清晰地看到算法的完整流程,更加掌握遗传算法的更多细节。通过修改进化算法模板,你可以轻松解决难以想象多的优化问题。可以将Geatpy用作研究进化算法的通用测试平台,实现各种改进的进化算法。
    4. 利用Numpy+mkl以及C内核实现高性能计算,使得Geatpy在算法执行效率上有着不俗的表现。在不失通用性的保证下在速度上比采用Java或是Matlab编写的或是采用C++内核及Python接口编写的进化算法工具箱、框架和平台快得多。
    5. 提供丰富的进化过程追踪分析功能,可以看到在进化过程中决策空间和目标空间的变化,以及进化过程中各项评价指标的变化,以帮助用户更好地研究进化算法。
    6. 支持轻松实现约束优化,可通过罚函数法或者利用可行性法则来完成对复杂约束条件(包括不等式约束和等式约束)的处理。
    7. 提供非常详尽的代码注释,是目前注释量最多的进化算法工具箱。让用户可以最快速度地上手进化算法、研究进化算法和应用进化算法。
    8. 支持多染色体混合编码的进化优化,使得Geatpy可以轻松应对各种复杂问题。
    9. 支持多种群进化优化,通过Geatpy灵活的数据结构,可以轻松利用多种群进行进化优化。
      参考1
      参考2
    展开全文
  • 遗传算法工具箱Geatpy求解TSP Geatpy简介 Geatpy是一个高性能实用型进化算法工具箱,提供许多已实现的进化算法中各项重要操作的库函数,并提供一个高度模块化、耦合度低的面向对象的进化算法框架,利用“定义问题类 ...
  • 上一篇讲了Geatpy的快速入门:...Geatpy提供面向对象的简单封装的开放式进化算法框架,可以方便、自由地与其他算法或项目相结合。Geatpy的文件结构如下图所示: 其中“...
  • 文章目录Geatpy种群初始化Example进化迭代相关的函数选择 ea.selecting()Example重组 recombin()突变 ea.mutate()数据可视化实验实例新建种群选择交叉变异整合数据重新计算适应度值绘图,保存写成了一个class参考...
  • 深度模型的超参数,由于模型计算量大,计算时间长,往往会采用运气调参,或者随机搜索调参来进行。今天打算记录一下使用Geatpy包对超参数进行进化算法的参数优化实现。 讓我們先看看文檔 ...
  • Python安装geatpy

    2021-09-23 13:38:35
    2.geatpy2.6版本的安装包,或者到geatpy官网也可找到 提醒:使用pip安装最高只能安装到2.4.0版本,而官网的教程只有2.5和2.6版本的 二、安装步骤 1.将安装包解压后放到pip安装包的路径下,一般在 盘符:\Python\Lib\...
  • 遗传算法| Python Geatpy

    千次阅读 多人点赞 2019-11-07 19:06:07
    1 Geatpy库的由来 由华南农业大学、暨南大学、华南理工大学等一批大佬们研发的超高性能、通用性强、能够轻松应用到实际工程项目之中的、能让用户快速上手进化算法的工具箱(遗传算法工具箱),详情见官网...
  • Geatpy数据结构

    2020-08-03 19:55:30
    采用Geatpy提供的面向对象的进化算法框架时,译码矩阵可以与一个存储着种群染色体编码方式的字符串Encoding配合使用。 三种Encoding: BG(二进制/格雷码) RI(实整数编码,即实数和整数的混合编码) p(排列编码,...
  • 声明:非官方解决方法,不一定正规哈 自定义初始值解决方法 以官方的第一个案例:https://github.com/geatpy-dev/geatpy/tree/master/geatpy/demo/soea_demo/soea_demo1 为例: 进入类MyProblem里 在函数def __init_...
  • Geatpy是一个高性能实用型的Python遗传算法工具箱,提供一个面向对象的进化算法框架,经过全面改版后,新版Geatpy2目前由华南农业大学、暨南大学、华南理工等本硕博学生联合团队开发及维护。 Website (including ...
  • 在前面几篇文章中,我们已经介绍了高性能Python遗传和进化算法框架——Geatpy的使用。 https://blog.csdn.net/qq_33353186/article/details/82014986 https://blog.csdn.net/qq_33353186/article/details/82020507...
  • Geatpy The Genetic and Evolutionary Algorithm Toolbox for Python Introduction Website (including documentation):http://www.geatpy.com Tutorial pdf:...
  • import geatpy as ea from sklearn import preprocessing from sklearn.model_selection import cross_val_score from multiprocessing.dummy import Pool as ThreadPool from sklearn import ...
  • 在前面几篇文章中,我们已经介绍了高性能Python遗传和进化算法框架——Geatpy的使用及一些案例。 https://blog.csdn.net/qq_33353186/article/details/82014986 ... ...
  • geatpy学习(长期更新)

    2021-02-02 21:48:22
    定义一个问题类,这段代码描述了一个优化问题: class MyProblem(ea.Problem): # 继承Problem父类 def __init__(self): name = 'MyProblem' # 初始化name(函数名称,可以随意设置) M = 1 # 初始化M(目标维数) ...
  • 园子里关于遗传算法的教案不少,但基于geatpy框架的并未多见,故分享此文以作参考,还望广大园友多多指教! Geatpy出自三所名校联合团队之手,是遗传算法领域的权威框架(python),其效率之高、应用领域之广远胜...
  • 使用案例: https://blog.csdn.net/weixin_42587745/article/details/82147482#comments geatpy官网: http://geatpy.com/
  • 上一篇讲了Geatpy的库函数和数据结构https://blog.csdn.net/qq_33353186/article/details/82020507 熟悉了之后,我尝试编写一个编程模板解决一个约束优化问题: 在...
  • geatpy简介:一个高性能Python遗传算法工具箱,提供了面向对象的进化算法框架。pip install geatpy即可安装。官网: geatpy.com 本文实现DE/rand/1, DE/best/1和DE/currentToBest/1三种变异策略的算法对比,以及上文...
  • [BestIndi, population] = myAlgorithm.run() 这是新版本的语句 而旧版有三个输出值。

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 303
精华内容 121
关键字:

geatpy