基于遗传算法解决流水车间调度问题

基于简单遗传算法解决流水车间调度问题（FSP）

流水车间调度问题（FSP）

问题描述

n 个工件要在 m 台机器上加工，每个工件需要经过 m 道工序，每道工序要求不同的机器，n 个工件在 m 台机器上的加工顺序相同。工件在机器上的加工时间是给定的，设为
$$
t_{ij}(i = 1….,n; j = 1,…,m)
$$

问题的目标

确定 n 个工件在每台机器上的最优加工顺序，使最大流程时间达到最小。

假设（约束条件）

• 每个工件在机器上的加工顺序是给定的
• 每台机器同时只能加工一个工件
• 一个工件不能同时在不同的机器上加工
• 工序不能预定
• 工序的准备时间与顺序无关，且包含在加工时间中
• 工件在每台机器上的加工顺序相同，且是确定的

问题的数学模型

遗传算法原理

基因交换、变异

遗传算法模拟生物学染色体配对过程中基因交换、基因变异对问题进行求解。

在遗传算法中，可以将问题的一个可行解看成一条染色体，染色体在配对时发生基因交换或者发生基因变异生成新的染色体，即新的可行解。

而新产生的可行解（染色体）参与到下一次基因配对中，产生另一些新的可行解。

比如对于某一个问题的可行解有【1，2，3，4，5】，【2，3，4，5，1】，两个可行解交叉配对之后生成的新可行解可以是【1，3，4，5，5】和【2，2，3，4，1】，然后产生的新可行解在进行配对生成新的可行解。

染色体编码

将问题的可行解抽象化为适用于遗传算法的形式

• 二进制编码，将数值转换为二进制串，用以基因的配对交换、变异
• 旅行商问题，比如 10 个城市，某个解可以表示为【3，2，1，4，5，7，6，8，9，0】
• 根据不同的问题进行不同的抽象实现

适应度

遗传算法模拟生物学染色体配对过程。

以生物学简单理解，适应度可以理解为新生成的染色体的存活能力——一般来说，两个优秀染色体生成的新染色体也是优秀的——所以适应度越高，该染色体留下来（不被淘汰）的概率越大。

以旅行商问题为例，如果问题目标是要求路径最短，那么我们可以认为路径越短的可行解适应度越高，如果要用数值表示适应度，我们可以选择用 1/可行解表示的路径 的方式表示适应度，这样越小的路径表示的适应度数值表示就越大。

染色体配对（复制）

遗传算法的本质是对问题部分的可行解进行交换、变异产生新的可行解，并且希望在这个过程中可以通过较少次数得出该问题的最优解——如果次数过多或者直接产生所有可行解去寻找最优解那么实际上这样的方法和枚举法没有什么区别，反而会浪费时间和资源。

所以遗传算法中选择可行解（染色体）配对交换、变异是很重要的一步，也是算法优化的关键。

遗传算法配对选择的方式多种多样。

• 轮盘赌法——将个体适应度大小映射为概率进行复制：适应度高的个体有更大概率复制，且复制的分数越多。
  1. 将适应度大小映射为概率——比如此时有20个可行解，那么就有20个适应度（比如说 1/路程 ），那么每个可行解映射后的概率为 该可行解的适应度 / 20个可行解的总和
  2. 轮盘赌法的详细介绍（个人理解）—— 比如一开始问题的可行解有20个，即20个染色体，在第一次俩俩配对后生成 N 个可行解，此时问题的可行解有 20+N 个（其中可能有重复的可行解），然后对这 20+N 个可行解的适应度进行降序排序，选择 20+N 个可行解中适应度前 20 的可行解进行下一次染色体配对
• 精英产生精英——对适应度高的前 N/4 的个体纪念性复制，然后用这些个体把后 N/4 个体替换掉
• 不一定要将当前个体的复制体将下一个个体替换掉，可以选择随机选择个体进行配对
• 也不一定把适应度低的个体替换掉——从生物学理解，两个优秀（适应度高）的个体不一定生成的子代一定优秀（适应度高）—— 即遗传算法有很大概率只能找到局部最优解而不是全局最优解
• 还有很多。。。

染色体变异

和染色体配对一样，选择哪个染色体发生变异，或者发生变异的位置选择的策略也是多种多样的

• 每个个体都发生变异
• 只对适应度低的后 N/4 的，或者 N/2 个个体变异
• 按适应度大小映射为概率变异
• 可以选择多个位点进行变异
• 还有很多。。。

适应度映射为概率之后的归一化处理

比如此时有 4 个 可行解，根据 适应度 / 适应度的总和 计算映射后的概率，比如此时 4 个可行解适应度映射后的概率为 【0.2，0.1，0.4，0.3】。

面对【0.2，0.1，0.4，0.3】的概率，在选择染色体时我们一般选择 【0.2，0.1，0.4，0.3】长度的 if 判断选择染色体，伪代码如下：

概率 = random.random()
if 概率 < 0.2:
    选择 0.2 对应的染色体
if 0.2 <= 概率 <= 0.2+0.1:
    ...
 ...

