Python遗传算法解决作业调度问题（JSP）

最新推荐文章于 2024-06-14 17:01:59 发布
最新推荐文章于 2024-06-14 17:01:59 发布
阅读量5.9k 收藏 95
点赞数 17
分类专栏： 遗传算法 文章标签： python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Juuunn/article/details/109756418
版权

2020年12月9日更新

感谢谭同学发现的bug，由于后期绘制甘特图的时候是依靠索引来取工件数和机器数，所以会导致工件或者机器>9的时候绘图失败（进化算法本身没问题），针对于此，采取正则表达式匹配Ci_j中的i（工件）与j（机器）。
更新后两个版本的代码进化算法本身没问题可以放心用，但是旧版本的甘特图不完美，新版本在文末
以下为旧码，

import matplotlib.pyplot as plt
from collections import OrderedDict
import random
import copy
import datetime

jobs = 5  # 工件数
machines = 4  # 机器数
population_num = 10  # 种群规模
population = []  # 初始种群
variation_rate = 0.8  # 变异率
iters = 50  # 进化次数
target_points = [1, 2, 3]  # 变异靶点

# 初始化一个种群
for i in range(population_num):
    population.append(random.sample(range(1, jobs + 1), jobs))

time_table = [[31, 41, 25, 30],  # 加工时间表,工件为行，机器为列
              [19, 55, 3, 34],
              [23, 42, 27, 6],
              [13, 22, 14, 13],
              [33, 5, 57, 19]]

# 产生随机解
random.seed(0)


# 定义工作节点类 name为Cij:第i个工件在第j个机器上加工，StartTime为开始时间，LoadTime为加工时间，EndTime为加工结束时间
class Cij:
    def __init__(self, name, StartTime, LoadTime):
        self.name = name
        self.StartTime = StartTime
        self.LoadTime = LoadTime
        self.EndTime = StartTime + LoadTime



# 定义最大流程时间函数
def c_max(n):
    # 循环赋值函数，将工件数，机器数与加工时间进行绑定
    for job, i in enumerate(time_table):
        for machine, loadtime in enumerate(i):
            locals()['c{}_{}'.format(job + 1, machine + 1)] = Cij(name='c{}_{}'.format(job + 1, machine + 1),
                                                                  StartTime=0, LoadTime=loadtime, )
    # 加工流程记录表
    load_time_tables = []
    for num, job in enumerate(n):
        for machine in range(machines + 1):
            if num == 0 and machine == 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = 0
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
            elif num == 0 and machine > 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = locals()['c{}_{}'.format(job, machine - 1)].EndTime
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
            elif num > 0 and machine == 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = locals()[
                    'c{}_{}'.format(n[num - 1], machine)].EndTime
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])

            elif num > 0 and machine > 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = max(
                    locals()['c{}_{}'.format(n[num - 1], machine)].EndTime,
                    locals()['c{}_{}'.format(job, machine - 1)].EndTime)
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
    return load_time_tables, load_time_tables[-1][-1][-1]


def fitness(n):
    return 1 / (c_max(n)[1])


# 定义节点类state为当前解向量，封装当前解的排列方式，加工时间状况，最大加工时间以及适应度
class node:
    def __init__(self, state):
        self.state = state
        self.load_table = c_max(state)[0]
        self.makespan = c_max(state)[1]
        self.fitness = fitness(state)


