退而求其次(3)——宿管员的烦恼

　　书接上文，在《退而求其次(1)——随机法》中宿管员使用了随机法分配宿舍，现在尝试使用遗传算法。

顺序编码和初始种群

　　遗传算法的首要问题是基因编码。对于分宿舍问题，每种分配方案是一个个体，其基因序列的每一个编码代表一个同学，要求处于同一基因序列中的所有基因代码均不能重复，也就是每个同学都是独一无二的。在这种规则下，使用二进制编码就显得笨拙了。一种简单的编码方案是直接使用同学的序号作为基因编码，这种编码称为顺序码。

　　顺序码又称自然数编码，使用从1到n 的自然数进行编码，且不允许重复。例如[1,2,3,4,5,6,7,8,9,10,11,12]是一个合法的个体，表示按编码从左到右的顺序四人一个宿舍，而[1,1,3,3,6,6,8,8,9,10,11,12]则不是。

　　随机选择1000个个体作为初始种群，约占解空间的20%：

1 POPULATION_SIZE = 1000 # 种群数量
2
3 def init_population():
4     ''' 构造初始种群 '''
5     population = []
6     code_len = len(base_data.STUDENTS_NAME)  # 编码长度
7     for i in range(POPULATION_SIZE):
8         population.append(base_data.upset())
9     return population

适应度评估和种群选择

　　可以利用成本函数cost_fun来进行适应度评估。由于cost_fun识别的是解而不是基因编码，因此在使用cost_fun之前还需要通过solution_adapter将基因编码适配成解，将基因编码[1,2,3,4,5,6,7,8,9,10,11,12]翻译成cost_fun能够有效计算的[[1,2,3,4],[5,6,7,8],[9,10,11,12]]。

 1 def solution_adapter(code):
 2     ''' 将基因编码翻适配成cost_fun能够识别的解 '''
 3     solution = []
 4     for i in range(0, len(base_data.STUDENTS_NAME), base_data.NUM_PER_DROM):
 5         solution.append(code[i:i + base_data.NUM_PER_DROM])
 6     return solution
 7
 8 def fitness_fun(code):
 9     '''
10     适应度评估
11     :param code:   二进制基因编码
12     :return: 适应度评估值, 二元组, (宿舍总成本, 每个宿舍的成本)
13     '''
14     return base_data.cost_fun(solution_adapter(code))

　　我们依然使用锦标赛法选择种群。由于成本越低表示适应度越越高，因此在锦标赛中适应度值低的是胜出者。

1 def selection(population):
2     '''选择策略, 锦标赛法'''
3     pop_next = []  # 下一代种群
4     for i in range(POPULATION_SIZE):
5         tour_list = random.choices(population, k=2) # 二元锦标赛
6         winner = min(tour_list, key=lambda x: fitness_fun(x)) # 成本低的胜出
7         pop_next.append(winner)
8     return pop_next

部分匹配交叉和循环交叉

　　对于宿舍编码来说，单点交叉和两点交叉都无法产生合法的个体，下图展示了一个不合法的单点交叉。

　　在交叉后的个体 r1' 中，基因代码6和8出现了两次，表示6号同学和8号同学同时住在两个宿舍，这显然不是一个合法的解。反过来，如果交叉后得到了合法的个体，那么新个体又会和它们的父代没有任何区别，即没有产生任何新个体：

　　r1和 r1' 没有任何区别，最后一个宿舍的四个同学仅仅是交换了一下床位。看来必须另辟他径，寻找其它的交叉策略。

部分匹配交叉

　　部分匹配交叉（Partially Matched Crossover，PMC）在1985年被提出，是由两点交叉改进而来的。部分匹配交叉的第一步和两点交叉一样，首先在个体基因序列中随机设置两个交叉点，然后随机选择两个个体做为父代个体，相互交换它们交叉点之间的那部分基因块

　　在交叉时需要记住交叉前的基因块r1→[5,6,7,8]，r2→[9,11,2,4] 。

