Python遗传和进化算法框架（三）自定义Geatpy编程模板解决约束优化问题

2019年3月19日 597次阅读 来源: 遗传算法

上一篇讲了Geatpy的库函数和数据结构https://blog.csdn.net/qq_33353186/article/details/82020507

熟悉了之后，我尝试编写一个编程模板解决一个约束优化问题：

《Python遗传和进化算法框架（三）自定义Geatpy编程模板解决约束优化问题》

在这个问题里，我们很容易知道目标函数的最小值为0，而这是个目标函数最大化问题，因此，我们可以对不符合约束条件的解的目标函数值设为0。而且不需要写罚函数了，直接把约束条件写在目标函数接口文件里即可。

编写目标函数接口文件：


 
 
    
  
  
  1.       """ aimfuc.py """  
    2. 
  
  
  2.        
    3. 
  
  
  3.       import numpy as np  
    4. 
  
  
  4.        
    5. 
  
  
  5.       # aim function  
    6. 
  
  
  6.       def aimfuc(variables):  
    7. 
  
  
  7.       x1 = variables[:, 0] # get x1  
    8. 
  
  
  8.       x2 = variables[:, 1] # get x2  
    9. 
  
  
  9.       f = 5 * x1 + 8 * x2  
    10. 
  
  
  10.       idx1 = np.where(x1 + x2 > 6)[ 0]  
    11. 
  
  
  11.       idx2 = np.where( 5 * x1 + 9 * x2 > 45)[ 0]  
    12. 
  
  
  12.       f[idx1] = 0  
    13. 
  
  
  13.       f[idx2] = 0  
    14. 
  
  
  14.       return np.array([f]).T # 对结果进行转置，使目标函数值矩阵符合Geatpy数据结构  
    15.

下面一步步来编写编程模板，以解决这个约束优化问题。

编写编程模板时一个要注意的地方是：调用目标函数时，传入的参数必须和目标函数的参数列表一致。

我们试一下一种改进的遗传算法，即不用遗传算法的经典流程，而是在进化过程中，先对父代进行交叉和变异产生子代，然后父代和子代直接合并成一个大的种群，再从这个大的种群中挑选50%的优秀个体存活下来。在下一次进化迭代中，这50%的个体继续沿用上面的流程进行交叉、变异、选择。算法流程如下：

《Python遗传和进化算法框架（三）自定义Geatpy编程模板解决约束优化问题》

这种改进遗传算法的好处是具有很强的精英保留能力。可以使算法快速收敛，得到最优结果。