# PMX两点交叉函数
def two_points_cross(a1, a2):
    # 不改变原始数据进行操作
    a1_1 = copy.deepcopy(a1)
    a2_1 = copy.deepcopy(a2)
    # 交叉位置,point1<point2
    point1 = random.randint(0, len(a1_1))
    point2 = random.randint(0., len(a1_1))
    while point1 > point2 or point1 == point2:
        point1 = random.randint(0, len(a1_1))
        point2 = random.randint(0., len(a1_1))
    # 记录交叉项
    fragment1 = a1[point1:point2]
    fragment2 = a2[point1:point2]
    # 交叉
    a1_1[point1:point2], a2_1[point1:point2] = a2_1[point1:point2], a1_1[point1:point2]
    # 定义容器
    a1_2 = []  # 储存修正后的head
    a2_2 = []
    a1_3 = []  # 修正后的tail
    a2_3 = []
    # 子代1头部修正
    for i in a1_1[:point1]:
        while i in fragment2:
            i = fragment1[fragment2.index(i)]
        a1_2.append(i)
    # 子代2尾部修正
    for i in a1_1[point2:]:
        while i in fragment2:
            i = fragment1[fragment2.index(i)]
        a1_3.append(i)
    # 子代2头部修订
    for i in a2_1[:point1]:
        while i in fragment1:
            i = fragment2[fragment1.index(i)]
        a2_2.append(i)
    # 子代2尾部修订
    for i in a2_1[point2:]:
        while i in fragment1:
            i = fragment2[fragment1.index(i)]
        a2_3.append(i)

    child1 = a1_2 + fragment2 + a1_3
    child2 = a2_2 + fragment1 + a2_3
    # print('修正后的子代为:\n{}\n{}'.format(child1, child2))
    return child1, child2


######变异函数######

# 交换变异
def gene_exchange(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2 or point1 > point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    n[point1], n[point2] = n[point2], n[point1]
    return n


# 插入变异
def gene_insertion(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    x = n.pop(point1)
    n.insert(point2, x)
    return n


# 局部逆序变异
def gene_reverse(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2 or point1 > point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    ls_res = n[point1:point2]
    ls_res.reverse()
    l1 = n[:point1]
    l2 = n[point2:]
    n_res_end = l1 + ls_res + l2
    return n_res_end


solution_list = []  # 存放noda解结点类
for i in population:
    locals()['solution{}'.format(population.index(i))] = node(i)
    solution_list.append(locals()['solution{}'.format(population.index(i))])
# 循环开始
start = datetime.datetime.now()
for i in range(iters):
    if i % 10 == 0:
        print('第{}次进化后的最优加工时间为{}'.format(i, solution_list[0].makespan))
    pops = [i.state for i in solution_list]
    pop_children1 = pops[1::2]  # 偶数解
    pop_children2 = pops[::2]  # 奇数解
    # PMX两点交叉变异
    for i in range(len(pop_children1)):
        pop_children1[i], pop_children2[i] = two_points_cross(pop_children1[i], pop_children2[i])
    # 交叉后的子种群
    cross_population = pop_children1 + pop_children2
    # 变异
    for i in cross_population:
        mutation_rate = random.random()
        if mutation_rate > variation_rate:
            target = random.choice(target_points)
            if target == 1:
                cross_population[cross_population.index(i)] = gene_exchange(i)
            elif target == 2:
                cross_population[cross_population.index(i)] = gene_insertion(i)
            else:
                cross_population[cross_population.index(i)] = gene_reverse(i)
    # 选择
    cross_solution = [node(i) for i in cross_population]
    solution_list = solution_list + cross_solution
    solution_list.sort(key=lambda x: x.makespan)
    del solution_list[population_num:]
print('进化完成，最终最优加工时间为：', solution_list[0].makespan)
end = datetime.datetime.now()
print('耗时{}'.format(end - start))
# 绘制甘特图
colors = ['pink', 'cyan', 'violet', 'moccasin', 'lightgreen']  # 甘特图颜色
for i in solution_list[0].load_table:
    print(i)
    plt.barh(y=i[0][-1], left=i[1][0], width=i[1][-1] - i[1][0], height=0.5, color=colors[eval(i[0][1]) - 1],
             label='job{}'.format(i[0][1]))
plt.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文标签
plt.rcParams['font.serif'] = ['KaiTi']
plt.rcParams['axes.unicode_minus'] = False
plt.title('jsp最优调度甘特图')
plt.xlabel('加工时间')
plt.ylabel('加工机器')
handles, labels = plt.gca().get_legend_handles_labels()  # 标签去重
by_label = OrderedDict(zip(labels, handles))
plt.legend(by_label.values(), by_label.keys())
plt.show()

以下为新码：

import matplotlib.pyplot as plt
from collections import OrderedDict
import random
import copy
import datetime
import numpy as np
import re

jobs = 25  # 工件数
machines = 10  # 机器数
population_num = 10  # 种群规模
population = []  # 初始种群
variation_rate = 0.8  # 变异率
iters = 50  # 进化次数
target_points = [1, 2, 3]  # 变异靶点

# 初始化一个种群
for i in range(population_num):
    population.append(random.sample(range(1, jobs + 1), jobs))


'''time_table = [[31, 41, 25, 30],  # 加工时间表,工件为行，机器为列
              [19, 55, 3, 34],
              [23, 42, 27, 6],
              [13, 22, 14, 13],
              [33, 5, 57, 19]]'''
time_table = np.random.randint(1, 100, (jobs, machines))  # 加工时间表，10*5
# 产生随机解
random.seed(0)


# 定义工作节点类 name为Cij:第i个工件在第j个机器上加工，StartTime为开始时间，LoadTime为加工时间，EndTime为加工结束时间
class Cij:
    def __init__(self, name, StartTime, LoadTime):
        self.name = name
        self.StartTime = StartTime
        self.LoadTime = LoadTime
        self.EndTime = StartTime + LoadTime



# 定义最大流程时间函数
def c_max(n):
    # 循环赋值函数，将工件数，机器数与加工时间进行绑定
    for job, i in enumerate(time_table):
        for machine, loadtime in enumerate(i):
            locals()['c{}_{}'.format(job + 1, machine + 1)] = Cij(name='c{}_{}'.format(job + 1, machine + 1),
                                                                  StartTime=0, LoadTime=loadtime, )
    # 加工流程记录表
    load_time_tables = []
    for num, job in enumerate(n):
        for machine in range(machines + 1):
            if num == 0 and machine == 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = 0
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
            elif num == 0 and machine > 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = locals()['c{}_{}'.format(job, machine - 1)].EndTime
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
            elif num > 0 and machine == 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = locals()[
                    'c{}_{}'.format(n[num - 1], machine)].EndTime
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])

            elif num > 0 and machine > 1:
                locals()['c{}_{}'.format(job, machine)].StartTime = max(
                    locals()['c{}_{}'.format(n[num - 1], machine)].EndTime,
                    locals()['c{}_{}'.format(job, machine - 1)].EndTime)
                locals()['c{}_{}'.format(job, machine)].EndTime = locals()['c{}_{}'.format(job, machine)].StartTime + \
                                                                  locals()['c{}_{}'.format(job, machine)].LoadTime
                load_time_tables.append([locals()['c{}_{}'.format(job, machine)].name, [
                    locals()['c{}_{}'.format(job, machine)].StartTime,
                    locals()['c{}_{}'.format(job, machine)].EndTime]])
    return load_time_tables, load_time_tables[-1][-1][-1]


def fitness(n):
    return 1 / (c_max(n)[1])


# 定义节点类state为当前解向量，封装当前解的排列方式，加工时间状况，最大加工时间以及适应度
class node:
    def __init__(self, state):
        self.state = state
        self.load_table = c_max(state)[0]
        self.makespan = c_max(state)[1]
        self.fitness = fitness(state)


# PMX两点交叉函数
def two_points_cross(a1, a2):
    # 不改变原始数据进行操作
    a1_1 = copy.deepcopy(a1)
    a2_1 = copy.deepcopy(a2)
    # 交叉位置,point1<point2
    point1 = random.randint(0, len(a1_1))
    point2 = random.randint(0., len(a1_1))
    while point1 > point2 or point1 == point2:
        point1 = random.randint(0, len(a1_1))
        point2 = random.randint(0., len(a1_1))
    # 记录交叉项
    fragment1 = a1[point1:point2]
    fragment2 = a2[point1:point2]
    # 交叉
    a1_1[point1:point2], a2_1[point1:point2] = a2_1[point1:point2], a1_1[point1:point2]
    # 定义容器
    a1_2 = []  # 储存修正后的head
    a2_2 = []
    a1_3 = []  # 修正后的tail
    a2_3 = []
    # 子代1头部修正
    for i in a1_1[:point1]:
        while i in fragment2:
            i = fragment1[fragment2.index(i)]
        a1_2.append(i)
    # 子代2尾部修正
    for i in a1_1[point2:]:
        while i in fragment2:
            i = fragment1[fragment2.index(i)]
        a1_3.append(i)
    # 子代2头部修订
    for i in a2_1[:point1]:
        while i in fragment1:
            i = fragment2[fragment1.index(i)]
        a2_2.append(i)
    # 子代2尾部修订
    for i in a2_1[point2:]:
        while i in fragment1:
            i = fragment2[fragment1.index(i)]
        a2_3.append(i)

    child1 = a1_2 + fragment2 + a1_3
    child2 = a2_2 + fragment1 + a2_3
    # print('修正后的子代为:\n{}\n{}'.format(child1, child2))
    return child1, child2


######变异函数######

# 交换变异
def gene_exchange(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2 or point1 > point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    n[point1], n[point2] = n[point2], n[point1]
    return n


# 插入变异
def gene_insertion(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    x = n.pop(point1)
    n.insert(point2, x)
    return n


# 局部逆序变异
def gene_reverse(n):
    point1 = random.randint(0, len(n) - 1)
    point2 = random.randint(0, len(n) - 1)
    while point1 == point2 or point1 > point2:
        point1 = random.randint(0, len(n) - 1)
        point2 = random.randint(0, len(n) - 1)
    ls_res = n[point1:point2]
    ls_res.reverse()
    l1 = n[:point1]
    l2 = n[point2:]
    n_res_end = l1 + ls_res + l2
    return n_res_end


solution_list = []  # 存放noda解结点类
for i in population:
    locals()['solution{}'.format(population.index(i))] = node(i)
    solution_list.append(locals()['solution{}'.format(population.index(i))])
# 循环开始
start = datetime.datetime.now()
for i in range(iters):
    if i % 10 == 0:
        print('第{}次进化后的最优加工时间为{}'.format(i, solution_list[0].makespan))
    pops = [i.state for i in solution_list]
    pop_children1 = pops[1::2]  # 偶数解
    pop_children2 = pops[::2]  # 奇数解
    # PMX两点交叉变异
    for i in range(len(pop_children1)):
        pop_children1[i], pop_children2[i] = two_points_cross(pop_children1[i], pop_children2[i])
    # 交叉后的子种群
    cross_population = pop_children1 + pop_children2
    # 变异
    for i in cross_population:
        mutation_rate = random.random()
        if mutation_rate > variation_rate:
            target = random.choice(target_points)
            if target == 1:
                cross_population[cross_population.index(i)] = gene_exchange(i)
            elif target == 2:
                cross_population[cross_population.index(i)] = gene_insertion(i)
            else:
                cross_population[cross_population.index(i)] = gene_reverse(i)
    # 选择
    cross_solution = [node(i) for i in cross_population]
    solution_list = solution_list + cross_solution
    solution_list.sort(key=lambda x: x.makespan)
    del solution_list[population_num:]
print('进化完成，最终最优加工时间为：', solution_list[0].makespan)
end = datetime.datetime.now()
print('耗时{}'.format(end - start))
# 绘制甘特图
def color():# 甘特图颜色生成函数
    color_ls=['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']
    col=''
    for i in range(6):
        col+=random.choice(color_ls)
    return '#'+col
colors = [color() for i in range(jobs)]# 甘特图颜色列表
for i in solution_list[0].load_table:
    print(i)
    y=eval(re.findall('_(\d+)',i[0])[0])#正则表达式匹配工件数
    label=re.findall(r'(\d*?)_',i[0])[0]#正则表达式匹配机器数
    plt.barh(y=y, left=i[1][0], width=i[1][-1] - i[1][0], height=0.5, color=colors[eval(label) - 1],
             label=f'job{label}')
plt.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文标签
plt.rcParams['font.serif'] = ['KaiTi']
plt.rcParams['axes.unicode_minus'] = False
plt.title('jsp最优调度甘特图')
plt.xlabel('加工时间')
plt.ylabel('加工机器')
handles, labels = plt.gca().get_legend_handles_labels()  # 标签去重
by_label = OrderedDict(zip(labels, handles))
plt.legend(by_label.values(), by_label.keys())
plt.show()

再次感谢小谭同学！

Biggoose1125
关注
  • 17
    点赞
  • 踩
  • 95
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
【车间调度】遗传算法求解柔性作业车间调度问题
weixin_51656605的博客
01-29 7576
本系列为自己学习调度相关知识的记录，如有误请指出，也欢迎调度方向的小伙伴加我好友共同交流。 FJSP的染色体编码 染色体编码是将所研究的问题的解用染色体的形式来表达的，这是遗传算法的关键。编码的目的是为了实现交叉、变异等类似于生物界的遗传操作。必须考虑染色体的合法性、可行性、有效性，以及对问题解空间表达的完全性。良好的编码方式可以在后续遗传操作中易产生可行解，提高执行效率；否则，经过遗传操作会产生不可行解，需要一定的修补措施，这样就降低了执行效率。染色体编码对求解速度、计算精度等有着直接的关系，对算法具.
用python实现简单的遗传算法
热门推荐
czrzchao的博客
08-25 4万+
今天整理之前写的代码，发现在做数模期间写的用python实现的遗传算法，感觉还是挺有意思的，就拿出来分享一下。 首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。 以目标式子 y = 10 * sin(5x) + 7 * cos(4x)为例，计算其最大值 首先是初始化，包括具
【背包问题】基于NSGAII实现多目标背包问题求解附matlab代码
qq_59747472的博客
03-04 969
多目标背包问题（Multi-Objective Knapsack Problem，MOKP）是背包问题的多目标版本，其目标是在满足背包容量限制的情况下，从一组物品中选择一个子集，以最大化多个目标函数。
遗传算法求解混合流水车间调度问题-Python版，号主自己写的
03-02
遗传算法求解混合流水车间调度问题
遗传算法求解车间调度问题(附python代码)
最新发布
weixin_38442390的博客
06-14 936
车间调度问题（Job Shop Scheduling Problem, JSSP）是一类经典的组合优化问题，它在制造业和生产管理中有着广泛的应用。JSSP 的目标是对车间中的一系列作业进行排程，以使得作业在不同机器上的加工顺序是最优的，达到某种特定的优化目标，比如最小化总的作业完成时间（即使得总完工时间尽可能短），或者最小化延迟时间、最大化产量等。车间调度问题通常被描述为一系列作业集合 J 和一系列机器集合 M，每个作业由一系列操作组成，每个操作需要在特定的机器上加工一定时间。
遗传算法解决作业调用问题（classic job shop scheduling problem）
狂奔的蜗牛
01-14 2万+
车间作业调度问题描述 JSP问题是一个包含n个工件和m台机器的调度问题，其常用的数学描述如下： Cmax ≥ tij + pij for all (i,j) ∈ N tkj ≥ tij + pij for all (i,j)  (k,j) ∈ A tij ≥ tik + pik for all (i,j) and (i,k) ∈ N tik ≥ tij +
利用遗传算法解决旅行商问题（GA-TSP）—— Python代码实现
weixin_46357639的博客
07-28 2486
利用Python编写GA-TSP算法，通过遗传算法对旅行商问题进行求解，并以29个城市为例的TSP问题进行求解
基于遗传算法求解车间调度python源码
05-20
作业车间调度问题（Job Shop Scheduling, JSP）是最经典的几个NP-hard问题之一。其应用领域极其广泛，涉及航母调度，机场飞机调度，港口码头货船调度，汽车加工流水线等。 JSP问题描述：一个加工系统有M台机器，要求...
可用遗传算法模拟退火求解作业车间调度问题
07-13
在Python中实现遗传算法和模拟退火来解决JSP，首先需要对问题进行建模，定义染色体（代表一种调度方案）、适应度函数（评价方案的质量，如总完工时间）、以及遗传算子（如选择、交叉和变异）。对于遗传算法，可能的...
GA(遗传算法)求解JSP(车间调度问题)python项目源码+项目说明.zip
12-24
GA(遗传算法)求解JSP(车间调度问题)python项目源码+项目说明.zip GA（遗传算法）求解JSP（车间调度问题） 工件在机器间流转：本机器上加工的工件要流转到下一个机器，本机器才能开始加工下一个工件。（与原作的时间...
课设新项目基于GA(遗传算法)求解JSP(车间调度问题)python源码及使用说明.zip
10-18
课设新项目基于GA(遗传算法)求解JSP(车间调度问题)python源码及使用说明.zip课设新项目基于GA(遗传算法)求解JSP(车间调度问题)python源码及使用说明.zip课设新项目基于GA(遗传算法)求解JSP(车间调度问题)python源码...
混合遗传模拟退火-N5邻域求解JSP问题python实现
07-13
混合遗传模拟退火-N5邻域求解JSP问题python实现
单机调度中的遗传算法方法: 单机调度中最小化总延迟的遗传算法方法-matlab开发
05-30
此代码是论文 [Gürsel A. Süer,Xiaozhe Yang,Omar I. Alhawari,Joel Santos,“A Genetic Algorithm Approach for Minimizing Total Tardiness in Single Machine Scheduling”, International Journal of Industrial Engineering and Management (IJIEM) 的实现，卷。 3 第 3 期，2012 年，第 163-171 页]。 目标是确定将作业放置在机器上的顺序，以优化给定的评估措施。
遗传算法的车间调度问题
06-13
智能车间调度问题，利用遗传算法更好的解决车间调度问题
python对遗传算法的实现
weixin_48049326的博客
10-11 1250
遗传算法
遗传算法及python实现
qq_54543084的博客
12-18 6986
遗传算法及python实现
基于遗传算法解决柔性车间生产调度问题（附代码）
Incalos的博客
04-13 5948
本文章讲述了如何基于遗传算法解决柔性车间生产调度问题，包括编码、解码、初始化、交叉操作、变异操作、选择操作等，并且提供了相应的编程步骤，并完善了甘特图绘制以及遗传算法优化过程的可视化。同时，提供了项目的 Python 代码以及相应的使用文档。
python 遗传算法 车辆调度
L123456qqw的博客
10-12 1121
有货场1 ，要送货到地点2 ，3，…，1 5 ，每个地点需要送货的质量为gi＝{ 0，1.2，3.2，2.5，0 .7，1.4，0.5，3.6，5.1，1.5，2.6，1.3，2.4，2.3，0.5}，g1＝0代表货场1给货场送的货为零，货车的标记载重为10 t，染色体采用 0-1编码，交叉概率为0.7，变异概率为0.03，种群规模为 2 0，迭代次数为100 次，算出最优方案为 x。
优化算法|遗传算法求解作业车间调度问题（Python）
eternal1995的博客
01-24 2265
之前的推文都是介绍车辆路径问题以及装箱问题，我们以这篇为引子，开始作业车间调度问题及其求解算法学习之路。本推文将展示遗传算法求解作业车间调度问题的求解思路以及python代码。排产调度（scheduling）是生产制造业和服务业的重要决策对象，旨在目标明确的前提下，合理地将资源分配给任务。作业车间调度问题（Job-Shop Scheduling Problem，简称 JSSP）就是典型的排产调度优化问题，也正是这篇推文的主题。作业车间调度问题可以描述为：一个车间中有mmm。
遗传算法解决车辆调度问题python
05-12
遗传算法是一种基于自然界遗传学理论...总而言之，车辆调度问题是一个复杂的组合优化问题，而遗传算法可以很好的解决这一问题，Python编程语言的使用也极大地方便了程序编写的过程，能够更快速高效的实现结果达到最优。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值