理论上这样的代码不报错也是可行的，但实际上这种代码是不合理的，因为假设此时可行解的规模大小是 1万，那么我们就需要写 1万 个 if 条件判断，这显然是不可能的，所以解决办法就是对这些概率进行归一化处理——这样就可以用 循环+if 条件判断解决要写 1万 个 if 判断的麻烦。

伪代码如下：

此时概率列表为 [0.2, 0.3, 0.7, 1.0]
概率 = random.random()
for i in 列表：
    if 概率 < i:
        选择 i 对应的染色体
        break 退出循环
        
'''
解释
如果此时随机的概率为 0.1，那么 0.1<0.2,选择 0.2 所对应的染色体

如果此时随机的概率为 0.5，那么 0.5>0.2, 0.5>0.3, 0.5<0.7, 选择 0.7 所对应的染色体——在判断 0.5和0.7的关系之前，循环已经判断了 0.5 和 0.2，0.3 之间的大小关系，所以在判断0.5 和0.7的关系时，我们已经保证了此时 随机的概率（0.5）不在0.2和0.3的概率范围之内
'''

另一种判断方式的伪代码：

此时概率列表为 [0.2, 0.3, 0.7, 1.0]
概率 = random.random()
概率差值列表 = [概率 - i for i in 概率列表]
for i in 概率差值列表:
    if i < 0: # 选择第一个差值 < 0 的 i 对应的染色体
        选择 i 对应的染色体
        break 退出循环
    continue
 '''
 解释
 随机概率为 0.1
 差值列表为 【-0.1，-0.2，-0.6，-0.9】
 -0.1 是第一个小于0的差值，所以选择 0.2 所对应的染色体
 '''

将流水车间调度问题（FSP）转换成遗传算法模型

染色体编码

每个染色体编码成工件号序列，比如5个工件的一个编码为序列：[5 1 3 4 2]——表示为加工顺序为工件5，工件1，工件3，工件4，工件2

基因交换、变异

在遗传算法中，可以将问题的一个可行解看成一条染色体，染色体在配对时发生基因交换或者发生基因变异生成新的染色体，即新的可行解。

而新产生的可行解（染色体）参与到下一次基因配对中，产生另一些新的可行解。

基因交换

'''
如果交换前的解为
【1 2 3 4 5】 解1
【4 2 5 1 3】 解2

要交换部分为
【2 3 4】
【2 5 1】

交换后解为
【1 2 5 1 5】 解3
【4 2 3 4 3】 解4

我们发现此时两个解加工工件有重复，需要进一步约束
下面就是进一步约束
此时 解1 的 头（head） 为 【1】，被交换过来的部分为 【2 5 1】，交换给解2的部分为 【2 3 4】，其中 1 重复，所以将重复的 解1 的 头（head） 更改为 被交换过来的部分1和交换过去的部分同一位置的数，所以 解3 的头（head） 为 4
解1 的 尾（tail）也一样，改为 3
所以最后的 解3 为 【4 2 5 1 3】
          解4 为 【1 2 3 4 5】
'''

基因突变

# 基因突变，相当于内部相关值进行交换
# 如：原来的解为 【1，2，3，4，5】，基因突变后 【1，3，2，4，5】

适应度

由于问题目标是：确定 n 个工件在每台机器上的最优加工顺序，使最大流程时间达到最小。

所以在该问题中时间越小可行解的适应度就越高，有适应度公式
$$
适应度 = 1/最大流程时间
$$

适应度映射为概率之后的归一化处理

适应度映射为概率

$$
适应度 / 适应度的总和=计算映射后的概率
$$

归一化处理

选择第二种伪代码

此时概率列表为 [0.2, 0.3, 0.7, 1.0]
概率 = random.random()
概率差值列表 = [概率 - i for i in 概率列表]
for i in 概率差值列表:
    if i < 0: # 选择第一个差值 < 0 的 i 对应的染色体
        选择 i 对应的染色体
        break 退出循环
    continue

具体代码如下

# 适应度概率归一化处理
choice = [choiceList[j] / sum(choiceList) for j in range(len(choiceList))]
# print(choice)
sum_choice = []
for p in range(len(choice)):
    if p == 0:
        sum_choice.append(choice[p])
    else:
        sum_choice.append(choice[p] + sum_choice[p - 1])
        # print(sum_choice)
         # print(rand_num)

'''
选择配对的个体，选择 self.N 个
'''
choice_three = []
for i in range(self.N):
    rand_num = random.random()
    three_change_list = [rand_num - sum_choice[i] for i in range(len(sum_choice))]
    change_index = self.where_change(three_change_list)
    choice_three.append(N_group[change_index])

染色体配对（复制）

遗传算法配对选择的方式多种多样，对该问题我们选择轮盘赌法进行染色体选择。

• 轮盘赌法——将个体适应度大小映射为概率进行复制：适应度高的个体有更大概率复制，且复制的分数越多。
  1. 将适应度大小映射为概率——比如此时有20个可行解，那么就有20个适应度（比如说 1/路程 ），那么每个可行解映射后的概率为 该可行解的适应度 / 20个可行解的总和
  2. 轮盘赌法的详细介绍（个人理解）—— 比如一开始问题的可行解有20个，即20个染色体，在第一次俩俩配对后生成 N 个可行解，此时问题的可行解有 20+N 个（其中可能有重复的可行解），然后对这 20+N 个可行解的适应度进行降序排序，选择 20+N 个可行解中适应度前 20 的可行解进行下一次染色体配对