为了使模板函数能够用于更多的场景，能同时解决整数型和实数型控制变量的问题。于是编写编程模板如下：


 
 
    
  
  
  1.       """ templet.py """  
    2. 
  
  
  2.        
    3. 
  
  
  3.       # -*- coding: utf-8 -*-  
    4. 
  
  
  4.       import numpy as np  
    5. 
  
  
  5.       import geatpy as ga  
    6. 
  
  
  6.       import time  
    7. 
  
  
  7.        
    8. 
  
  
  8.       """  
    9. 
  
  
  9.       输入参数：  
    10. 
  
  
  10.        AIM_M - 目标函数的地址，传入该函数前通常由AIM_M = __import__('目标函数名')语句得到  
    11. 
  
  
  11.          
    12. 
  
  
  12.        AIM_F : str - 目标函数名  
    13. 
  
  
  13.          
    14. 
  
  
  14.        PUN_M - 罚函数的地址，传入该函数前通常由PUN_M = __import__('罚函数名')语句得到  
    15. 
  
  
  15.          
    16. 
  
  
  16.        PUN_F : str - 罚函数名  
    17. 
  
  
  17.          
    18. 
  
  
  18.        FieldDR : array - 实际值种群区域描述器  
    19. 
  
  
  19.        [lb; (float) 指明每个变量使用的下界  
    20. 
  
  
  20.        ub] (float) 指明每个变量使用的上界  
    21. 
  
  
  21.        注：不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理  
    22. 
  
  
  22.        本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间  
    23. 
  
  
  23.          
    24. 
  
  
  24.        problem : str - 表明是整数问题还是实数问题，'I'表示是整数问题，'R'表示是实数问题   
    25. 
  
  
  25.          
    26. 
  
  
  26.        maxormin int - 最小最大化标记，1表示目标函数最小化；-1表示目标函数最大化  
    27. 
  
  
  27.          
    28. 
  
  
  28.        MAXGEN : int - 最大遗传代数  
    29. 
  
  
  29.          
    30. 
  
  
  30.        NIND : int - 种群规模，即种群中包含多少个个体  
    31. 
  
  
  31.          
    32. 
  
  
  32.        SUBPOP : int - 子种群数量，即对一个种群划分多少个子种群  
    33. 
  
  
  33.          
    34. 
  
  
  34.        GGAP : float - 代沟，本模板中该参数为无用参数，仅为了兼容同类的其他模板而设  
    35. 
  
  
  35.          
    36. 
  
  
  36.        selectStyle : str - 指代所采用的低级选择算子的名称，如'rws'(轮盘赌选择算子)  
    37. 
  
  
  37.          
    38. 
  
  
  38.        recombinStyle: str - 指代所采用的低级重组算子的名称，如'xovsp'(单点交叉)  
    39. 
  
  
  39.          
    40. 
  
  
  40.        recopt : float - 交叉概率  
    41. 
  
  
  41.          
    42. 
  
  
  42.        pm : float - 重组概率  
    43. 
  
  
  43.         
    44. 
  
  
  44.       输出参数：  
    45. 
  
  
  45.        pop_trace : array - 种群进化记录器(进化追踪器),  
    46. 
  
  
  46.        第0列记录着各代种群最优个体的目标函数值  
    47. 
  
  
  47.        第1列记录着各代种群的适应度均值  
    48. 
  
  
  48.        第2列记录着各代种群最优个体的适应度值  
    49. 
  
  
  49.          
    50. 
  
  
  50.        var_trace : array - 变量记录器，记录着各代种群最优个体的变量值，每一列对应一个控制变量  
    51. 
  
  
  51.          
    52. 
  
  
  52.        times : float - 进化所用时间  
    53. 
  
  
  53.       """  
    54. 
  
  
  54.        
    55. 
  
  
  55.       def templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm):  
    56. 
  
  
  56.       """==========================初始化配置==========================="""  
    57. 
  
  
  57.       GGAP = 0.5 # 因为父子合并后选择50%的个体留到下一代，因此要将代沟设为0.5以维持种群规模  
    58. 
  
  
  58.       # 获取目标函数和罚函数  
    59. 
  
  
  59.       aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数  
    60. 
  
  
  60.       if PUN_F is not None:  
    61. 
  
  
  61.       punishing = getattr(PUN_M, PUN_F) # 获得罚函数  
    62. 
  
  
  62.       NVAR = FieldDR.shape[ 1] # 得到控制变量的个数  
    63. 
  
  
  63.       # 定义进化记录器，初始值为nan  
    64. 
  
  
  64.       pop_trace = (np.zeros((MAXGEN , 2)) * np.nan)  
    65. 
  
  
  65.       # 定义变量记录器，记录控制变量值，初始值为nan  
    66. 
  
  
  66.       var_trace = (np.zeros((MAXGEN ,NVAR)) * np.nan)  
    67. 
  
  
  67.       """=========================开始遗传算法进化======================="""  
    68. 
  
  
  68.       if problem == 'R':  
    69. 
  
  
  69.       Chrom = ga.crtrp(NIND, FieldDR) # 生成初始种群  
    70. 
  
  
  70.       elif problem == 'I':  
    71. 
  
  
  71.       Chrom = ga.crtip(NIND, FieldDR)  
    72. 
  
  
  72.       start_time = time.time() # 开始计时  
    73. 
  
  
  73.       # 开始进化！！  
    74. 
  
  
  74.       for gen in range(MAXGEN):  
    75. 
  
  
  75.       # 进行遗传算子，生成子代  
    76. 
  
  
  76.       SelCh=ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组  
    77. 
  
  
  77.       if problem == 'R': # 若是实数型控制变量，则用mutbga进行变异  
    78. 
  
  
  78.       SelCh=ga.mutbga(SelCh,FieldDR, pm) # 变异  
    79. 
  
  
  79.       elif problem == 'I': # 若是整数型控制变量，则用mutint进行变异  
    80. 
  
  
  80.       SelCh=ga.mutint(SelCh, FieldDR, pm)  
    81. 
  
  
  81.       Chrom = np.vstack([Chrom, SelCh]) # 父子合并  
    82. 
  
  
  82.       ObjV = aimfuc(Chrom) # 求后代的目标函数值  
    83. 
  
  
  83.       pop_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[ 0] # 记录种群个体平均目标函数值  
    84. 
  
  
  84.       if maxormin == 1:  
    85. 
  
  
  85.       pop_trace[gen, 1] = np.min(ObjV) # 记录当代目标函数的最优值  
    86. 
  
  
  86.       var_trace[gen,:] = Chrom[np.argmin(ObjV), :] # 记录当代最优的控制变量值  
    87. 
  
  
  87.       elif maxormin == -1:  
    88. 
  
  
  88.       pop_trace[gen, 1] = np.max(ObjV)  
    89. 
  
  
  89.       var_trace[gen,:] = Chrom[np.argmax(ObjV), :] # 记录当代最优的控制变量值  
    90. 
  
  
  90.       # 最后对合并的种群进行适应度评价并选出一半个体留到下一代  
    91. 
  
  
  91.       FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP)  
    92. 
  
  
  92.       if PUN_F is not None:  
    93. 
  
  
  93.       FitnV = punishing(Chrom, FitnV) # 调用罚函数  
    94. 
  
  
  94.       Chrom=ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择  
    95. 
  
  
  95.       end_time = time.time() # 结束计时  
    96. 
  
  
  96.       # 绘图  
    97. 
  
  
  97.       ga.trcplot(pop_trace, [[ '种群个体平均目标函数值', '种群最优个体目标函数值']])  
    98. 
  
  
  98.       if maxormin == 1:  
    99. 
  
  
  99.       best_gen = np.argmin(pop_trace[:, 1]) # 记录最优种群是在哪一代  
    100. 
  
  
  100.       print( '最优的目标函数值为：'+ str(np.min(pop_trace[:, 1])))  
    101. 
  
  
  101.       elif maxormin == -1:  
    102. 
  
  
  102.       best_gen = np.argmax(pop_trace[:, 1]) # 记录最优种群是在哪一代  
    103. 
  
  
  103.       print( '最优的目标函数值为：' + str(np.max(pop_trace[:, 1])))  
    104. 
  
  
  104.       print( '最优的控制变量值为：')  
    105. 
  
  
  105.       for i in range(NVAR):  
    106. 
  
  
  106.       print(var_trace[best_gen, i])  
    107. 
  
  
  107.       print( '最优的一代是第' + str(best_gen + 1) + '代')  
    108. 
  
  
  108.       times = end_time - start_time  
    109. 
  
  
  109.       print( '时间已过'+ str(times) + '秒')  
    110. 
  
  
  110.       # 返回进化记录器、变量记录器以及执行时间  
    111. 
  
  
  111.       return [pop_trace, var_trace, times]  
    112.

好了，现在该编程模板可以用于解决这类约束优化问题了。控制变量既可以是整数，也可以是实数。

下面编写执行脚本：


 
 
    
  
  
  1.       import numpy as np  
    2. 
  
  
  2.       import geatpy as ga  
    3. 
  
  
  3.       from aimfuc import aimfuc  
    4. 
  
  
  4.       from templet import templet # 导入自定义的编程模板  
    5. 
  
  
  5.        
    6. 
  
  
  6.       # 获取函数接口地址  
    7. 
  
  
  7.       AIM_M = __import__( 'aimfuc')  
    8. 
  
  
  8.       # 变量设置  
    9. 
  
  
  9.       x1 = [ 0, 100] # 自变量1的范围  
    10. 
  
  
  10.       x2 = [ 0, 100] # 自变量2的范围  
    11. 
  
  
  11.       b1 = [ 1, 1] # 自变量1是否包含下界  
    12. 
  
  
  12.       b2 = [ 1, 1] # 自变量2是否包含上界  
    13. 
  
  
  13.       ranges=np.vstack([x1, x2]).T # 生成自变量的范围矩阵  
    14. 
  
  
  14.       borders = np.vstack([b1, b2]).T # 生成自变量的边界矩阵  
    15. 
  
  
  15.       # 生成区域描述器  
    16. 
  
  
  16.       FieldDR = ga.crtfld(ranges, borders)  
    17. 
  
  
  17.       # 调用编程模板  
    18. 
  
  
  18.       [pop_trace, var_trace, times] = templet(AIM_M, 'aimfuc', None, None, FieldDR, problem = 'I', maxormin = -1, MAXGEN = 2000, NIND = 100, SUBPOP = 1, GGAP = 0.9, selectStyle = 'tour', recombinStyle = 'xovdp', recopt = 0.7, pm = 0.1)  
    19.

因为这道题的控制变量x1和x2的区间都是单侧的，因此我们设个大一点的区间以便搜索最优解。我们采用锦标赛选择算子，并设置最大进化代数为100，种群规模为100，使用两点交叉，交叉和变异概率分别是0.9和0.1。

运行结果如下：

《Python遗传和进化算法框架（三）自定义Geatpy编程模板解决约束优化问题》

最优的目标函数值为：39.0
最优的控制变量值为：
3.0
3.0
最优的一代是第40代
时间已过0.11623454093933105秒

至此，我们知道了如何自定义编程模板实现遗传算法了。在Geatpy中，内置了好几种进化算法编程模板。详细源码可以参见https://github.com/geatpy-dev/geatpy/tree/master/geatpy/source-code/templets

使用Geatpy内置模板会使上面的例子变得更加简单，只需编写目标函数接口和执行脚本就可以了。比如上面的例子，使用Geatpy框架，真正只需几行代码便可以解决：


 
 
    
  
  
  1.       """ main.py """  
    2. 
  
  
  2.        
    3. 
  
  
  3.       import numpy as np  
    4. 
  
  
  4.       import geatpy as ga  
    5. 
  
  
  5.        
    6. 
  
  
  6.       # define aim function  
    7. 
  
  
  7.       def aimfuc(variables):  
    8. 
  
  
  8.       x1 = variables[:, 0] # get x1  
    9. 
  
  
  9.       x2 = variables[:, 1] # get x2  
    10. 
  
  
  10.       f = 5 * x1 + 8 * x2  
    11. 
  
  
  11.       idx1 = np.where(x1 + x2 > 6)[ 0]  
    12. 
  
  
  12.       idx2 = np.where( 5 * x1 + 9 * x2 > 45)[ 0]  
    13. 
  
  
  13.       f[idx1] = 0; f[idx2] = 0  
    14. 
  
  
  14.       return np.array([f]).T # 对结果进行转置，使目标函数值矩阵符合Geatpy数据结构  
    15. 
  
  
  15.        
    16. 
  
  
  16.       # 获取目标函数地址  
    17. 
  
  
  17.       AIM_M = __import__( 'main')  
    18. 
  
  
  18.       # 变量设置  
    19. 
  
  
  19.       x1 = [ 0, 100] # 自变量1的范围  
    20. 
  
  
  20.       x2 = [ 0, 100] # 自变量2的范围  
    21. 
  
  
  21.       b1 = [ 1, 1] # 自变量1是否包含下界  
    22. 
  
  
  22.       b2 = [ 1, 1] # 自变量2是否包含上界  
    23. 
  
  
  23.       ranges = np.vstack([x1, x2]).T # 生成自变量的范围矩阵  
    24. 
  
  
  24.       borders = np.vstack([b1, b2]).T # 生成自变量的边界矩阵  
    25. 
  
  
  25.       FieldDR = ga.crtfld(ranges, borders) # 生成区域描述器  
    26. 
  
  
  26.       # 调用Geatpy内置编程模板  
    27. 
  
  
  27.       [pop_trace, var_trace, times] = ga.sga_new_real_templet(AIM_M, 'aimfuc', None, None, FieldDR, problem = 'I', maxormin = -1, MAXGEN = 100, NIND = 100, SUBPOP = 1, GGAP = 0.9, selectStyle = 'tour', recombinStyle = 'xovdp', recopt = 0.7, pm = 0.1)  
    28.

在后面的版本中，Geatpy将不断丰富和改进编程模板，以Geatpy的算法性能。比如添加MOEA/D多目标优化编程模板等。有相关想法的也可以email：jazzbin@geatpy.com。

更多教程可以参见官网http://www.geatpy.com (repairing)，以及参见Geatpy的源码和demo示例：https://github.com/geatpy-dev/geatpy/tree/master/geatpy/demo 你将有更多的收获。

在下一篇，我们将讲述如何使用Geatpy解决一些实际的有趣问题。

https://blog.csdn.net/qq_33353186/article/details/82047692 欢迎继续跟进，谢谢大家！

    原文作者：遗传算法
    原文地址: https://blog.csdn.net/daihao1413/article/details/82110719
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