python 遗传算法智能排课 python的遗传算法

转载

mob64ca14092155 2024-08-14 18:16:37

文章标签 python 遗传算法智能排课 python matlab c/c++ 遗传算法 文章分类 Python 后端开发

前言

最近需要用到遗传算法来优化一些东西，最初是打算直接基于某些算法实现一个简单的函数来优化，但是感觉单纯写个非通用的函数运行后期改进算子或者别人使用起来都会带来困难，同时遗传算法基本概念和运行流程相对固定，改进也一般通过编码机制，选择策略，交叉变异算子以及参数设计等方面，对于算法的整体结构并没有大的影响。这样对于遗传算法来说，就非常适合写个相对固定的框架然后给算子、参数等留出空间以便对新算法进行测试和改进。于是就动手写了个遗传算法的小框架gaft，本文对此框架进行一些介绍并分别以一个一维搜索和二维搜索为例子对使用方法进行了介绍。

GitHub: https://github.com/PytLab/gaft
PyPI: https://pypi.python.org/pypi/gaft

目前框架只是完成了最初的版本，比较简陋，内置了几个基本的常用算子，使用者可以根据接口规则实现自定义的算子并放入框架中运行。我自己也会根据自己的需求后续添加更多的改进算子，同时改进框架使其更加通用.

正文

遗传算法介绍

这里我对遗传算法的基本概念进行简要的介绍，并阐述gaft的设计原则。

简单而言，遗传算法使用群体搜索技术，将种群代表一组问题的可行解，通过对当前种群施加选择，交叉，变异等一些列遗传操作来产生新一代的种群，并逐步是种群进化到包含近似全局最优解的状态。下面我将遗传学和遗传算法相关术语的对应关系总结一下:

术语

算法特点

以决策变量的编码作为运算对象，使得优化过程借鉴生物学中的概念成为可能
直接以目标函数作为搜索信息，确定搜索方向很范围，属于无导数优化
同时使用多个搜索点的搜索信息，算是一种隐含的并行性
是一种基于概率的搜索技术
具有自组织，自适应和自学习等特性

算法流程

gaft 设计原则

由于遗传算法的流程相对固定，我们优化算法基本上也是在流程整体框架下对编码机制，算子，参数等进行修改，因此在写框架的时候，我便想把那些固定的遗传算子，适应度函数写成接口，并使用元类、装饰器等方式实现对接口的限制和优化，这样便可以方便后续自定义算符和适应度函数定制。最后将各个部分组合到一起组成一个engine然后根据算法流程运行遗传算法对目标进行优化.

这样我们便脱离每次都要写遗传算法流程的繁琐，每次只需要像写插件一样实现自己的算子和适应度函数便可以将其放入gaft开始对算法进行测试或者对目标函数进行优化了。

GAFT文件结构

此部分我对自己实现的框架的整体结构进行下介绍.

1. . 
2.  
3. ├── LICENSE 
4.  
5. ├── MANIFEST.in
6.  
7. ├── README.rst 
8.  
9. ├── examples 
10.  
11. │ ├── ex01 
12.  
13. │ └── ex02 
14.  
15. ├── gaft 
16.  
17. │ ├── __init__.py 
18.  
19. │ ├── __pycache__ 
20.  
21. │ ├── analysis 
22.  
23. │ ├── components 
24.  
25. │ ├── engine.py 
26.  
27. │ ├── operators 
28.  
29. │ └── plugin_interfaces 
30.  
31. ├── setup.cfg 
32.  
33. ├── setup.py 
34.  
35. └── tests 
36.  
37. ├── flip_bit_mutation_test.py 
38.  
39. ├── gaft_test.py 
40.  
41. ├── individual_test.py 
42.  
43. ├── population_test.py 
44.  
45. ├── roulette_wheel_selection_test.py 
46.  
47. └── uniform_crossover_test.py

目前的文件结果如上所示，

/gaft/components中定义了内置的个体和种群类型，提供了两种不同的遗传编码方式:二进制编码和实数编码。
/gaft/plugin_interfaces中是插件接口定义，所有的算子定义以及on-the-fly分析的接口规则都在里面，使用者可以根据此来编写自己的插件并放入到engine中。
/gaft/operators里面是内置遗传算子，他们也是遵循/gaft/plugin_interfaces中的规则进行编写，可以作为编写算子的例子。其中算子我目前内置了roulette wheel选择算子，uniform 交叉算子和flipbit变异算子，使用者可以直接使用内置算子来使用gaft对自己的问题进行优化。
/gaft/analysis里面是内置的on-the-fly分析插件，他可以在遗传算法迭代的过程中对迭代过程中的变量进行分析，例如我在里面内置了控制台日志信息输出，以及迭代适应度值的保存等插件方便对进化曲线作图。
/gaft/engine便是遗传算法的流程控制模块了，他将所有的之前定义的各个部分组合到一起使用遗传算法流程进行优化迭代。

使用GAFT

下面我就以两个函数作为例子来使用GAFT对目标函数进行优化.

一维搜索