遗传算法代码

染色体类

# data
# fitness 适应度
class Node:
    def __init__(self,data,fitness):
        self.data = data
        self.fitness = fitness

参数介绍

N = 20  # 群体大小，即进行染色体配对时，染色体规模，配对时只考虑其中 20个 可行解
T = 50  # 终止进化代数
Pc = 0.6 # 交叉概率
Pm=0.1 # 变异概率
n = 5 # 工件个数
machine = 4 # 机器个数

实例化参数

def __init__(self,pc=0.6,pm=0.1,N=5,T=2,n=work_num,machine=machine_num):
    '''
    N = 20  # 群体大小
    T = 50  # 终止进化代数
    Pc = 0.6 # 交叉概率
    Pm=0.1 # 变异概率
    n = 5 # 工件个数
    machine = 4 # 机器个数
    '''

    self.pc = pc
    self.pm = pm
    self.N = N
    self.T = T
    self.n = n
    self.machine = machine

生成初始解

# 生成 N 个（种群规模）的初始解
def init_list(self):
    N_group = []
    for i in range(self.N):
        order_list = [p for p in range(1, self.n + 1)]
        random.shuffle(order_list)
        # node = Node(order_list,fitness(order_list))
        N_group.append(order_list)
    # print(N_group)
    return N_group

计算最大流程时间和适应度

def fitness(self,order_list):
    '''
    根据列表顺序调整整体数据。
    '''
    # 复制 order_list
    three_init_data = copy.deepcopy(order_list)
    # print(three_init_data)

    # 输出
    for j in range(len(order_list)):
        i = order_list[j]
        order_i = str(i)
        three_init_data[j] = source_data[order_i]

    init_data = np.array(three_init_data)
    # print(init_data)

    # k = init_data.shape[0]
    # j = init_data.shape[1] - 1
    # print(k,j)

    def find_time(k, j):
        if k == 1 and j == 1:
            return init_data[0, 1]
        elif k >= 2 and j == 1:
            return find_time(k - 1, 1) + init_data[k - 1, 1]
        elif k == 1 and j >= 2:
            return find_time(1, j - 1) + init_data[0, j]
        else:
            time = max(find_time(k - 1, j), find_time(k, j - 1)) + init_data[k - 1, j]
        return time
    time = find_time(self.n, self.machine)
    # print(time)
    fitness = 1 / time
    print(time)
    return fitness, time

基因交换

def cross_change(self,choice_three):
    changed_list = []
    '''
    函数：两点交叉 传入数据为node列表 长度20
    '''
    def change_main(a1,a2):
        '''
        两点交叉
        传入数据为两个个体
        '''

        a1_copy = copy.deepcopy(a1)
        a2_copy = copy.deepcopy(a2)

        random_1 = random.randint(0, self.n - 1)
        random_2 = random.randint(0, self.n - 1)

        # 确保 random_1 < random_2
        while random_1 > random_2 or random_1 == random_2:
            random_1 = random.randint(0,self.n-1)
            random_2 = random.randint(0,self.n-1)
        # 交换,因为是无脑交换，所以需要考虑交换之后的工件顺序是否有重复，即不能出现交换之后的解为 [1, 4, 3, 1, 5] [4, 2, 2, 3, 5] 的情况
        a1_copy.data[random_1:random_2], a2_copy.data[random_1:random_2] = a2_copy.data[random_1:random_2], a1_copy.data[random_1:random_2]

        intermediate1 = a1.data[random_1:random_2]
        intermediate2 = a2.data[random_1:random_2]

        head1 = []
        head2 = []
        tail1 = []
        tail2 = []

        '''
        如果交换前的解为
        【1 2 3 4 5】 解1
        【4 2 5 1 3】 解2
        要交换部分为
        【2 3 4】
        【2 5 1】
        交换后解为
        【1 2 5 1 5】 解3
        【4 2 3 4 3】 解4
        我们发现此时两个解加工工件有重复，需要进一步约束
        下面子代头尾的代码就是进一步约束
        此时 解1 的 头（head） 为 【1】，被交换过来的部分为 【2 5 1】，交换给解2的部分为 【2 3 4】，其中 1 重复，所以将重复的 解1 的 头（head） 更改为 被交换过来的部分1和交换过去的部分同一位置的数，所以 解3 的头（head） 为 4
        解1 的 尾（tail）也一样，改为 3
        所以最后的 解3 为 【4 2 5 1 3】
                  解4 为 【1 2 3 4 5】
        '''

        # 子代1头
        for i in a1_copy.data[:random_1]:
            while i in intermediate2:
                i = intermediate1[intermediate2.index(i)]
            head1.append(i)

        # 子代1尾
        for i in a1_copy.data[random_2:]:
            while i in intermediate2:
                i = intermediate1[intermediate2.index(i)]
            tail1.append(i)

        # 子代2头
        for i in a2_copy.data[:random_1]:
            while i in intermediate1:
                i = intermediate2[intermediate1.index(i)]
            head2.append(i)

        # 子代2尾
        for i in a2_copy.data[random_2:]:
            while i in intermediate1:
                i = intermediate2[intermediate1.index(i)]
            tail2.append(i)

        result1 = head1 + intermediate2 + tail1
        result2 = head2 + intermediate1 + tail2

        result1 = Node(result1, self.fitness(result1))
        result2 = Node(result2, self.fitness(result2))

        return result1, result2

    # 选取 母亲 和 父亲
    male = choice_three[0:len(choice_three):2]
    female = choice_three[1:len(choice_three):2]

    if len(male) != len(female):
        minmale = min(len(male), len(female))
    else:
        minmale = len(male)

    for j in range(minmale):
        cross_rand = random.random()
        if cross_rand < self.pc: # 发生交换
            a1, a2 = change_main(male[j], female[j])
            changed_list.append(a1)
            changed_list.append(a2)
        else:
            changed_list.append(male[j])
            changed_list.append(female[j])

    return changed_list

基因突变

# 基因突变，相当于内部相关值进行交换
# 如：原来的解为 【1，2，3，4，5】，基因突变后 【1，3，2，4，5】
def variation_change(self, cross_change_three):
    changed_variation = []
    for j in range(len(cross_change_three)):
        variation_rand = random.random()
        if variation_rand < self.pm:
            random_1 = random.randint(0, self.n - 1)
            random_2 = random.randint(0, self.n - 1)
            # print("变异之前的数据",cross_change_three[j].data)
            cross_change_three[j].data[random_1],cross_change_three[j].data[random_2]=cross_change_three[j].data[random_2], cross_change_three[j].data[random_1]
            changed_variation.append(cross_change_three[j])
            # print("变异之后的数据",cross_change_three[j].data)
        else:
            changed_variation.append(cross_change_three[j])

    return changed_variation

轮盘赌法选择

# 确定进行配对的个体
def where_change(self,three_change_list):
    for i in range(len(three_change_list)):
        if three_change_list[i]<=0:
            return i
        continue

....

# 选择操作
choiceList = [N_group[i].fitness[1] for i in range(len(N_group))]
#             print(choiceList)
'''
求出个体i被选中的概率，选择轮盘赌
'''
# 适应度概率归一化处理
choice = [choiceList[j] / sum(choiceList) for j in range(len(choiceList))]
# print(choice)
sum_choice = []
for p in range(len(choice)):
    if p == 0:
        sum_choice.append(choice[p])
    else:
        sum_choice.append(choice[p] + sum_choice[p - 1])

# print(sum_choice)
# print(rand_num)

'''
选择配对的个体，选择 self.N 个
'''
choice_three = []
for i in range(self.N):
    rand_num = random.random()
    three_change_list = [rand_num - sum_choice[i] for i in range(len(sum_choice))]
    change_index = self.where_change(three_change_list)
    choice_three.append(N_group[change_index])

最终完整代码

import copy
import numpy as np
import random
import threading

# data
# fitness 适应度
class Node:
    def __init__(self,data,fitness):
        self.data = data
        self.fitness = fitness

# 测试样例
# source_data = {'1':[1,31,41,25,30],
#              '2':[2,19,55,3,34],
#              '3':[3,23,42,27,6],
#              '4':[4,13,22,14,13],
#              '5':[5,33,5,57,19]
#             }

path_list = ["car01.txt", "car07.txt", "rec01.txt"]
# path_list = ["rec21.txt"]
# path_list = ["rec31.txt"]

for path in path_list:
    print(path)
    source_data = {}
    with open(path, "r", encoding="utf-8") as f:
        count = 0
        for line in f:
            data_list = line.split(" ")[1:]
            if "" in data_list:
                data_list.remove("")
            # print(data_list)

            if count == 0:
                work_num = int(data_list[0])
                machine_num = int(data_list[1])
            else:
                values = []
                values.append(count)
                work_time_list = data_list[1::2]
                for i in work_time_list:
                    if "\n" in i:
                        i = i[:-1]
                    data = int(i)
                    values.append(data)
                # print(values)
                source_data[str(count)] = values
            count += 1
            # print(source_data)

    class GA_FSP:
        def __init__(self,pc=0.6,pm=0.1,N=20,T=100,n=work_num,machine=machine_num):
            '''
            N = 20  #群体大小
            T = 100  #Ga终止进化代数
            Pc = 0.6 #交叉概率
            Pm=0.1 #变异概率
            n = 5 #工件个数
            machine = 4 #机器个数
            '''

            self.pc = pc
            self.pm = pm
            self.N = N
            self.T = T
            self.n = n
            self.machine = machine

        def fitness(self,order_list):
            '''
            根据列表顺序调整整体数据。
            '''
            # 复制 order_list
            three_init_data = copy.deepcopy(order_list)
            # print(three_init_data)

            # 输出
            for j in range(len(order_list)):
                i = order_list[j]
                order_i = str(i)
                three_init_data[j] = source_data[order_i]

            init_data = np.array(three_init_data)
            # print(init_data)

            # k = init_data.shape[0]
            # j = init_data.shape[1] - 1
            # print(k,j)

            def find_time(k, j):
                if k == 1 and j == 1:
                    return init_data[0, 1]
                elif k >= 2 and j == 1:
                    return find_time(k - 1, 1) + init_data[k - 1, 1]
                elif k == 1 and j >= 2:
                    return find_time(1, j - 1) + init_data[0, j]
                else:
                    time = max(find_time(k - 1, j), find_time(k, j - 1)) + init_data[k - 1, j]
                return time
            time = find_time(self.n, self.machine)
            # print(time)
            fitness = 1 / time
            print(time)
            return fitness, time

        # 生成 N 个（种群规模）的初始解
        def init_list(self):
            N_group = []
            for i in range(self.N):
                order_list = [p for p in range(1, self.n + 1)]
                random.shuffle(order_list)
                #             node = Node(order_list,fitness(order_list))
                N_group.append(order_list)
            # print(N_group)
            return N_group

        # 确定进行配对的个体
        def where_change(self,three_change_list):
            for i in range(len(three_change_list)):
                if three_change_list[i]<=0:
                    return i
                continue

        def cross_change(self,choice_three):
            changed_list = []
            '''
            函数：两点交叉 传入数据为node列表 长度20
            '''
            def change_main(a1,a2):
                '''
                两点交叉
                传入数据为两个个体
                '''

                a1_copy = copy.deepcopy(a1)
                a2_copy = copy.deepcopy(a2)

                random_1 = random.randint(0, self.n - 1)
                random_2 = random.randint(0, self.n - 1)

                # 确保 random_1 < random_2
                while random_1 > random_2 or random_1 == random_2:
                    random_1 = random.randint(0,self.n-1)
                    random_2 = random.randint(0,self.n-1)
                # 交换,因为是无脑交换，所以需要考虑交换之后的工件顺序是否有重复，即不能出现交换之后的解为 [1, 4, 3, 1, 5] [4, 2, 2, 3, 5] 的情况
                a1_copy.data[random_1:random_2], a2_copy.data[random_1:random_2] = a2_copy.data[random_1:random_2], a1_copy.data[random_1:random_2]

                intermediate1 = a1.data[random_1:random_2]
                intermediate2 = a2.data[random_1:random_2]

                head1 = []
                head2 = []
                tail1 = []
                tail2 = []

                '''
                如果交换前的解为
                【1 2 3 4 5】 解1
                【4 2 5 1 3】 解2
                要交换部分为
                【2 3 4】
                【2 5 1】
                交换后解为
                【1 2 5 1 5】 解3
                【4 2 3 4 3】 解4
                我们发现此时两个解加工工件有重复，需要进一步约束
                下面子代头尾的代码就是进一步约束
                此时 解1 的 头（head） 为 【1】，被交换过来的部分为 【2 5 1】，交换给解2的部分为 【2 3 4】，其中 1 重复，所以将重复的 解1 的 头（head） 更改为 被交换过来的部分1和交换过去的部分同一位置的数，所以 解3 的头（head） 为 4
                解1 的 尾（tail）也一样，改为 3
                所以最后的 解3 为 【4 2 5 1 3】
                          解4 为 【1 2 3 4 5】
                '''

                # 子代1头
                for i in a1_copy.data[:random_1]:
                    while i in intermediate2:
                        i = intermediate1[intermediate2.index(i)]
                    head1.append(i)

                # 子代1尾
                for i in a1_copy.data[random_2:]:
                    while i in intermediate2:
                        i = intermediate1[intermediate2.index(i)]
                    tail1.append(i)

                # 子代2头
                for i in a2_copy.data[:random_1]:
                    while i in intermediate1:
                        i = intermediate2[intermediate1.index(i)]
                    head2.append(i)

                # 子代2尾
                for i in a2_copy.data[random_2:]:
                    while i in intermediate1:
                        i = intermediate2[intermediate1.index(i)]
                    tail2.append(i)

                result1 = head1 + intermediate2 + tail1
                result2 = head2 + intermediate1 + tail2

                result1 = Node(result1, self.fitness(result1))
                result2 = Node(result2, self.fitness(result2))

                return result1, result2

            # 选取 母亲 和 父亲
            male = choice_three[0:len(choice_three):2]
            female = choice_three[1:len(choice_three):2]

            if len(male) != len(female):
                minmale = min(len(male), len(female))
            else:
                minmale = len(male)

            for j in range(minmale):
                cross_rand = random.random()
                if cross_rand < self.pc: # 发生交换
                    a1, a2 = change_main(male[j], female[j])
                    changed_list.append(a1)
                    changed_list.append(a2)
                else:
                    changed_list.append(male[j])
                    changed_list.append(female[j])

            return changed_list

        # 基因突变，相当于内部相关值进行交换
        # 如：原来的解为 【1，2，3，4，5】，基因突变后 【1，3，2，4，5】
        def variation_change(self, cross_change_three):
            changed_variation = []
            for j in range(len(cross_change_three)):
                variation_rand = random.random()
                if variation_rand < self.pm:
                    random_1 = random.randint(0, self.n - 1)
                    random_2 = random.randint(0, self.n - 1)
                    # print("变异之前的数据",cross_change_three[j].data)
                    cross_change_three[j].data[random_1],cross_change_three[j].data[random_2]=cross_change_three[j].data[random_2], cross_change_three[j].data[random_1]
                    changed_variation.append(cross_change_three[j])
                    # print("变异之后的数据",cross_change_three[j].data)
                else:
                    changed_variation.append(cross_change_three[j])

            return changed_variation

        def __sort_threelist(self,arr):
            '''
            冒泡排序，适应度排序，有进行归一化处理吗？
            '''
            n = len(arr)
            for i in range(n):
                for j in range(0,n-i-1):
                    if arr[j].fitness[1]>arr[j+1].fitness[1]:
                        arr[j],arr[j+1] = arr[j+1] ,arr[j]
            return arr

        def pro_go(self):
            # 初始化种群
            N_group = self.init_list()
            for j in range(len(N_group)):
                N_group[j] = Node(N_group[j], self.fitness(N_group[j]))
            # 开始迭代
            draw_x = []
            draw_y = []
            for num in range(self.T + 1):
                # 每完成一次迭代就计算一次适应度
                for j in range(len(N_group)):
                    N_group[j].fitness = self.fitness(N_group[j].data)
                #                 print(N_group[j].fitness[0])
                #                 print(N_group)

                if num > self.T:
                    break

                # 选择操作
                choiceList = [N_group[i].fitness[1] for i in range(len(N_group))]
                #             print(choiceList)
                '''
                求出个体i被选中的概率，选择轮盘赌
                '''
                # 适应度概率归一化处理
                choice = [choiceList[j] / sum(choiceList) for j in range(len(choiceList))]
                # print(choice)
                sum_choice = []
                for p in range(len(choice)):
                    if p == 0:
                        sum_choice.append(choice[p])
                    else:
                        sum_choice.append(choice[p] + sum_choice[p - 1])

                # print(sum_choice)
                # print(rand_num)

                '''
                选择配对的个体，选择 self.N 个
                '''
                choice_three = []
                for i in range(self.N):
                    rand_num = random.random()
                    three_change_list = [rand_num - sum_choice[i] for i in range(len(sum_choice))]
                    change_index = self.where_change(three_change_list)
                    choice_three.append(N_group[change_index])
                '''
                交叉
                传入种群节点即可
                '''

                cross_choice_three = self.cross_change(choice_three)
                # print(cross_choice_three)
                '''
                变异
                '''
                variation_three = self.variation_change(cross_choice_three)
                sort_group = N_group + variation_three

                print("第" + str(num) + "次迭代", end=" ")
                N_group = self.__sort_threelist(sort_group)[0:self.N] # 选择前 self.N 个适应度大的作为下一次迭代的父母
                print(N_group[0].fitness[1], end='--')
                print(N_group[-1].fitness[1])
                #             print()
                draw_x.append(num)
                draw_y.append(N_group[0].fitness[1])

                random.shuffle(N_group)

            N_group = self.__sort_threelist(sort_group)[0:self.N]
            for i in range(len(N_group)):
                print(N_group[i].data)

            return N_group[i], draw_x, draw_y

    Ga1 = GA_FSP(n=work_num, machine=machine_num)
    best1,draw_x,draw_y = Ga1.pro_go()
    final_data = best1.data

    import matplotlib.pyplot as plt
    plt.plot(draw_x, draw_y)
    plt.show()

数据介绍

 11 5 # 11 —— 11个工件数，5 —— 5 台机器
 0 375 1  12 2 142 3 245 4 412 # 0，1，2，3，4 表示第0，1，2，3，4 机器，其他为加工时间
 0 632 1 452 2 758 3 278 4 398
 0  12 1 876 2 124 3 534 4 765
 0 460 1 542 2 523 3 120 4 499
 0 528 1 101 2 789 3 124 4 999
 0 796 1 245 2 632 3 375 4 123
 0 532 1 230 2 543 3 896 4 452
 0  14 1 124 2 214 3 543 4 785
 0 257 1 527 2 753 3 210 4 463
 0 896 1 896 2 214 3 258 4 259
 0 532 1 302 2 501 3 765 4 988

运行结果

运行结果是局部最优解，不是全局最优解，每次运行结果可能会有变化

car01.txt

数据

 11 5
 0 375 1  12 2 142 3 245 4 412
 0 632 1 452 2 758 3 278 4 398
 0  12 1 876 2 124 3 534 4 765
 0 460 1 542 2 523 3 120 4 499
 0 528 1 101 2 789 3 124 4 999
 0 796 1 245 2 632 3 375 4 123
 0 532 1 230 2 543 3 896 4 452
 0  14 1 124 2 214 3 543 4 785
 0 257 1 527 2 753 3 210 4 463
 0 896 1 896 2 214 3 258 4 259
 0 532 1 302 2 501 3 765 4 988

迭代100次最终值为：7156

car07.txt

数据

 7 7
 0 692 1 310 2 832 3 630 4 258 5 147 6 255
 0 581 1 582 2  14 3 214 4 147 5 753 6 806
 0 475 1 475 2 785 3 578 4 852 5  2 6 699
 0  23 1 196 2 696 3 214 4 586 5 356 6 877
 0 158 1 325 2 530 3 785 4 325 5 565 6 412
 0 796 1 874 2 214 3 236 4 896 5 898 6 302
 0 542 1 205 2 578 3 963 4 325 5 800 6 120

迭代100次最终值为：6685

rec01.txt

数据

 20 5
 0 5 1 76 2 74 3 99 4 26
 0 74 1 21 2 83 3 52 4 90
 0 67 1 48 2  6 3 66 4 38
 0 97 1 36 2 71 3 68 4 81
 0 87 1 86 2 64 3 11 4 31
 0  1 1 42 2 20 3 90 4 23
 0 69 1 32 2 99 3 26 4 57
 0 69 1 12 2 54 3 80 4 16
 0 11 1 63 2 24 3 16 4 89
 0 87 1 52 2 43 3 10 4 26
 0 25 1 59 2 88 3 87 4 40
 0 50 1 42 2 72 3 77 4 29
 0 58 1 76 2 71 3 82 4 94
 0 79 1 48 2 20 3 63 4 97
 0 35 1 57 2 78 3 99 4 80
 0 70 1 76 2 53 3  2 4 19
 0 79 1 22 2 77 3 74 4 95
 0 34 1 99 2 49 3  3 4 61
 0 37 1 24 2 32 3 35 4  4
 0 50 1 88 2 46 3 63 4 76

迭代100次最终值为：1368

rec21.txt

数据

 30 10
 0 12 1 89 2 69 3 94 4 22 5 31 6 22 7 95 8 36 9 38
 0 55 1 2 2 94 3 19 4 43 5 74 6 72 7 10 8 99 9 16
 0 34 1 78 2 27 3 40 4 21 5 17 6 15 7 62 8 96 9 63
 0 100 1 14 2 23 3 42 4 52 5 18 6 29 7 70 8 21 9 47
 0 41 1 92 2 88 3 52 4 99 5 41 6 68 7 22 8 57 9 66
 0 24 1 62 2 19 3 35 4 24 5 49 6 100 7 65 8 13 9 41
 0 29 1 34 2 38 3 72 4 29 5 83 6 44 7 91 8 65 9 100
 0 89 1 62 2 32 3 54 4 93 5 59 6 8 7 24 8 86 9 66
 0 23 1 34 2 89 3 66 4 10 5 48 6 27 7 11 8 94 9 45
 0 81 1 57 2 35 3 78 4 23 5 66 6 1 7 3 8 77 9 14
 0 72 1 47 2 75 3 27 4 66 5 64 6 30 7 49 8 42 9 7
 0 10 1 15 2 26 3 12 4 98 5 12 6 53 7 81 8 46 9 3
 0 47 1 54 2 58 3 73 4 44 5 87 6 87 7 98 8 34 9 15
 0 13 1 27 2 29 3 85 4 29 5 64 6 62 7 62 8 79 9 74
 0 49 1 57 2 24 3 44 4 18 5 97 6 59 7 75 8 17 9 22
 0 50 1 11 2 93 3 53 4 52 5 13 6 51 7 76 8 87 9 95
 0 99 1 87 2 85 3 9 4 87 5 98 6 34 7 22 8 66 9 11
 0 7 1 8 2 90 3 95 4 29 5 79 6 70 7 79 8 6 9 58
 0 48 1 100 2 74 3 60 4 74 5 19 6 21 7 6 8 77 9 84
 0 96 1 86 2 19 3 15 4 45 5 1 6 90 7 49 8 98 9 80
 0 68 1 73 2 55 3 13 4 28 5 16 6 57 7 20 8 76 9 71
 0 53 1 38 2 4 3 43 4 11 5 49 6 12 7 91 8 47 9 3
 0 57 1 13 2 12 3 12 4 21 5 68 6 2 7 80 8 9 9 28
 0 37 1 79 2 92 3 35 4 63 5 13 6 58 7 36 8 65 9 94
 0 39 1 49 2 57 3 23 4 53 5 80 6 42 7 29 8 52 9 33
 0 36 1 54 2 59 3 69 4 62 5 12 6 77 7 37 8 87 9 47
 0 63 1 35 2 26 3 38 4 47 5 82 6 89 7 34 8 1 9 93
 0 60 1 28 2 1 3 51 4 94 5 86 6 42 7 75 8 76 9 77
 0 2 1 51 2 79 3 74 4 51 5 28 6 78 7 87 8 81 9 35
 0 45 1 94 2 42 3 9 4 70 5 4 6 52 7 54 8 16 9 27

由于计算最大流程时间的时间过久，所以此时 N=5（种群规模为5），T=2（迭代次数2次）

迭代100次最终值为：2394

rec31.txt

数据

 50 10
 0 59 1 47 2 20 3 43 4 49 5 74 6 38 7 46 8 18 9 12
 0 30 1 1 2 90 3 97 4 5 5 70 6 59 7 63 8 15 9 93
 0 22 1 58 2 68 3 3 4 33 5 48 6 27 7 12 8 65 9 21
 0 70 1 81 2 2 3 32 4 72 5 57 6 32 7 25 8 13 9 87
 0 38 1 17 2 48 3 53 4 57 5 17 6 25 7 50 8 72 9 72
 0 51 1 15 2 72 3 8 4 34 5 90 6 40 7 44 8 47 9 77
 0 63 1 84 2 75 3 75 4 71 5 13 6 10 7 97 8 81 9 31
 0 48 1 62 2 71 3 70 4 6 5 94 6 10 7 71 8 29 9 99
 0 92 1 29 2 91 3 99 4 54 5 64 6 89 7 89 8 38 9 87
 0 91 1 21 2 56 3 49 4 43 5 20 6 27 7 68 8 99 9 73
 0 62 1 6 2 3 3 89 4 48 5 97 6 79 7 21 8 96 9 77
 0 67 1 83 2 70 3 49 4 50 5 50 6 60 7 28 8 15 9 50
 0 73 1 18 2 55 3 49 4 66 5 56 6 90 7 29 8 87 9 4
 0 27 1 94 2 71 3 33 4 31 5 68 6 45 7 52 8 95 9 40
 0 48 1 28 2 46 3 73 4 89 5 35 6 98 7 97 8 67 9 9
 0 7 1 51 2 48 3 4 4 29 5 62 6 37 7 15 8 10 9 66
 0 55 1 46 2 65 3 48 4 61 5 36 6 69 7 14 8 78 9 100
 0 4 1 4 2 31 3 49 4 28 5 78 6 73 7 26 8 29 9 26
 0 19 1 97 2 37 3 30 4 37 5 16 6 15 7 89 8 11 9 16
 0 30 1 95 2 86 3 22 4 17 5 16 6 61 7 79 8 24 9 9
 0 71 1 39 2 93 3 87 4 38 5 7 6 24 7 1 8 91 9 34
 0 83 1 40 2 37 3 25 4 68 5 47 6 81 7 62 8 96 9 19
 0 45 1 33 2 12 3 63 4 32 5 40 6 60 7 54 8 66 9 92
 0 40 1 67 2 83 3 11 4 62 5 69 6 46 7 93 8 80 9 50
 0 100 1 6 2 82 3 78 4 5 5 43 6 18 7 73 8 86 9 62
 0 97 1 75 2 81 3 22 4 38 5 2 6 53 7 44 8 73 9 74
 0 74 1 89 2 14 3 33 4 11 5 43 6 70 7 58 8 47 9 8
 0 73 1 46 2 62 3 27 4 63 5 34 6 58 7 91 8 11 9 80
 0 14 1 24 2 27 3 62 4 72 5 85 6 98 7 99 8 25 9 7
 0 100 1 29 2 8 3 55 4 88 5 96 6 23 7 98 8 19 9 79
 0 53 1 11 2 74 3 66 4 94 5 66 6 98 7 87 8 5 9 85
 0 68 1 77 2 88 3 47 4 51 5 73 6 16 7 17 8 87 9 96
 0 69 1 40 2 46 3 62 4 23 5 31 6 45 7 21 8 15 9 40
 0 34 1 41 2 10 3 17 4 25 5 33 6 17 7 28 8 45 9 68
 0 7 1 26 2 79 3 76 4 35 5 92 6 77 7 15 8 27 9 69
 0 47 1 31 2 83 3 28 4 92 5 83 6 96 7 18 8 84 9 45
 0 54 1 96 2 8 3 28 4 94 5 50 6 20 7 28 8 99 9 65
 0 9 1 13 2 81 3 1 4 94 5 82 6 29 7 82 8 27 9 45
 0 64 1 22 2 51 3 33 4 9 5 25 6 22 7 64 8 78 9 88
 0 38 1 25 2 16 3 24 4 62 5 4 6 39 7 77 8 36 9 60
 0 72 1 6 2 40 3 56 4 23 5 39 6 38 7 5 8 75 9 44
 0 26 1 33 2 37 3 84 4 61 5 86 6 22 7 94 8 93 9 17
 0 88 1 39 2 63 3 43 4 98 5 27 6 32 7 20 8 25 9 25
 0 73 1 70 2 57 3 5 4 100 5 31 6 34 7 11 8 98 9 76
 0 77 1 4 2 85 3 50 4 9 5 45 6 35 7 3 8 41 9 80
 0 20 1 36 2 9 3 89 4 4 5 32 6 76 7 20 8 84 9 6
 0 99 1 64 2 7 3 68 4 67 5 85 6 60 7 23 8 55 9 52
 0 13 1 7 2 80 3 57 4 22 5 78 6 75 7 17 8 70 9 55
 0 40 1 87 2 34 3 96 4 27 5 78 6 53 7 40 8 72 9 91
 0 77 1 8 2 14 3 76 4 19 5 82 6 86 7 21 8 10 9 51

由于计算最大流程时间的时间过久，所以此时 N=5（种群规模为5），T=2（迭代次数2次）

代码一些问题

由于计算最大流程时间的时间过久，在处理 rec21.txt 和 rec31.txt 时改变了参数，N=5（种群规模为5），T=2（迭代次数2次）

参考内容

代码参考

遗传算法理论学习