　　接下来对交叉后生成的新个体 r1' 和 r2' 中的×部分，分别继承r1和 r2 中对应位置的编码，如果待继承的编码在交换后的基因块中，则不做继承：

　　最后，把交叉前记住的基因块按顺序依次填入×部分，得到最终的r1'和 r2' ：

　　如果交叉前的编码已经在 r1' 中，则略过该编码。下图在替换x时需要略过2和6：

　　r1 是初始个体，它的基因块[2,4,6,9]与另一个个体的对应基因块[2,6,7,8]交叉，得到[×,×,×,×.2,6,7,8,×,×,×,×]。继承 r1 后得到 r1' = [1,3,5,×,2,6,7,8,×,10,11,12]。在[2,4,6,9]中，编码2和6已经在 r1' 中，因此只有4和9可以替换对应的×。

　　部分匹配交叉的编码如下。

 1 def crossover_pmc(population):
 2     ''' 部分匹配交叉（PMC）'''
 3
 4     def create_mapping(cross_code_1, cross_code_2):
 5         '''
 6         建立两个交叉片段间的映射关系
 7         :param cross_code_1:
 8         :param cross_code_2:
 9         :return:  映射关系set
10         '''
11         mapping = set()
12         for i in range(len(cross_code_1)):
13             c1, c2 = cross_code_1[i], cross_code_2[i]
14             if (c1, c2) not in mapping and  (c2, c1) not in mapping:
15                 mapping.add((c1, c2))
16         return mapping
17
18     def code_extends(child, parent, start, end):
19         '''
20         继承父代的编码
21         :param child: 子代个体
22         :param parent: 父代个体
23         :param start: 基因编码起始位置
24         :param end: 基因编码终止位置
25         '''
26         for i in range(start, end):
27            if parent[i] not in child:
28                child[i] = parent[i]
29
30     def code_rest(child, cross_code):
31         '''
32         通交叉前的基因片段修改子代的编码
33         :param child: 子代个体
34         :param cross_code: 交叉前的的基因片段
35         :return:
36         '''
37         for i, x in enumerate(child):
38             if x != -1:
39                 continue
40             for x_old in cross_code:
41                 if x_old not in child:
42                     child[i] = x_old
43                     break
44
45     pop_new = []  # 新种群
46     code_len = len(population[0])  # 基因编码的长度
47     for i in range(POPULATION_SIZE):
48         # 选择两个随机的交叉点
49         p1, p2 = random.randint(0, code_len - 1), random.randint(0, code_len - 1)
50         if p1 > p2:
51             p1, p2 = p2, p1
52         parent1, parent2 = random.choices(population, k=2)  # 选择两个随机的个体
53         cross_code_1 = parent1[p1:p2] # 交叉前的编码块
54         cross_code_2 = parent2[p1:p2] # 交叉后的编码块
55         # 构造新的个体，-1表示基因编码尚未确定
56         r = [-1] * p1 + cross_code_2 + [-1] * (code_len - p2)
57         code_extends(r, parent1, 0, p1) #  继承父代的编码
58         code_extends(r, parent1, p2, code_len) #  继承父代的编码
59         mapping = create_mapping(cross_code_1, cross_code_2) # 两个交叉块的映射关系
60         code_rest(r, cross_code_1)  # 通过交换前的基因片段确定剩余编码
61         pop_new.append(r)
62     return pop_new

循环交叉

　　循环交叉（Cycle Crossover，CX）是另一种适合顺序编码的交叉策略。不同于其它交叉策略，循环交叉不需事先要选择交叉点。

　　假设有两个父代个体

　　先从 r1 中选择第0个编码，作为子代 r1' 的第一个编码：

　　r2 的第0个编码是2，因此 r1' 中第2个被确定的编码是2：

　　2在 r1 中的序号是1， r2[1]=3, r1' 中第3个确定的编码是3：

　　3在 r1 中的序号是2， r2[2]=5， r1' 中第4个确定的编码是5：

　　5在 r1 中的序号是3， r2[3]=1 ， 和 r1' 中第1个编码相同，至此称为一个循环。剩余未确定的编码从 r2 的对应位置映射即可

　　循环交叉匹配的代码如下：

 1 def crossover_cx(population):
 2     ''' 循环交叉匹配 '''
 3     pop_new = []  # 新种群
 4     code_len = len(population[0])  # 基因编码的长度
 5     for i in range(POPULATION_SIZE):
 6         parent1, parent2 = random.choices(population, k=2)  # 选择两个随机的个体
 7         r_new = [-1] * code_len  # 新个体
 8         r_new[0] = parent1[0]
 9         i = 0
10         while True:  # 循环交叉
11             x = parent2[i]
12             if r_new[0] == x:
13                 break
14             i = parent1.index(x)
15             r_new[i] = x
16         # r_new中剩余未确定的编码直接从parent2中继承
17         for i, x in enumerate(r_new):
18             if x == -1:
19                 r_new[i] = parent2[i]
20         pop_new.append(r_new)
21     return pop_new

变异

　　顺序编码的变异策略很简单，仅仅是将两个随机变异点的编码互相交换：

 1 def mutation(population):
 2     ''' 变异 '''
 3     code_len = len(population[0])  # 基因编码的长度
 4     mp = 0.2  # 变异率
 5     for i, r in enumerate(population):
 6         if random.random() < mp:
 7             # 两个随机变异点
 8             p1, p2 = random.randint(0, code_len - 1), random.randint(0, code_len - 1)
 9             # 交换两个变异点的数据
10             population[p1], population[p2] = population[p2], population[p1]

分配宿舍

　　准备工作已经就绪，可以开始使用遗传算法分配宿舍：

 1 def sum_fitness(population):
 2     ''' 计算种群的总适应度 '''
 3     return sum([fitness_fun(code)[0] for code in population])
 4
 5 def ga():
 6     ''' 遗传算法分配宿舍 '''
 7     population = init_population() # 构建初始化种群
 8     s_fitness = sum_fitness(population) # 种群的总适应度
 9     i = 0
10     while i < 10: # 如果连续10代没有改进，结束算法
11         pop_next = selection(population) # 选择种群
12         pop_new = crossover_cx(pop_next) # 交叉
13         mutation(pop_new) # 变异
14         s_fitness_new = sum_fitness(pop_new) # 新种群的总适应度
15         if s_fitness > s_fitness_new: # 成本越低，适应度越高
16             s_fitness = s_fitness_new
17             i = 0
18         else:
19             i += 1
20         population = pop_new
21     # 按适应度值从大到小排序
22     population = sorted(population, key=lambda x: fitness_fun(x), reverse=True)
23     # 返回最优的个体
24     return population[0]
25
26 if __name__ == '__main__':
27     best = ga()
28     solution = solution_adapter(best)
29     total_cost, dorms_cost = base_data.cost_fun(solution)
30     base_data.print_solution(solution, total_cost, dorms_cost)

　　需要注意的是第15行的适应度比较，由于这里使用的是成本函数，因此种群的成本值越低，适应度越高，越应该被保留。一种可能的运行结果：

　　可以看到，在总成本较低的同时，“不均”的问题也得到了解决。

总体代码

　　base_data.py:

  1 import random
  2
  3 # 学生调查表数据
  4 STUDENTS = [
  5     [32, 1, 2, 2, [11, 33, 42], 5],
  6     [32, 1, 2, 1, [11], 5],
  7     [41, 1, 2, 5, [21, 22], 4],
  8     [43, 2, 3, 3, [11, 21], 3],
  9     [36, 2, 3, 4, [11, 33], 3],
 10     [44, 2, 3, 4, [41, 42], 2],
 11     [42, 1, 2, 1, [11, 12], 1],
 12     [32, 1, 1, 2, [31, 32], 2],
 13     [61, 1, 1, 3, [51], 3],
 14     [61, 1, 1, 2, [13], 3],
 15     [44, 3, 4, 1, [21, 43], 1],
 16     [22, 3, 4, 4, [22, 43], 2]
 17 ]
 18 # 学生姓名
 19 STUDENTS_NAME = ['蕾娜', '琪琳', '蔷薇', '炙心',
 20                  '灵犀', '莫伊', '怜风', '语琴',
 21                  '凉冰', '鹤熙', '瑞萌萌', '何蔚蓝']
 22 DROM_SIZE = 3  # 宿舍数量
 23 NUM_PER_DROM = 4 # 每个宿舍的人数
 24 MAX_COST = 5 # 同一维度间的最大差异
 25
 26 def cost_stu(stu_1, stu_2):
 27     ''' 以stu_1为主，计算stu_1与stu_2的差异 '''
 28     cost = [] # 各维度的成本值（差异度）
 29     cost.append(cost_equal(stu_1[0], stu_2[0])) # 籍贯成本
 30     cost.append(cost_equal(stu_1[1], stu_2[1])) # 专业成本
 31     cost.append(cost_class(stu_1[2], stu_2[2], stu_1[1], stu_2[1])) # 班级成本
 32     cost.append(cost_get_up(stu_1[3], stu_2[3])) # 起床成本
 33     cost.append(cost_interest(stu_1[4], stu_2[4])) # 爱好成本
 34     w_idx_1, w_idx_2 = stu_1[len(stu_1) - 1] - 1, stu_2[len(stu_2) - 1] - 1 # 权重序号
 35     w_cost_1, w_cost_2 = cost[w_idx_1] * 1.5,  cost[w_idx_2] * 1.5  # 加权处理
 36     # 判断二者最在意的是否相同
 37     if w_idx_1 == w_idx_1:
 38         cost[w_idx_1] = w_cost_1 + w_cost_2
 39     else:
 40         cost[w_idx_1], cost[w_idx_2] = w_cost_1, w_cost_2
 41
 42     return sum(cost)
 43
 44 def cost_equal(d_1, d_2):
 45     ''' 同质化比较成本  '''
 46     return 0 if d_1 == d_2 else MAX_COST
 47
 48 def cost_class(d_1, d_2, sub_1, sub_2):
 49     ''' 班级成本 '''
 50     if d_1 == d_1: # 班级相同
 51         return 0
 52     elif sub_1 == sub_1: # 不同班级，同一专业
 53         return 1
 54     else: # 不同班级，不同专业
 55         return MAX_COST
 56
 57 def cost_get_up(d_1, d_2):
 58     ''' 起床成本 '''
 59     return 1.2 * (d_2 - d_1)
 60
 61 def cost_interest(d_1, d_2):
 62     ''' 爱好成本 '''
 63     for t_1 in d_1:
 64         # 如果两个同学都有一个共同的爱好，二者就是零距离
 65         if t_1 in d_2:
 66             return 0
 67
 68         obj_1 = t_1 // 10 # 爱好的“大类”
 69         # 如果两个同学都有一个共同的大类，二者距离是2
 70         for t_2 in d_2:
 71             if obj_1 == t_2 // 10:
 72                 return 2
 73     return MAX_COST
 74
 75 def cost_fun(solution):
 76     '''
 77     计算方案中每个宿舍的成本
 78     :param solution: 宿舍分配方案
 79     :return: 宿舍总成本和每个宿舍的成本
 80     '''
 81     droms_cost = []
 82     for drom in solution:
 83         # 同一宿舍中的四个同学两两比对
 84         d_cost = 0
 85         d_cost += cost_stu(STUDENTS[drom[0]], STUDENTS[drom[1]])
 86         d_cost += cost_stu(STUDENTS[drom[0]], STUDENTS[drom[2]])
 87         d_cost += cost_stu(STUDENTS[drom[0]], STUDENTS[drom[3]])
 88         d_cost += cost_stu(STUDENTS[drom[1]], STUDENTS[drom[2]])
 89         d_cost += cost_stu(STUDENTS[drom[1]], STUDENTS[drom[3]])
 90         d_cost += cost_stu(STUDENTS[drom[2]], STUDENTS[drom[3]])
 91         droms_cost.append(d_cost)
 92     diff_cost = max(droms_cost) - min(droms_cost) # 宿舍之间的贫富差
 93     total_cost = sum(droms_cost) + diff_cost * DROM_SIZE # 该方案的总成本
 94     return total_cost, droms_cost
 95
 96 def upset():
 97     ''' 打乱学生顺序 '''
 98     n = len(STUDENTS_NAME)
 99     stu_list = list(range(n))
100     # 打乱学生顺序
101     for i in range(n):
102         rand_idx = random.randint(0, n - 1)
103         stu_list[i], stu_list[rand_idx] = stu_list[rand_idx], stu_list[i]
104     return stu_list
105
106 def print_solution(solution, total_cost, dorms_cost):
107     for i, drom in enumerate(solution):
108         print('宿舍%d:\t' % i, end='')
109         for j in drom:
110             print('%-8s' % STUDENTS_NAME[j], end='')
111         print('\tcost=%f' % dorms_cost[i])
112     print('total=%f' % total_cost)

genetic_optimize.py

  1 from __future__ import division
  2 import random
  3 import os
  4 import sys
  5 parent_dir_name = os.path.dirname(os.path.realpath(__file__))
  6 sys.path.append(parent_dir_name )
  7 import base_data
  8
  9 POPULATION_SIZE = 1000 # 种群数量
 10
 11 def init_population():
 12     ''' 构造初始种群 '''
 13     population = []
 14     code_len = len(base_data.STUDENTS_NAME)  # 编码长度
 15     for i in range(POPULATION_SIZE):
 16         population.append(base_data.upset())
 17     return population
 18
 19 def solution_adapter(code):
 20     ''' 将基因编码翻适配成cost_fun能够识别的解 '''
 21     solution = []
 22     for i in range(0, len(base_data.STUDENTS_NAME), base_data.NUM_PER_DROM):
 23         solution.append(code[i:i + base_data.NUM_PER_DROM])
 24     return solution
 25
 26 def fitness_fun(code):
 27     '''
 28     适应度评估
 29     :param code:   二进制基因编码
 30     :return: 适应度评估值, 二元组, (宿舍总成本, 每个宿舍的成本)
 31     '''
 32     return base_data.cost_fun(solution_adapter(code))
 33
 34 def selection(population):
 35     '''选择策略, 锦标赛法'''
 36     pop_next = []  # 下一代种群
 37     for i in range(POPULATION_SIZE):
 38         tour_list = random.choices(population, k=2) # 二元锦标赛
 39         winner = min(tour_list, key=lambda x: fitness_fun(x)) # 成本低的胜出
 40         pop_next.append(winner)
 41     return pop_next
 42
 43 def crossover_pmc(population):
 44     ''' 部分匹配交叉（PMC）'''
 45
 46     def create_mapping(cross_code_1, cross_code_2):
 47         '''
 48         建立两个交叉片段间的映射关系
 49         :param cross_code_1:
 50         :param cross_code_2:
 51         :return:  映射关系set
 52         '''
 53         mapping = set()
 54         for i in range(len(cross_code_1)):
 55             c1, c2 = cross_code_1[i], cross_code_2[i]
 56             if (c1, c2) not in mapping and  (c2, c1) not in mapping:
 57                 mapping.add((c1, c2))
 58         return mapping
 59
 60     def code_extends(child, parent, start, end):
 61         '''
 62         继承父代的编码
 63         :param child: 子代个体
 64         :param parent: 父代个体
 65         :param start: 基因编码起始位置
 66         :param end: 基因编码终止位置
 67         '''
 68         for i in range(start, end):
 69            if parent[i] not in child:
 70                child[i] = parent[i]
 71
 72     def code_rest(child, cross_code):
 73         '''
 74         通交叉前的基因片段修改子代的编码
 75         :param child: 子代个体
 76         :param cross_code: 交叉前的的基因片段
 77         :return:
 78         '''
 79         for i, x in enumerate(child):
 80             if x != -1:
 81                 continue
 82             for x_old in cross_code:
 83                 if x_old not in child:
 84                     child[i] = x_old
 85                     break
 86
 87     pop_new = []  # 新种群
 88     code_len = len(population[0])  # 基因编码的长度
 89     for i in range(POPULATION_SIZE):
 90         # 选择两个随机的交叉点
 91         p1, p2 = random.randint(0, code_len - 1), random.randint(0, code_len - 1)
 92         if p1 > p2:
 93             p1, p2 = p2, p1
 94         parent1, parent2 = random.choices(population, k=2)  # 选择两个随机的个体
 95         cross_code_1 = parent1[p1:p2] # 交叉前的编码块
 96         cross_code_2 = parent2[p1:p2] # 交叉后的编码块
 97         # 构造新的个体，-1表示基因编码尚未确定
 98         r = [-1] * p1 + cross_code_2 + [-1] * (code_len - p2)
 99         code_extends(r, parent1, 0, p1) #  继承父代的编码
100         code_extends(r, parent1, p2, code_len) #  继承父代的编码
101         mapping = create_mapping(cross_code_1, cross_code_2) # 两个交叉块的映射关系
102         code_rest(r, cross_code_1)  # 通过交换前的基因片段确定剩余编码
103         pop_new.append(r)
104     return pop_new
105
106 def crossover_cx(population):
107     ''' 循环交叉匹配 '''
108     pop_new = []  # 新种群
109     code_len = len(population[0])  # 基因编码的长度
110     for i in range(POPULATION_SIZE):
111         parent1, parent2 = random.choices(population, k=2)  # 选择两个随机的个体
112         r_new = [-1] * code_len  # 新个体
113         r_new[0] = parent1[0]
114         i = 0
115         while True:  # 循环交叉
116             x = parent2[i]
117             if r_new[0] == x:
118                 break
119             i = parent1.index(x)
120             r_new[i] = x
121         # r_new中剩余未确定的编码直接从parent2中继承
122         for i, x in enumerate(r_new):
123             if x == -1:
124                 r_new[i] = parent2[i]
125         pop_new.append(r_new)
126     return pop_new
127
128 def mutation(population):
129     ''' 变异 '''
130     code_len = len(population[0])  # 基因编码的长度
131     mp = 0.2  # 变异率
132     for i, r in enumerate(population):
133         if random.random() < mp:
134             # 两个随机变异点
135             p1, p2 = random.randint(0, code_len - 1), random.randint(0, code_len - 1)
136             # 交换两个变异点的数据
137             population[p1], population[p2] = population[p2], population[p1]
138
139 def sum_fitness(population):
140     ''' 计算种群的总适应度 '''
141     return sum([fitness_fun(code)[0] for code in population])
142
143 def ga():
144     ''' 遗传算法分配宿舍 '''
145     population = init_population() # 构建初始化种群
146     s_fitness = sum_fitness(population) # 种群的总适应度
147     i = 0
148     while i < 10: # 如果连续10代没有改进，结束算法
149         pop_next = selection(population) # 选择种群
150         pop_new = crossover_cx(pop_next) # 交叉
151         mutation(pop_new) # 变异
152         s_fitness_new = sum_fitness(pop_new) # 新种群的总适应度
153         if s_fitness > s_fitness_new: # 成本越低，适应度越高
154             s_fitness = s_fitness_new
155             i = 0
156         else:
157             i += 1
158         population = pop_new
159     # 按适应度值从大到小排序
160     population = sorted(population, key=lambda x: fitness_fun(x), reverse=True)
161     # 返回最优的个体
162     return population[0]
163
164 if __name__ == '__main__':
165     best = ga()
166     solution = solution_adapter(best)
167     total_cost, dorms_cost = base_data.cost_fun(solution)
168     base_data.print_solution(solution, total_cost, dorms_cost)

---

　　 作者：我是8位的

　　出处：http://www.cnblogs.com/bigmonkey

　　本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！ 

　　扫描二维码关注公众号“我是8位的”