首先我们先对一个简单的具有多个局部极值的函数进行优化，我们来使用内置的算子求函数 f(x)=x+10sin(5x)+7cos(4x)的极大值，x的取值范围为[0,10]

1. 先导入需要的模块

1. from
2.  
3.   
4.  
5. # 导入种群和内置算子相关类 
6.  
7. from
8.  
9. from
10.  
11. from
12.  
13. from
14.  
15. from
16.  
17. from
18.  
19.   
20.  
21. # 用于编写分析插件的接口类 
22.  
23. from
24.  
25.   
26.  
27. # 内置的存档适应度函数的分析类 
28.  
29. from
30.  
31.   
32.  
33. # 我们将用两种方式将分析插件注册到遗传算法引擎中

2. 创建引擎

1. # 定义种群 
2.  
3. indv_template = GAIndividual(ranges=[(0, 10)], encoding='binary', eps=0.001) 
4.  
5. population = GAPopulation(indv_template=indv_template, size=50) 
6.  
7.   
8.  
9. # 创建遗传算子 
10.  
11. selection = RouletteWheelSelection() 
12.  
13. crossover = UniformCrossover(pc=0.8, pe=0.5) 
14.  
15. mutation = FlipBitMutation(pm=0.1) 
16.  
17.   
18.  
19. # 创建遗传算法引擎, 分析插件和适应度函数可以以参数的形式传入引擎中 
20.  
21. engine = GAEngine(population=population, selection=selection, 
22.  
23.                   crossover=crossover, mutation=mutation, 
24.  
25.                   analysis=[FitnessStoreAnalysis])  
3. 自定义适应度函数
可以通过修饰符的方式将，适应度函数注册到引擎中。
 
  
 
1. @engine.fitness_register 
2.  
3. def fitness(indv): 
4.  
5.     x, = indv.variants 
6.  
7. return
4. 自定义on-the-fly分析插件
也可以通过修饰符在定义的时候直接将插件注册到引擎中
 
  
 
1. @engine.analysis_register 
2.  
3. class ConsoleOutputAnalysis(OnTheFlyAnalysis): 
4.  
5.     interval = 1 
6.  
7.   
8.  
9.     def register_step(self, ng, population, engine): 
10.  
11.         best_indv = population.best_indv(engine.fitness) 
12.  
13. 'Generation: {}, best fitness: {:.3f}'.format(ng, engine.fitness(best_indv)) 
14.  
15.         engine.logger.info(msg) 
16.  
17.   
18.  
19.     def finalize(self, population, engine): 
20.  
21.         best_indv = population.best_indv(engine.fitness) 
22.  
23.         x = best_indv.variants 
24.  
25.         y = engine.fitness(best_indv) 
26.  
27. 'Optimal solution: ({}, {})'.format(x, y) 
28.  
29.         engine.logger.info(msg)  
5. Ok, 开始跑(优化)吧!

我们这里跑100代种群.

if '__main__'
# Run the GA engine.
engine.run(ng=100)

内置的分析插件会在每步迭代中记录得到的每一代的最优个体，并生成数据保存。

绘制一下函数本身的曲线和我们使用遗传算法得到的进化曲线:

优化过程动画:

二维搜索

下面我们使用GAFT内置算子来搜索同样具有多个极值点的二元函数f(x)=ysin(2πx)+xcos(2πy) 的最大值，x, y 的范围为 [−2,2] .

这里我们就不自定义分析插件了，直接使用内置的分析类，并在构造引擎时直接传入.

1. ''' 
2.  
3. Find the global maximum for binary function: f(x) = y*sim(2*pi*x) + x*cos(2*pi*y) 
4.  
5. ''' 
6.  
7.   
8.  
9. from
10.  
11.   
12.  
13. from
14.  
15. from
16.  
17. from
18.  
19. from
20.  
21. from
22.  
23. from
24.  
25.   
26.  
27. # Built-in
28.  
29. from
30.  
31. from
32.  
33.   
34.  
35. # Define population. 
36.  
37. indv_template = GAIndividual(ranges=[(-2, 2), (-2, 2)], encoding='binary', eps=0.001) 
38.  
39. population = GAPopulation(indv_template=indv_template, size=50) 
40.  
41.   
42.  
43. # Create
44.  
45. selection = RouletteWheelSelection() 
46.  
47. crossover = UniformCrossover(pc=0.8, pe=0.5) 
48.  
49. mutation = FlipBitMutation(pm=0.1) 
50.  
51.   
52.  
53. # Create
54.  
55. # Here we pass all built-in analysis to
56.  
57. engine = GAEngine(population=population, selection=selection, 
58.  
59.                   crossover=crossover, mutation=mutation, 
60.  
61.                   analysis=[ConsoleOutputAnalysis, FitnessStoreAnalysis]) 
62.  
63.   
64.  
65. # Define fitness function. 
66.  
67. @engine.fitness_register 
68.  
69. def fitness(indv): 
70.  
71.     x, y = indv.variants 
72.  
73. return
74.  
75.   
76.  
77. if '__main__'
78.  
79.     engine.run(ng=100)  
进化曲线: