FlowShop问题python实现

最新推荐文章于 2024-06-15 16:12:58 发布
最新推荐文章于 2024-06-15 16:12:58 发布
阅读量1k 收藏 10
点赞数 3
分类专栏： 作业调度 FlowJob 文章标签： 人工智能 算法 python
原文链接：https://github.com/wurmen/Genetic-Algorithm-for-Job-Shop-Scheduling-and-NSGA-II
版权

Solving flow shop scheduling problem with genetic algorithm

​ 前言

这里要来说明如何运用GA求解flow shop 问题，以下将先对flow shop 问题做个简介，说明一下编码原则，接着对每个程序块进行说明。

什么是 flow shop 问题?

简单来说，flow shop 问题就是有 n 个工件以及 m 台机器，每个工件在机器上的加工顺序都一样，如下图所示，工件1先进入机器1加工，再到机器2加工，而工件2跟随着工件1的脚步，按照同样的机器顺序加工，其他工件以此类推。

 因此假设现在有3个工件2台机器，每个工件在每台机器上的加工时间，如左下图所示，工件的加工顺序为先到机器A加工再到机器B上加工，假设得到的排程结果为: Job 1->Job 2->Job 3，因此可得到如右下图的甘特图

​ 问题描述

本范例是一个具有20个工件的flow shop 问题，排程目标最小化的加权延迟 (Total weighted tardiness) ，工件信息如下图所示

排程目标

由本文范例的目标为最小化的加权延迟 (Total weighted tardiness)，因此除了必须知道每个工件在每台机器上的加工时间外，还必须知道每个工件的到期日及权重。

c_i工件 i 的完工时间 (Completion time)​、：工件 i 的到期日 (Due date)​、：工件 i 的延迟时间(Tardiness time)、工件 i 的权重(Weight)

首先计算每个工件的延迟时间，如果提早做完，则延迟时间为0

T_i=\max \left\{ 0,c_i-d_i \right\}

计算所有工件的加权延迟时间总和，从公式我们可以知道，当工件的权重越大，我们要尽可能的准时完成那些权重较大的工件，不然会导致总加权延迟时间太大，对于这样的排程问题来说，这就不是一个好的排程

\left( \underset{i=1}{\overset{n}{\varSigma}}w_iT_i \right)

另外，这里提供了另一个版本的 flow shop 程序，跟本文主要的差別在于求解目标的不同，另一版本的目标为最小化总闲置时间 (Idle time)，也就是上面范例甘特图中，灰色区域的部分，期望排出来的排程，可以尽可能减少总机器的闲置时间。

编码原则

这里的编码方式很简单，每個染色体就表示一组排程结果，因此，如果 flow shop 的问题中，共有五个工件要排，则每个染色体就由五个基因所組成，每个基因即代表某个工件，会通过list 來储存每个染色体，

如下面所示：

chromosome 1 => [0,1,2,3,4]

chromosome 2 => [1,2,0,3,4]

chromosome 3 => [4,2,0,1,3]

........

程序说明

这里主要针对程序中重要的步骤来说明，有些细节未放入，如有需要请参考完整程序码或范例代码

导入包

# importing required modules
import numpy as np
import time
import copy

初始设定

此处主要包含数据或是资料给定，以及一些参数上的设定

''' ================= initialization setting ======================'''
num_job=20 # 工件数量

p=[10,10,13,4,9,4,8,15,7,1,9,3,15,9,11,6,5,14,18,3]#每个工件的完工时间
d=[50,38,49,12,20,105,73,45,6,64,15,6,92,43,78,21,15,50,150,99]#每个工件的到期时间
w=[10,5,1,5,10,1,5,10,5,1,5,10,10,5,1,10,5,5,1,5]#每个工作的到期日
# raw_input is used in python 2
population_size=int(input('Please input the size of population: ') or 30)#种群规模，默认为30
crossover_rate=float(input('Please input the size of Crossover Rate: ') or 0.8) #交叉概率，默认为0.8
mutation_rate=float(input('Please input the size of Mutation Rate: ') or 0.1) 
#变异概率，默认为0.1
mutation_selection_rate=float(input('Please input the mutation selection rate: ') or 0.5)#变异选择概率，默认为0.5
num_mutation_jobs=round(num_job*mutation_selection_rate)#变异数量
num_iteration=int(input('Please input number of iteration: ') or 2000) 
# 最大迭代次数，默认为2000


start_time = time.time()

​ 种群初始化

根据上述所设定的族群大小，通过随机的方式，产生初始族群

'''----- generate initial population -----'''
Tbest = 999999999999999  # 最小的总加权延迟时间
best_list, best_obj = [], []
population_list = []
makespan_record = []
for i in range(population_size):
    nxm_random_num = list(np.random.permutation(num_job))  # 对0到num_job-1之间的序列进行随机排序
    population_list.append(nxm_random_num)  # 添加到population_list中
    # population_list: 30次0到num_job-1的随机排序

for n in range(num_iteration):
    Tbest_now = 99999999999  # 到目前为止最小的总加权延迟时间

​ 交插

这里的交插方式是通过指定位置的方式进行行交插，执行的步骤如下：

  1. 通过随机选择的方式，将基因数一半的位置设为固定不变，以下图例，共有六个工件进行排序，生成两个子代，在此选定2、5、6为工件顺序不变的位置。

  2. 将 Parent 1 工件不变的位置，复制到对应的 Child 2 ，接着将Child 2 与Parent 2 进行比较。

  3. 将 parent 2 与child2不重复的工件，依序填入 Child 2 剩余的位置，形成新的子代2。

  4. Child 1 的形成方式如 Child 2 所示。

 

'''-------- crossover --------'''
    parent_list = population_list[:]  # 亲本列表
    offspring_list = population_list[:]  # 子代列表
    S = list(np.random.permutation(population_size))  # 生成一个随机序列，选择亲本染色体进行交叉操作
    # 对0到population_size之间的序列进行随机排序

    for m in range(int(population_size / 2)):
        crossover_prob = np.random.rand()
        if crossover_rate >= crossover_prob:
            parent_1 = population_list[S[2 * m]][:]  # 亲本1为population_list的第S[2*m]个
            parent_2 = population_list[S[2 * m + 1]][:]  # 亲本2为population_list的第S[2*m+1]个
            child_1 = ['na' for i in range(num_job)]  # 初始化子代1
            child_2 = ['na' for i in range(num_job)]  # 初始化子代2
            fix_num = round(num_job/2)  # 工件个数的一半
            g_fix = list(np.random.choice(num_job, fix_num, replace=False))  # 从20个基因中随机选10个

            for g in range(fix_num):
                child_1[g_fix[g]] = parent_2[g_fix[g]]  # 亲本2中g_fix位的基因赋给子代1
                child_2[g_fix[g]] = parent_1[g_fix[g]]  # 亲本1中g_fix位的基因赋给子代2
            c1 = [parent_1[i] for i in range(num_job) if parent_1[i] not in child_1]  # 子代1中的空位需要的基因
            c2 = [parent_2[i] for i in range(num_job) if parent_2[i] not in child_2]  # 子代2中的空位需要的基因

            for i in range(num_job - fix_num):
                child_1[child_1.index('na')] = c1[i]  # 填补子代2中的空位需要的基因
                child_2[child_2.index('na')] = c2[i]  # 填补子代2中的空位需要的基因
            offspring_list[S[2 * m]] = child_1[:]
            offspring_list[S[2 * m + 1]] = child_2[:]

变异

此方法是通过基因位移的方式进行突变，突变方式如下:

  1. 依据 mutation selection rate 決定染色体中有多少百分比的基因要进行突变，假设每条染色体有六个基因， mutation selection rate 为0.5，则有3个基因要进行突变。

  2. 随机选定要位移的基因位，假设选定5、2、6 (在此表示该位置下的基因要进行突变)

  3. 进行基因移位，移位方式如图所示。


    '''--------mutatuon--------'''
    for m in range(len(offspring_list)):
        mutation_prob = np.random.rand()
        if mutation_rate >= mutation_prob:
            m_chg = list(np.random.choice(num_job, num_mutation_jobs, replace=False))  # 从20个基因中随机选10个变异位置
            t_value_last = offspring_list[m][m_chg[0]]  # 保存子代第一个变异位置上的值
            for i in range(num_mutation_jobs - 1):
                offspring_list[m][m_chg[i]] = offspring_list[m][m_chg[i + 1]]  # 移位

            offspring_list[m][m_chg[num_mutation_jobs - 1]] = t_value_last  # 将第一个变异位置的值移至最后一个变异位置

 

适应度计算

计算每个染色体也就是每个排程结果的总加权延迟，并将其记录，以利于进行选择时能进行比较.

  '''--------fitness value(calculate tardiness)-------------'''
    total_chromosome = parent_list[:] + offspring_list[:]  # 结合亲本和子代的染色体，形成总种群total_chromosome
    chrom_fitness, chrom_fit = [], []
    total_fitness = 0
    for i in range(population_size * 2):  # 对于每个亲本和子代染色体
        ptime = 0
        tardiness = 0
        for j in range(num_job):  # 对于每个工件
            ptime = ptime + p[total_chromosome[i][j]]  # 完工时间
            tardiness = tardiness + w[total_chromosome[i][j]] * max(ptime - d[total_chromosome[i][j]], 0)  # 总加权拖期时间
        chrom_fitness.append(1 / tardiness)
        chrom_fit.append(tardiness)
        total_fitness = total_fitness + chrom_fitness[i]

选择

这里选择轮盘赌 (Roulette wheel) 的选择机制

 '''----------selection----------'''
    pk, qk = [], []

    for i in range(population_size * 2):  # 对于每个亲本和子代染色体
        pk.append(chrom_fitness[i] / total_fitness)
    for i in range(population_size * 2):
        cumulative = 0
        for j in range(0, i + 1):
            cumulative = cumulative + pk[j]
        qk.append(cumulative)

    selection_rand = [np.random.rand() for i in range(population_size)]

    for i in range(population_size):
        if selection_rand[i] <= qk[0]:
            population_list[i][:] = total_chromosome[0][:]
            break
        else:
            for j in range(0, population_size * 2 - 1):
                if selection_rand[i] > qk[j] and selection_rand[i] <= qk[j + 1]:
                    population_list[i][:] = total_chromosome[j + 1][:]

比较

先比较每个染色体的总加权延迟 (chrom_fit) ，找到的最好解 (Tbest_now) ，接着在跟目前为止找到的最好解 (Tbest) 进行比较，一旦有一个的解比目前为止找到的解还要好，就替代 Tbest 并记录此解所得到的排程结果。

'''----------comparison----------'''
    for i in range(population_size * 2):
        if chrom_fit[i] < Tbest_now:
            Tbest_now = chrom_fit[i]
            sequence_now = total_chromosome[i][:]

    if Tbest_now <= Tbest:
        Tbest = Tbest_now
        sequence_best = sequence_now[:]

    makespan_record.append(Tbest)

    job_sequence_ptime = 0
    num_tardy = 0
    for k in range(num_job):  # 对于每个工件
        job_sequence_ptime = job_sequence_ptime + p[sequence_best[k]]
        if job_sequence_ptime > d[sequence_best[k]]:
            num_tardy = num_tardy + 1

结果

等所有迭代次数结束后，在输出的所有迭代中找到的最好排程结果 (sequence_best)、它的总加权延迟时间、每个工件平均加权延迟时间、有多少工件延迟以及程序的执行时间

'''----------result----------'''
print("optimeal sequence", sequence_best)
print("optimeal value:%f" % Tbest)
print("average tardiness:%f" % (Tbest / num_job))
print("number of tardy:%d" % num_tardy)
print('the elapsed time:%s' % (time.time() - start_time))

import matplotlib.pyplot as plt
%matplotlib inline
plt.plot([i for i in range(len(makespan_record))],makespan_record,'b')
plt.ylabel('makespan',fontsize=15)
plt.xlabel('generation',fontsize=15)
plt.show()
Please input the size of population: 30
Please input the size of Crossover Rate: 0.8
Please input the size of Mutation Rate: 0.1
Please input the mutation selection rate: 0.5
Please input number of iteration: 2000
optimeal sequence [11, 4, 15, 16, 3, 0, 7, 19, 9, 10, 6, 12, 13, 1, 8, 17, 2, 18, 5, 14]
optimeal value:2235.000000
average tardiness:111.750000
number of tardy:12
the elapsed time:35.346625566482544

 

甘特图

'''--------plot gantt chart-------'''
import pandas as pd
import plotly.plotly as py
import plotly.figure_factory as ff
import plotly.offline as offline
import datetime

j_keys=[j for j in range(num_job)]
j_count={key:0 for key in j_keys}
m_count=0
j_record={}
for i in sequence_best:
   gen_t=int(p[i])
   j_count[i]=j_count[i]+gen_t
   m_count=m_count+gen_t
   
   if m_count<j_count[i]:
       m_count=j_count[i]
   elif m_count>j_count[i]:
       j_count[i]=m_count
   start_time=str(datetime.timedelta(seconds=j_count[i]-p[i])) # convert seconds to hours, minutes and seconds

   end_time=str(datetime.timedelta(seconds=j_count[i]))
   j_record[i]=[start_time,end_time]
       

df=[]
for j in j_keys:
   df.append(dict(Task='Machine', Start='2018-07-14 %s'%(str(j_record[j][0])), Finish='2018-07-14 %s'%(str(j_record[j][1])),Resource='Job %s'%(j+1)))

# colors={}
# for i in j_keys:
#     colors['Job %s'%(i+1)]='rgb(%s,%s,%s)'%(255/(i+1)+0*i,5+12*i,50+10*i)

fig = ff.create_gantt(df, colors=['#008B00','#FF8C00','#E3CF57','#0000CD','#7AC5CD','#ED9121','#76EE00','#6495ED','#008B8B','#A9A9A9','#A2CD5A','#9A32CD','#8FBC8F','#EEC900','#EEE685','#CDC1C5','#9AC0CD','#EEA2AD','#00FA9A','#CDB38B'], index_col='Resource', show_colorbar=True, group_tasks=True, showgrid_x=True)
py.iplot(fig, filename='GA_flow_shop_scheduling_tardyjob', world_readable=True)

 

Reference

  • António Ferrolho and Manuel Crisóstomo. “Single Machine Total Weighted Tardiness Problem with Genetic Algorithms”

  • N. Liu, Mohamed A. Abdelrahman, and Snni Ramaswamy. “A Genetic Algorithm for the Single Machine Total Weighted Tardiness Problem”

是凌然啊
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
基于GA的FSP流水车间调度问题python实现（带NEH实现）（留言可获得完整代码
qq_39589163的博客
02-28 655
附带详细的理论+代码详解视频，见某站lvqaq的数学建模。car01数据集甘特图。
The_Flow_Shop_Scheduling_Problem:用遗传算法解决流水车间调度问题
05-02
The_Flow_Shop_Scheduling_Problem 用遗传算法解决流水车间调度问题 在本作业中，您将解决文本文件“ fssp-data-3instances.txt”中给出的三个数据集的流水车间调度问题。 这些数据集中的作业数和机器数不同。 目标功能是最小化制造期，即完成由最后一台机器处理的最后一项作业。 我想提醒您，在提交作业时应考虑以下几点。 它由两部分组成：您的代码和报告。 首先，您的代码必须清晰易懂，并且应在代码中使用注释行定义以下内容：变量名称及其用途，函数名称及其用途。 例如，您应该编写“ X是赋值变量”，“ CompObj计算目标值”等。或者，您可以使用不言自明的函数名称，例如ApplyMove。
遗传算法在生产调度中的应用
最新发布
earthbingshi的博客
06-15 1137
遗传算法（Genetic Algorithm, GA）在生产调度中具有广泛的应用，因其强大的全局搜索能力和适应性，能够有效解决各种复杂的调度问题。
Job-shop和Flow-shop区别
梓莘
10-08 4667
flow shop： n个工件在m台机器上加工，每个工件都要在m台机器上加工一次，并且每台机器上的工序，即加工顺序都是一样的。如四个工件在第一台机器加工顺序为2134，那么在剩余m-1台机器上的工序必须严格保持2134的顺序。因此flow shop也被称为流水作业或顺序作业。 job shop 每台机器的工序是可变的。因此job shop也被称为异序作业。同时，如果不限制工件j只能在机器m上加工一次，就变成可重入job shop。 open shop ...
遗传算法解flowshop问题
Silvester123的博客
07-11 7195
遗传算法解决flowshop问题 1.遗传算法简介 参考:https://blog.csdn.net/u010451580/article/details/51178225 百度百科：遗传算法 总结遗传算法过程：选择 -&gt; 交叉 -&gt; 变异 -&gt; 更新 -&gt; 终止 2.flowshop问题简介 已知：有n 个工件需要在m台机器上流水加工。 工件上的约束...
基础NEH算法 在 流水车间调度问题（FlowShop)问题 的应用（C++）
Liablbility的博客
06-08 5960
基础流水车间调度的NEH实现（C++） #include <iostream>#include <stdio.h>#include <math.h>#include <random>#include <algorithm>using namespace std;int times[105][105];void InsSort(int Order[],int insLoc,int Loc)//插入排序 {
面对Flow-shop调度问题如何优化？可用MindOpt来决策
MindOpt_003的博客
02-24 534
mindopt案例——Flow shop-流线型调度问题
多机Flowshop调度问题
07-02
多机Flowshop 加权完成时间调度问题, 使用单机松弛和概率分析方法
混合Flowshop调度问题
07-02
采用多种群并行自适应遗传算法解决混合Flowshop调度问题
FlowShop.pdf
08-15
We consider the permutation flow shop scheduling problem, with release dates and due dates. There are n machines and m jobs, and each job contains exactly n operations.
FlowShop 网上花店
05-19
"FlowShop 网上花店"是一个基于ASP.Net技术构建的电子商务平台，主要用于在线销售花卉产品。这个系统集成了完善的前后台功能，为用户提供了一流的购物流程体验。让我们详细了解一下其核心组成部分和涉及的技术知识。...
流水车间调度问题代码（flowshop）
01-30
流水车间调度问题一种方法的源代码，有N个工件M台机器，每个阶段至少有一台机器并且至少有一阶段有不少于一台机器。
flow shop problem GA算法
04-12
flow shop problem GA算法 详细代码标注
flowshop测试算例
03-08
这个是基于matlab的流水调度问题的标准测试算例，在用算法求解flowshop问题时需要通过对这些算例求解效果来验证算法的有效性。
双层编码的遗传算法优化Flowshop调度程序（JSP也可以）
04-10
网上很多不完整的，不能用的，修改半天还是出错是因为发布的人改了几句。本人结果修改，整理出的这个程序是完整的、运行通过，分享给大家~！节省时间，共同进步！
JOB-SHOP问题算例
03-19
job shop scheduling problem 算例，包含FT06\10\20问题，LA01-06问题等
MES系统的三种车间类型：flow shop、job shop、open shop
热门推荐
先学再说
10-11 1万+
flow shop：如果每个作业需要在每个处理机上加工，而且每个作业的工序也相同，即在处理机上加工的顺序相同，则这种多类机的环境称为同顺序作业或流水作业。 job shop：如果每个作业需要在每个处理机上加工，每个作业有自己的加工顺序，称之为异顺序作业。 open shop：如果每个作业需要在每个处理机上加工，每个作业可按任意顺序加工，称之为自由顺序作业或开放作业。
3.9 流水作业调度问题
tang7mj的博客
06-04 4786
流水作业调度问题是动态规划中的一个经典问题，它涉及将一系列作业分配给多个工作站以最小化总完成时间。该问题的目标是确定作业的最优调度顺序，以使得所有作业的完成时间最小。下面是该问题的一般描述和解决步骤：1. 问题描述： - 给定n个作业和m个工作站，每个作业有一个处理时间(ti)和一个工作站的要求（wj）。 - 每个工作站一次只能处理一个作业，且每个作业只能分配给一个工作站。 - 每个工作站在完成作业后会空闲，可以接受下一个作业。2. 动态规划解决步骤： - 定义状态：首先定义问题的状
flow-shop调度问题、job shop调度问题、open shop调度问题 是什么 区别
软件工程小施同学 的专栏
10-02 2646
flow shop： 如果每个作业需要在每个处理机上加工，而且每个作业的工序也相同，即在处理机上加工的顺序相同，则这种多类机的环境称为同顺序作业或流水作业。 flow shop问题，n个工件在m台机器上加工，每个工件都要在m台机器上加工一次，并且每台机器上的工序，即加工顺序都是一样的。如四个工件在第一台机器加工顺序为2134，那么在剩余m-1台机器上的工序必须严格保持2134的顺序。因此flow shop也被称为流水作业或顺序作业 job shop： 如果每个作业需要在每个处理机上加工，.
flowshop 甘特图
12-08
flowshop 甘特图是一种用于规划和管理流水线加工过程的图表工具。flowshop 是一种生产方式，它要求产品在多个加工工序上按照特定的顺序进行加工。而甘特图则可以呈现出这些工序的时间安排和进度。 在甘特图中，我们通常使用横轴表示时间，纵轴表示工序。每个工序会按照指定的顺序排列在甘特图的纵轴上。而每个工序在时间轴上则会被表示为一个条形块，条形块的长度会反映该工序所需要的时间。通过查看甘特图，我们可以清楚地了解到每个工序的时间安排，以及整个流水线加工过程的进度。 甘特图的使用可以帮助我们更好地规划和控制流水线加工过程。我们可以根据甘特图上的时间安排，提前预测每个工序的完成时间。这可以帮助我们及时调整生产计划，确保整个流水线的顺利运行。同时，甘特图还可以帮助我们识别出流程中的瓶颈，找到优化的空间，提高制造效率。 总之，flowshop 甘特图是一种简单而直观的工具，用于可视化流水线加工过程的时间安排和进度。它可以帮助我们更好地规划和控制流程，提高生产效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值