柔性车间作业调度（Flexible Job-shop Scheduling Problem, FJSP）

已于 2023-09-14 17:05:48 修改
阅读量7.7k 收藏 97
点赞数 19
分类专栏： 车间调度 文章标签： 笔记
于 2023-08-13 18:40:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46225503/article/details/132246053
版权

柔性车间作业调度（Flexible Job-shop Scheduling Problem, FJSP）

1. 前言

1.1 车间作业调度问题描述

调度问题的一般性定义为：在一定的约束条件下，把有限的资源在时间上分配给若干个任务，以满足或优化一个或多个性能指标。

在这里插入图片描述

在这里插入图片描述

n n n 个工件 [ J 1 , J 2 , . . . , J n ] [J_1,J_2,...,J_n] [J1​,J2​,...,Jn​] 要在 m m m 台机器 [ M 1 , M 2 , . . . , M m ] [M_1,M_2,...,M_m] [M1​,M2​,...,Mm​] 上加工。每个工件包含一道或多道工序，工序顺序是预先确定的，每道工序可以在多台不同加工机器上进行加工，工序的加工时间随加工机器的不同而不同。
调度目标是为每道工序选择最合适的机器、确定每台机器上各个工序的最佳加工顺序以及开工时间，使整个系统的某些性能指标达到最优。

在这里插入图片描述

1.2 车间调度问题的分类

  • 单机调度问题 加工系统中只有一台机床，代加工的工件有且仅有一道工序，所有工件都在该机床上进行加工。
  • 并行机调度问题 加工系统中有多个完全相同的机床，每个工件只有一道工序，工件可以在任意一台机床上加工。
  • 开放车间调度问题 每个工件的工序之间的加工顺序是任意的。工件的加工路线可以在任何一道工序开始，在任何一道工序结束。工件的加工没有特定的技术路线约束，各个工件之间没有先后关系约束。
  • 流水车间调度 加工系统中有一组功能不同的机床，待加工的工件包含多道工序，每道工序在一台机床上加工，所有工件的加工路线相同，每个工件的工序之间有先后顺序约束。
  • 作业车间调度问题 加工系统中有一组功能不同的机床，待加工的工件包含多道工序，每道工序在一台机床上加工，工件的加工路线互不相同，每个工件的工序之间有先后顺序约束。

柔性作业车间调度问题也是本文介绍的重点内容。

柔性，指的是供应链根据需求的变化，快速做出反应的能力。

在这里插入图片描述

1.3 调度问题的解决算法

在这里插入图片描述

2. 柔性作业车间调度问题(FJSP)描述

柔性作业车间调度问题包含两个子问题：

  • 确定各工件的加工机器机器选择子问题
  • 确定各个机器上的加工先后顺序工序排序子问题

柔性作业车间调度问题根据资源选择条件的不同，柔性程度可以分为完全柔性作业车间调度问题（T-FJSP,工序可选择的加工机器为所有候选机器）和部分柔性作业车间调度问题（P-FJSP，工序可选择的加工机器为部分候选机器)。具体示例如下：
在这里插入图片描述

2.1 问题背景

柔性作业车间调度问题的描述如下：

一个加工系统有 m m m 台机器，要加工 n n n 种工件。每个工件包含一道或多道工序，工件的工序顺序是预先确定的；每道工序可以在多台不同的机床上加工，工序的加工时间随机床的性能不同而变化。调度目标是为每道工序选择最合适的机器、确定每台机器上各工件工序的最佳加工顺序及开工时间，使系统的某些性能指标达到最优。

2.2 问题假设

  1. 同一台机器同一时刻只能加工一个工件；
  2. 同一工件的同一道工序在同一时刻只能被一台机器加工；
  3. 每个工件的每道工序一旦开始加工不能中断；
  4. 不同工件之间具有相同的优先级；
  5. 不同工件的工序之间没有先后约束；
  6. 同一工件的工序之间有先后约束；
  7. 所有工件在零时刻都可以被加工。

2.3 问题模型

为了后文描述方便，定义以下符号：

符号说明
n n n工件总数
m m m机器总数
Ω \Omega Ω总的机器集
i , e i,e i,e机器序号， i , e = 1 , 2 , 3 , . . , m i,e=1,2,3,..,m i,e=1,2,3,..,m
j , k j,k j,k工件序号， j , k = 1 , 2 , 3 , . . . n j,k= 1,2,3,...n j,k=1,2,3,...n
h j h_j hj​工件 j j j 的工序总数
h , l h,l h,l工序序号， h = 1 , 2 , 3 , . . . h j h=1,2,3,...h_j h=1,2,3,...hj​
Ω j h \Omega _{jh} Ωjh​工件 j j j 的第 h h h 道工序的可选加工机器集
m j h m_{jh} mjh​工件 j j j 的第 h h h 道工序的可选加工机器数
O j h O_{jh} Ojh​工件 j j j 的第 h h h 道工序
M i j h M_{ijh} Mijh​工件 j j j 的第 h h h 道工序在机器 i i i 上加工
p i j h p_{ijh} pijh​工件 j j j 的第 h h h 道工序在机器 i i i 上的加工时间
s j h s_{jh} sjh​工件 j j j 的第 h h h 道工序加工开始时间
c j h c_{jh} cjh​工件 j j j 的第 h h h 道工序加工完成时间
L L L一个足够大的正数
d j d_{j} dj​工件 j j j 的交货期
C j C_{j} Cj​每个工件的完成时间
C max C_{\text{max}} Cmax​最大完工时间
T o T_o To​ ∑ j = 1 n h j {{\sum\limits_{j=1}^{n}h_j}} j=1∑n​hj​，所有工件工序总数

x i j h = { 1 , 如果工序 O j h 选择机器 i ； 0 , 否则； x_{ijh}=\left\{ \begin{aligned} & 1,\text{如果工序}O_{jh}\text{选择机器}i ；\\ & 0,\text{否则；} \end{aligned} \right. xijh​={​1,如果工序Ojh​选择机器i；0,否则；​

y i j h k l = { 1 , 如果 O i j h 先于 O i k l 加工； 0 , 否则； y_{ijhkl}=\left\{ \begin{aligned} & 1,\text{如果}O_{ijh}\text{先于}O_{ikl}\text{加工；} \\ & 0,\text{否则；} \end{aligned} \right. yijhkl​={​1,如果Oijh​先于Oikl​加工；0,否则；​

如果 Ω j h = Ω \Omega _{jh}=\Omega Ωjh​=Ω， ∀ j ∈ [ 1 , n ] , ∀ h ∈ [ 1 , h j ] \forall j\in [1,n],\forall h\in [1,{{h}_{j}}] ∀j∈[1,n],∀h∈[1,hj​]，则是T-FJSP；
如果 Ω j h ∈ Ω \Omega _{jh}∈\Omega Ωjh​∈Ω， ∃ j ∈ [ 1 , n ] , ∃ h ∈ [ 1 , h j ] \exists j\in [1,n],\exists h\in [1,{{h}_{j}}] ∃j∈[1,n],∃h∈[1,hj​]，则是P-FJSP；

在这里插入图片描述

2.4 模型约束

一般的FJSP受到下列约束：

s j h + x i j h × p i j h ≤ c j h . \begin{equation} s_{jh}+x_{ijh}×p_{ijh}≤c_{jh}. \end{equation} sjh​+xijh​×pijh​≤cjh​.​​
其中： i = 1 , 2 , 3 , . . , m i=1,2,3,..,m i=1,2,3,..,m； j = 1 , 2 , 3 , . . . , n j= 1,2,3,...,n j=1,2,3,...,n； h = 1 , 2 , 3 , . . . , h j h=1,2,3,...,h_j h=1,2,3,...,hj​

工件 j j j 的第 h h h 道工序加工开始时间+在机器 i i i 上的加工时间≤工序加工完成时间
在这里插入图片描述
c j h ≤ s j ( h + 1 ) . \begin{equation} c_{jh}≤s_{j(h+1)}. \end{equation} cjh​≤sj(h+1)​.​​
其中： j = 1 , 2 , 3 , . . . n j= 1,2,3,...n j=1,2,3,...n； h = 1 , 2 , 3 , . . . , h j − 1 h=1,2,3,...,h_j-1 h=1,2,3,...,hj​−1
工件 j j j 的第 h h h 道工序加工完成时间≤工件 j j j 的第 h + 1 h+1 h+1 道工序加工开始时间
在这里插入图片描述
c j h j ≤ C max . \begin{equation} c_{jh_{j}}≤C_{\text{max}}. \end{equation} cjhj​​≤Cmax​.​​
其中： j = 1 , 2 , 3 , . . . n j= 1,2,3,...n j=1,2,3,...n
工件 j j j 共有 h j h_j hj​ 道工序，工序总时间不能超过最大完工时间 C max C_\text{max} Cmax​

在这里插入图片描述
s j h + p i j h ≤ s k l + L ( 1 − y i j h k l ) . \begin{equation} s_{jh}+p_{ijh}≤s_{kl}+L(1-y_{ijhkl}). \end{equation} sjh​+pijh​≤skl​+L(1−yijhkl​).​​
其中： j = 0 , 1 , 2 , . . . n j= 0,1,2,...n j=0,1,2,...n； k = 1 , 2 , 3 , . . . n k= 1,2,3,...n k=1,2,3,...n； h = 1 , 2 , 3 , . . . , h j h=1,2,3,...,h_j h=1,2,3,...,hj​； l = 1 , 2 , 3 , . . . , h k l=1,2,3,...,h_k l=1,2,3,...,hk​； i = 1 , 2 , . . , m i=1,2,..,m i=1,2,..,m
工件 j j j 的第 h h h 道工序加工开始时间+在第 i i i机器的加工时间≤工件 k k k 的第 l l l 道工序加工开始时间+ Y Y Y

Y Y Y=如果 O i j h O_{ijh} Oijh​先于 O i k l O_{ikl} Oikl​加工时间 =0
Y Y Y=如果 O i j h O_{ijh} Oijh​晚于 O i k l O_{ikl} Oikl​加工时间 =无穷大

在这里插入图片描述
c j h ≤ s i ( h + 1 ) + L ( 1 − y i k l j ( h + 1 ) ) . \begin{equation} c_{jh}≤s_{i(h+1)}+L(1-y_{iklj(h+1)}). \end{equation} cjh​≤si(h+1)​+L(1−yiklj(h+1)​).​​
其中： j = 1 , 2 , . . . n j= 1,2,...n j=1,2,...n； k = 0 , 1 , 2 , . . . n k= 0,1,2,...n k=0,1,2,...n； h = 1 , 2 , 3 , . . . , h j − 1 h=1,2,3,...,h_j-1 h=1,2,3,...,hj​−1； l = 1 , 2 , 3 , . . . , h k l=1,2,3,...,h_k l=1,2,3,...,hk​； i = 1 , 2 , . . , m i=1,2,..,m i=1,2,..,m
工件 j j j 共有 h j h_j hj​ 道工序总时间不能超过工件 j j j 的第 h + 1 h+1 h+1 道工序加工开始时间+ Y Y YY YY

Y Y YY YY=如果 O i k l O_{ikl} Oikl​先于 O i j ( h + 1 ) O_{ij(h+1)} Oij(h+1)​加工时间 =0
Y Y YY YY=如果 O i k l O_{ikl} Oikl​晚于 O i j ( h + 1 ) O_{ij(h+1)} Oij(h+1)​加工时间 =无穷大

在这里插入图片描述
∑ i = 1 m j h x i j h = 1. \begin{equation} {{\sum\limits_{i=1}^{m_{jh}}x_{ijh}}}=1. \end{equation} i=1∑mjh​​xijh​=1.​​
其中： j = 1 , 2 , 3 , . . . n j= 1,2,3,...n j=1,2,3,...n； h = 1 , 2 , 3 , . . . , h j h=1,2,3,...,h_j h=1,2,3,...,hj​
如果工序 O j h O_{jh} Ojh​只能在可选的机器中选择一个

在这里插入图片描述
∑ j = 1 n ∑ h = 1 h j y i j h k l = x i k l . \begin{equation} {{\sum\limits_{j=1}^{n}{{\sum\limits_{h=1}^{h_{j}}y_{ijhkl}}}}}=x_{ikl}. \end{equation} j=1∑n​h=1∑hj​​yijhkl​=xikl​.​​
其中： k = 1 , 2 , 3 , . . . n k= 1,2,3,...n k=1,2,3,...n； l = 1 , 2 , 3 , . . . , h k l=1,2,3,...,h_k l=1,2,3,...,hk​； i = 1 , 2 , . . , m i=1,2,..,m i=1,2,..,m
对于第 i i i号机器，早于 O k l O_{kl} Okl​的其他全部工件的全部工序 的集合个数= Y Y Y YYY YYY
如果工序 O k l O_{kl} Okl​选择i机器 —— Y Y Y = 1 YYY=1 YYY=1
如果工序 O k l O_{kl} Okl​不选择i机器 —— Y Y Y = 0 YYY=0 YYY=0
在这里插入图片描述
∑ k = 1 n ∑ l = 1 h j y i j h k l = x i j h . \begin{equation} {{\sum\limits_{k=1}^{n}{{\sum\limits_{l=1}^{h_{j}}y_{ijhkl}}}}}=x_{ijh}. \end{equation} k=1∑n​l=1∑hj​​yijhkl​=xijh​.​​
其中： k = 1 , 2 , 3 , . . . n k= 1,2,3,...n k=1,2,3,...n； h = 1 , 2 , 3 , . . . , h k h=1,2,3,...,h_k h=1,2,3,...,hk​； i = 1 , 2 , . . , m i=1,2,..,m i=1,2,..,m
对于第 i i i号机器，晚于 O j h O_{jh} Ojh​的其他全部工件的全部工序 的集合个数= Y Y Y YYY YYY
如果工序 O j h O_{jh} Ojh​选择i机器 —— Y Y Y = 1 YYY=1 YYY=1
如果工序 O j h O_{jh} Ojh​不选择i机器 —— Y Y Y = 0 YYY=0 YYY=0
在这里插入图片描述
s j h ≥ 0 ; c j h ≥ 0. \begin{equation} s_{jh}≥0 ;c_{jh}≥0. \end{equation} sjh​≥0;cjh​≥0.​​
其中： j = 0 , 1 , 2 , 3 , . . . n j= 0,1,2,3,...n j=0,1,2,3,...n； h = 1 , 2 , 3 , . . . , h j h=1,2,3,...,h_j h=1,2,3,...,hj​

各个参数变量必须是正数
在这里插入图片描述

2.4.1 模型约束小总结

  • 式(1) 和式(2) 表示每一个工件的工序先后顺序约束；
  • 式(3)表示工件的完工时间的约束，即每一个工件的完工时间不可能超过总的完工时间；
  • 式(4)和式(5) 表示同一时刻同一台机器只能加工一道工序；
  • 式(6) 表示机器约束，即同一时刻同一道工序只能且仅能被一台机器加工；
  • 式(7)和式(8)表示存在每一台机器上可以存在循环操作；
  • 式(9)表示各个参数变量必须是正数。

在这里插入图片描述

2.4.2 传统方法

目前已经提出了很多近似算法来求解FJSP问题，包括启发式、元启发式和机器学习技术。
相比较于精确算法，近似算法可以在求解效率和求解质量上实现较好的均衡。特别是群体智能（SI）和进化算法（EA），例如遗传（GA）、粒子群（PSO）、蚁群优化（ACO）、人工蜂群(ABC)等，在求解FJSP时都表现出了较强的实力。

在这里插入图片描述

3. FJSP评价指标

在FJSP的求解过程中，调度方案优劣的评价需要通过一定的目标函数来判断，目标函数也就是常用的评价指标。FJSP中不仅包括了经典JSP常用的评价指标，而且还有其他的评价指标。下面列出文献中较为常用的几个评价指标。

  • 最大完工时间最小完工时间是每个工件最后一道工序完成的时间，其中最大的那个时间就是最大完工时间（makespan）。
    它是衡量调度方案的最根本指标，主要体现车间的生产效率，也是FJSP研究中应用最广泛的评价指标之一。
    可表示为：

f 1 = min ( max ⁡ 1 ≤ j ≤ n   ( C j ) ) . \begin{equation} f_1=\text{min}(\underset{1\le j\le n}{\mathop{\max }}\,({{C}_{j}})). \end{equation} f1​=min(1≤j≤nmax​(Cj​)).​​

  • 机器最大负荷最小在FJSP求解中，存在选择机器的过程，各台机器的负荷随着不同的调度方案而不同。负荷最大的机器就是瓶颈设备。要提高每台机器的利用率，必须使得各台机器的负荷尽量小且平衡，可表示为

f 2 = min ( max ⁡ 1 ≤ j ≤ m   ( ∑ j = 1 n ∑ h = 1 h j p i j h x i j h ) ) . \begin{equation} f_2=\text{min}(\underset{1\le j\le m}{\mathop{\max }}\,({{\sum\limits_{j=1}^{n}{{\sum\limits_{h=1}^{h_{j}}p_{ijh}x_{ijh}}}}})). \end{equation} f2​=min(1≤j≤mmax​(j=1∑n​h=1∑hj​​pijh​xijh​)).​​

  • 总机器负荷最小工序在不同机器上的加工时间是不同的，那么总的机器负荷随着不同的调度方案而不同。尽量使最大完工时间一样的情况下，减少所有机器的总消耗，可表示为

f 3 = min ( ∑ i = 1 m ∑ j = 1 n ∑ h = 1 h j p i j h x i j h ) . \begin{equation} f_3=\text{min}({{\sum\limits_{i=1}^{m}{{\sum\limits_{j=1}^{n}{\sum\limits_{h=1}^{h_{j}}p_{ijh}x_{ijh}}}}}}). \end{equation} f3​=min(i=1∑m​j=1∑n​h=1∑hj​​pijh​xijh​).​​

  • 提前／拖期最小准时制的生产必须考虑交货期问题，工件完工时间越接近交货期，表明其交货期性能越好。一般用最大提前时间指标 E j E_j Ej​ 表示工件 j j j 的交货期 d j d_j dj​ 与其完成时间 C j C_j Cj​ 的非负差值，即

E j = max ( d j − C j , 0 ) . \begin{equation} E_j=\text{max}(d_j-C_j,0). \end{equation} Ej​=max(dj​−Cj​,0).​​

  • 用最大拖期时间指标 T j T_j Tj​表示工件 j j j 的完成时间 C j C_j Cj​ 与交货期时间 d j d_j dj​ 的非负差值，即

T j = max ( C j − d j , 0 ) . \begin{equation} T_j=\text{max}(C_j-d_j,0). \end{equation} Tj​=max(Cj​−dj​,0).​​

  • 最大提前时间最小和最大拖期时间最小分别可表示为

f 4 = min ( max ⁡ 1 ≤ j ≤ n   ( E j ) ) . \begin{equation} f_4=\text{min}(\underset{1\le j\le n}{\mathop{\max }}\,(E_j)). \end{equation} f4​=min(1≤j≤nmax​(Ej​)).​​
f 5 = min ( max ⁡ 1 ≤ j ≤ n   ( T j ) ) . \begin{equation} f_5=\text{min}(\underset{1\le j\le n}{\mathop{\max }}\,(T_j)). \end{equation} f5​=min(1≤j≤nmax​(Tj​)).​​

以上几种性能评价指标较为常用。还有其他如考虑工件安装时间的性能评价指标或更加贴近生产成本的一些成本指标等。其中如果性能评价指标函数是完工时间的非减函数，则称为正规性能指标(regular measure)，如 f 1 , f 2 , f 3 , f 4 , f 5 f_1,f_2,f_3,f_4,f_5 f1​,f2​,f3​,f4​,f5​；否则称为非正规性能指标，如 E / T E/T E/T 惩罚代价最小等

在这里插入图片描述在这里插入图片描述

4. 举例说明

4.1 加工过程论述方法

假如此时有3个工件 [ J 1 , J 2 , J 3 ] [J_1,J_2,J_3] [J1​,J2​,J3​]需要在3台机器 [ M 1 , M 2 , M 3 ] [M_1,M_2,M_3] [M1​,M2​,M3​] 上加工
n = 3 m = 3 n=3\\ m=3 n=3m=3
不同工件所需的加工工序及加工时间可以用以下公式表示：

J 1 = [ ( 1 , 3 ) , ( 2 , 2 ) , ( 3 , 2 ) ] J_1=[(1,3),(2,2),(3,2)] J1​=[(1,3),(2,2),(3,2)]

J 2 ​ = [ ( 1 , 2 ) , ( 3 , 1 ) , ( 2 , 4 ) ] J_2​=[(1,2),(3,1),(2,4)] J2​​=[(1,2),(3,1),(2,4)]

J 3 = [ ( 2 , 4 ) , ( 3 , 3 ) ] J_3=[(2,4),(3,3)] J3​=[(2,4),(3,3)]

在这个例子中，作业 J 1 J_1 J1​有3道工序：

  • 它的第1道工序上标注有(1,3)，表示第1道工序必须在 M 1 M_1 M1​上进行加工，且需要3个单位的加工时间；
  • 它的第2道工序上标注有(2,2)，表示第2道工序必须在 M 2 M_2 M2​上进行加工，且需要2个单位的加工时间；
  • 余下的同理。总的来说，这个实例中共有8道工序。

当然，对于代码 来讲 起始做索引0开始比较好，即 J 0 J_0 J0​和 J 0 J_0 J0​。

在这里插入图片描述

4.2 加工过程论述图表

例如， 一个包括 3 个工件、5 台机器的柔性作业车间调度加工时间表。柔性作业车间调度问题的求解过程包括两部分：选择各工序的加工机器和确定每台机器上工件的先后顺序。

在这里插入图片描述
调度的目标就是确定每个机器上工序的加工顺序和每个工序的开工时间，使得最大完工时间 C m a x C_{max} Cmax​最小或者其他指标达到最优

5. 利用遗传算法求解柔性车间调度问题

5.1 遗传算法编码

编码与解码是指染色体和调度解之间进行相互转换，是遗传算法成功实施优化的首要和关键问题。对于传统的作业车间调度问题，大多数研究采用基于工序的编码。

但是柔性作业车间调度问题不仅要确定工序的加工顺序，还需为每道工序选择一台合适的机器，仅采用基于工序的编码方法不能得到问题的解。因此，对于柔性作业车间调度问题，遗传算法的编码由两部分组成，第一部分为基于工序的编码，用来确定工序的加工先后顺序；第二部分为基于机器分配的编码，用来选择每道工序的加工机器。融合这两种编码方法，即可得到柔性作业车间调度问题的一个可行解。结合两种编码方式的染色体如下图所示。
在这里插入图片描述

function [Population] = Coding(T,PopSize)
%% INPUT：
% T--input matrix:
%  For example: 
%  A partial flexible scheduling problem in which 8 jobs are processed 
%  on 8 machines, in which the number of available machining machines per
%  step of job is less than or equal to the total number of machines
% J1 ={[5 3 5 3 3 0 10 9];[10 0 5 8 3 9 9 6];[0 10 0 5 6 2 4 5]};
% J2 ={[5 7 3 9 8 0 9 0];[0 8 5 2 6 7 10 9];[0 10 0 5 6 4 1 7];[10 8 9 6 4 7 0 0]};
% J3 ={[10 0 0 7 6 5 2 4];[0 10 6 4 8 9 10 0];[1 4 5 6 0 10 0 7]};
% J4 ={[3 1 6 5 9 7 8 4];[12 11 7 8 10 5 6 9];[4 6 2 10 3 9 5 7]}; 
% J5 ={[3 6 7 8 9 0 10 0];[10 0 7 4 9 8 6 0];[0 9 8 7 4 2 7 0];[11 9 0 6 7 5 3 6]};
% J6 ={[6 7 1 4 6 9 0 10];[11 0 9 9 9 7 6 4];[10 5 9 10 11 0 10 0]};
% J7 ={[5 4 2 6 7 0 10 0];[0 9 0 9 11 9 10 5];[0 8 9 3 8 6 0 10]};
% J8 ={[2 8 5 9 0 4 0 10];[7 4 7 8 9 0 10 0];[9 9 0 8 5 6 7 1];[9 0 3 7 1 5 8 0]};
% T={J1;J2;J3;J4;J5;J6;J7;J8}; 8*1 cell
% Popsize- Population size in genetic algorithms,2*PopSize+1
%% OUTPUT:
% Population-Popsize*1 cell
% chromosome-2*1 cell
%% variable declaration
num_of_jobs = length(T);                                                   %number of jobs
num_of_machines = length(T{1}{1});                                         %number of machines
steps_of_job =[];
machine_of_job=cell(num_of_jobs,1);

% calculate the length of chromosome
for i = 1:num_of_jobs
    steps_of_job=[steps_of_job;length(T{i})];
end
len_of_chromosome = sum(steps_of_job);

% calculate the machine set for each steps of each job
for i=1:num_of_jobs
    steps=cell(steps_of_job(i),1);
    for j = 1:steps_of_job(i)
        machineset=[];
        for k=1:length(T{i}{j})
            if T{i}{j}(k)~=0
               machineset=[machineset k]; 
            end
        end
        steps{j}=machineset;
    end
    machine_of_job{i}=steps;
end


%steps chromosome
%Coding is based on the step of the job
step_chromsome=[];
for i = 1:num_of_jobs
    for j = 1:steps_of_job(i)
        step_chromsome=[step_chromsome i];
    end
end
step_population =[];
%Generate population with chromosome containing random genes 
for i = 1:PopSize
    step_population(i,:)=step_chromsome(randperm(length(step_chromsome(:))));
end
%
%machine chromosome
%In each steps, the machine is randomly selected for two machines,
%and the machine that selects the short processing time is the gene with
%propability
machine_population =[];
for index = 1:PopSize
    machine_chromsome=[];
    for i=1:num_of_jobs
        for j=1:steps_of_job(i)
            pos= randperm(length(machine_of_job{i}{j}),2);
            machine1=machine_of_job{i}{j}(pos(1));
            machine2=machine_of_job{i}{j}(pos(2));
            if (rand(1)<0.8) && (T{i}{j}(machine1)>T{i}{j}(machine2))
                machine = machine2;
            else
                machine = machine1;
            end
            machine_chromsome=[machine_chromsome machine];   
        end
    end
    machine_population(index,:) = machine_chromsome;
end

Population=cell(PopSize,1);
for i=1:PopSize
    Population{i} =[step_population(i,:);machine_population(i,:)]; 
end
end

其中基于工序编码的基因串确定工序加工的先后顺序，基于机器编码的基因串确定每个工件所有工序的加工机器。图中所示的染色体表示的工序和机器序列为
( O 11 , M 1 ) (O_{11},M_1 ) (O11​,M1​)， ( O 21 , M 1 ) (O_{21},M_1) (O21​,M1​)， ( O 12 , M 3 ) (O_{12},M_3 ) (O12​,M3​)， ( O 22 , M 4 O ) (O_{22},M_4O ) (O22​,M4​O)， ( O 13 , M 4 ) (O_{13},M_4 ) (O13​,M4​)， ( O 31 , M 3 ) (O_{31},M_3 ) (O31​,M3​)， ( O 23 , M 5 ) (O_{23},M_5 ) (O23​,M5​)， ( O 32 , M 2 ) (O_{32},M_2) (O32​,M2​)， ( O 33 , M 2 ) (O_{33},M_2) (O33​,M2​)

编码代码如下：

解码过程和编码过程相反，解码分为一般解码或者称为半主动解码、主动解码和全主动解码。本文使用半主动解码方式进行染色体解码。

5.2 遗传算法解码

（1）活动调度: 在不推迟其他操作或破坏优先顺序的条件下，其中没有一个操作可以提前加工。图b所示。

（2）半活动调度： 在不改变机器上加工顺序的条件下，其中没有操作可以提前。图a所示。

（3）非延迟调度： 至少存在一个工件等待加工时，对应不存在相应处于空闲的机器。

在这里插入图片描述
解码代码如下

%% Flexible Job-shop scheduling problem based on genetic algorithm with POX selection
% Author：Eric.Wan
% Date：2019-12-8
% Add.：ShenYang,China
% Email:970301442@qq.com
% Version: v1.0
function [Jobs,Cmax,MachineList,ST,PT] = SemiActiveDecoding(T,Chromosome)
%% INPUT:
 % T--input matrix:
    %  For example: 
    %  A partial flexible scheduling problem in which 8 jobs are processed 
    %  on 8 machines, in which the number of available machining machines per
    %  step of job is less than or equal to the total number of machines
    % J1 ={[5 3 5 3 3 0 10 9];[10 0 5 8 3 9 9 6];[0 10 0 5 6 2 4 5]};
    % J2 ={[5 7 3 9 8 0 9 0];[0 8 5 2 6 7 10 9];[0 10 0 5 6 4 1 7];[10 8 9 6 4 7 0 0]};
    % J3 ={[10 0 0 7 6 5 2 4];[0 10 6 4 8 9 10 0];[1 4 5 6 0 10 0 7]};
    % J4 ={[3 1 6 5 9 7 8 4];[12 11 7 8 10 5 6 9];[4 6 2 10 3 9 5 7]}; 
    % J5 ={[3 6 7 8 9 0 10 0];[10 0 7 4 9 8 6 0];[0 9 8 7 4 2 7 0];[11 9 0 6 7 5 3 6]};
    % J6 ={[6 7 1 4 6 9 0 10];[11 0 9 9 9 7 6 4];[10 5 9 10 11 0 10 0]};
    % J7 ={[5 4 2 6 7 0 10 0];[0 9 0 9 11 9 10 5];[0 8 9 3 8 6 0 10]};
    % J8 ={[2 8 5 9 0 4 0 10];[7 4 7 8 9 0 10 0];[9 9 0 8 5 6 7 1];[9 0 3 7 1 5 8 0]};
    % T={J1;J2;J3;J4;J5;J6;J7;J8}; 8*1 cell
  %Chromosome -- A chromosome to be decoded
%% OUTPUT:
    %JobList-- job sequences
    %Cmax --the max makespan
    %MachineList--The machine sequences corresponding to chromosome
    %ST --the start time for each job step in chromosome
    %PT --The operation time for each job step in chromome
%% start
num_of_jobs = length(T);                                                   %number of jobs
num_of_machines = length(T{1}{1});                                         %number of machines
len_of_chromosome = length(Chromosome);


StepList = [];                                                             %steps for all genes
MachineList = zeros(1,len_of_chromosome);
ST = zeros(1,len_of_chromosome);
PT = zeros(1,len_of_chromosome);
DecodedGenes =[];


steps_of_job =[];                                                       
for i = 1:num_of_jobs
    steps_of_job=[steps_of_job;length(T{i})];
end
               
%% Caculate MachineList and PT
for index = 1:len_of_chromosome
    DecodedGenes=[DecodedGenes Chromosome(1,index)];
    postion = length(find(DecodedGenes==Chromosome(1,index))); 
    StepList = [StepList postion];
    MachineList(index)=Chromosome(2,sum(steps_of_job(1:(Chromosome(1,index)-1)))+postion);
    PT(index)=T{Chromosome(1,index)}{postion}(MachineList(index));
end

%% Caculate ST
Machines = unique(MachineList);
Jobs = unique(Chromosome(1,:));

job_start_time = cell(num_of_jobs,1);
job_end_time = cell(num_of_jobs,1);
machine_start_time = cell(num_of_machines,1);
machine_end_time   = cell(num_of_machines,1);
machine_state = zeros(1,num_of_machines);                                %0--FirstWork;1--NotFirst 


for index = 1:len_of_chromosome
    job = Chromosome(1,index);
    machine = MachineList(index);
    pt = PT(index);
    step = StepList(index);
    pos_m = find(Machines==machine);
    pos_j = find(Jobs==job);
    if step==1                                                             %first step without considering the constrains between steps of same job
        if machine_state(pos_m)==0                                         % The machine is first used
            job_start_time{pos_j}=[0,pos_m];
            job_end_time{pos_j}=[job_start_time{pos_j}(1)+pt,pos_m];
            
        else
            job_start_time{pos_j}=[machine_end_time{pos_m}(1),pos_m];
            job_end_time{pos_j}=[job_start_time{pos_j}(1)+pt,pos_m];
        end
    else
         if machine_state(pos_m)==0                                         % The machine is first used
            job_start_time{pos_j}=[job_end_time{pos_j}(1),pos_m];
            job_end_time{pos_j}=[job_start_time{pos_j}(1)+pt,pos_m];
           
        else
            job_start_time{pos_j}=[max(machine_end_time{pos_m}(1),job_end_time{pos_j}(1)),pos_m];
            job_end_time{pos_j}=[job_start_time{pos_j}(1)+pt,pos_m];
        end       
        
    end
    machine_start_time{pos_m}= job_start_time{pos_j}(1);
    machine_end_time{pos_m} = job_end_time{pos_j}(1); 
    machine_state(pos_m)=1;
    ST(index)=job_start_time{pos_j}(1); 
end

%% Caculate Cmax
end_time=cell2mat(job_end_time);
Cmax = max(end_time(:,1));
end

5.3 遗传算法选择

在遗传算法中,适应度是个体对生存环境的适应程度，适应度高的个体将获得更多的生存机会。选择算子根据适应度的值选择个体遗传到下一代群体中。选择操作采用最佳个体保存（Elitist model）和锦标选择（Tournament selection）两种方法。在本章的改进遗传算法中，最佳个体保存方法是将父代群体中最优的 一个个体直接复制到下一代中。锦标选择是从种群中随机选择两个个体，如果随机值（在 0～1 之间随机产生）小于给定概率值 r（概率值 r是一个参数，一般设置为 0.8），则选择优的一个，否则就选择另一个。被选择的个体放回到种群，可以重新作为一个父染色体参与选择。

选择代码如下

BestFitness=min(FITNESS);                                              % find the best chromosome
    position=find(FITNESS==BestFitness);                                   % and the position,may be more than one
    BestChromosome=Population{position(1)};                                % choose one chromosome from population
  
    
    %% Selection :Elitism and 2-tournament selection are used
    Parent = cell(PopSize,1);
    Pr =0.8;
    for index =1:PopSize-1
        pos = randperm(PopSize,2);
        chromosome1 = Population{pos(1)};
        chromosome2 = Population{pos(2)};
        if (rand(1)<Pr) && FITNESS(pos(1))>FITNESS(pos(2))
                chromosome = chromosome1;
        else
                chromosome = chromosome2;
        end
        Parent{index} = chromosome;
    end
        Parent{PopSize}=BestChromosome;

5.4 遗传算法交叉

交叉操作是将种群中两个个体随机地交换某些基因，产生新的基因组合，期望将有益的基因组合在一起。染色体中两部分基因串的交叉分别进行，其中第一部分基于工序编码基因串的交叉操作采用IPOX 交叉算子，第二部分基于机器分配编码基因串的交叉采用多点交叉MPX的方法。

5.4.1 IPOX交叉因子

IPOX操作是在POX操作基础上经改进而形成的（POX不了解的可以参考博文基于遗传算法的传统作业车间调度的问题求解），它仅仅交叉父代染色体中工序的加工序列，保留工件中工序分配的机器到子代。IPOX的具体操作过程如下图所示，其中 P 1 P_1 P1​和 P 2 P_2 P2​ 为调度问题的两个父代染色体，交叉产生子代 C 1 C_1 C1​ 和 C 2 C_2 C2​IPOX交叉操作过程为：

1）把所有的工件随机分成两个集合 G 1 G_1 G1​ 和 G 2 G_2 G2​ ;
2) 复制 P 1 P_1 P1​ 包含在 G 1 G_1 G1​ 中的工件到 C 1 C_1 C1​，复制 P 2 P_2 P2​ 包含在 G 2 G_2 G2​ 中的工件到 C 2 C_2 C2​ ，保留它们的位置；
3）复制 P 1 P_1 P1​ 包含在 G 1 G_1 G1​ 中的工件到 C 2 C_2 C2​ ，复制$ P_2$ 包含在$ G_2$ 中的工件到 C 1 C_1 C1​ ，保留它们的顺序。

在这里插入图片描述

5.4.2 MPX交叉因子

MPX交叉父代染色体中工序选定的机器，工序的加工顺序保留到子代。多点交叉操作的过程如下图所示。对于某调度问题， P 1 P_1 P1​和 P 2 P_2 P2​为调度问题的两个父代染色体，交叉产生子代 C 1 C_1 C1​和 C 2 C_2 C2​MPX交叉操作过程为：

1）首先随机产生一个有整数0、1组成的与染色体长度相等的 r a n d [ 0 , 1 ] rand[0,1] rand[0,1]集；
2）依次在 P 2 P_2 P2​中选出 P 1 P_1 P1​与 r a n d [ 0 , 1 ] rand[0,1] rand[0,1]集中1的位置对应相同的工序，交换他们分配的机器， P 1 P_1 P1​ 和 P 2 P_2 P2​中其他机器的加工顺序保留到子代，这样分别产生子代 C 1 C_1 C1​ 和 C 2 C_2 C2​ 。因为是同一工序的加工机器交换，生成的子代染色体必为可行解。

在这里插入图片描述

交叉操作的代码如下

   %% Crossover: IPOX for steps, MPX for machine 
   
    Children_group1=cell(PopSize,1);
    for i=1:(PopSize-1)
        %Parent individuals are selected for crossover operation:
        %Parent1 is selected sequentially and Parent2 is selected randomly.
        index_parent2 = randi([1,(PopSize-1)]);
        Parent1=Parent{i};
        Parent2=Parent{index_parent2};
       
        Children1=zeros(2,len_of_chromosome);
        Children2=zeros(2,len_of_chromosome);
        if rand(1)<=Pc %Use the probability to determine if crossover is required
           %% Part1: IPX for step
            %Randomly divide the set of jobs {1,2,3...,n} into two non-empty sub-sets J1 and J2.
            num_J1 = randi([1,num_of_jobs]);   
            if num_J1==num_of_jobs
                num_J1 = fix(num_of_jobs/2);  
            end
            J = randperm(num_of_jobs);          
            J1 =J(1:num_J1);
            J2 =J(num_J1+1:num_of_jobs); 
            % Copy the jobs that Parent1 contains in J1 to Children1, 
            % and Parent2 contains in J2 to Children2, and keep them in place.
            for index = 1:num_J1                                            % look for jobs that Parent1 are included in J1
                job = J1(index);
                for j = 1:len_of_chromosome
                    if job == Parent1(1,j)
                        Children1(1,j)=Parent1(1,j);
                    end 
                end   
            end
            for index = 1:num_of_jobs-num_J1                                % look for jobs that Parent2 are included in J2
                job = J2(index);
                for j = 1:len_of_chromosome
                    if job == Parent2(1,j)
                        Children2(1,j)=Parent2(1,j);
                    end 
                end   
            end           
            %Copy the jobs that Parent1 contains in J1 to Children2, 
            %and Parent2 contains in J2 to Children1 in their order.
           for index = 1:len_of_chromosome                                            % look for jobs that Parent1 are included in J1
                job = Parent1(1,index);
                if ~isempty(find(J1==job, 1))
                     for gene = 1:len_of_chromosome
                         if Children2(1,gene)==0
                            Children2(1,gene)=job;
                            break;
                         end
                     end
                end
                
            end
           for index = 1:len_of_chromosome                                            % look for jobs that Parent1 are included in J1
                job = Parent2(1,index);
                if ~isempty(find(J2==job, 1))
                     for gene = 1:len_of_chromosome
                         if Children1(1,gene)==0
                            Children1(1,gene)=job;
                            break;
                         end
                     end
                end
                
            end
            %%IPOX cross operation completed
           %% Part 2 MPX for machine 
            %The process of crossover operation is as follows: firstly, a set rand0_1 
            %composed of 0 and 1 that is equal to the length of chromosome is randomly 
            %generated, and then the genes at the same position of 1 in the set of rand0_1
            %in the two parental generations are interchanged, and two offspring are
            %obtained after the crossover
            rand0_1 = zeros(1,len_of_chromosome);
            for gene = 1:len_of_chromosome
                if rand(1)>0.5
                    rand0_1(gene)=1;
                end
            end

            for gene = 1:len_of_chromosome
                if rand0_1(gene)==1
                   Children1(2,gene) = Parent2(2,gene);
                   Children2(2,gene) = Parent1(2,gene);
                else
                   Children1(2,gene) = Parent1(2,gene);
                   Children2(2,gene) = Parent2(2,gene);                   
                end
            end    
            %MOX cross operation completed
        else  
        Children1 = Parent1;
        Children2 = Parent2;  
        end
        %% Select the Fitness value best retained to the next generation
        [Parent1_FitnessValue] = FitnessCalculator(T,Parent1);
        [Parent2_FitnessValue] = FitnessCalculator(T,Parent2);
        [Children1_FitnessValue] = FitnessCalculator(T,Children1);
        [Children2_FitnessValue] = FitnessCalculator(T,Children2);
        [~, pos] = max([Parent1_FitnessValue Parent2_FitnessValue Children1_FitnessValue Children2_FitnessValue]);
        temp_group ={Parent1 Parent2 Children1 Children2};

           
    end
    Children_group1{PopSize}= BestChromosome;

5.5 遗传算法变异

变异操作的目的是改善算法的局部搜索能力和维持群体多样性，同时防止出现早
熟现象。基于工序编码和基于机器分配编码的变异分别设计如下：

  1. 基于工序编码的变异
    对于这部分基因实施插入变异，即从染色体中随机选择一个基因，然后将之插入到一个随机的位置。
  2. 基于机器分配编码的变异
    由于每道工序都可以由多台机器完成，所以随机选择两道工序，然后在执行这两道工序的机器集合中选择一台机器（采用比例选择策略，加工时间短的优先选择），并将选择的机器号置入对应的基于机器分配编码的基因串中，这样得出的解能确保是可行解。

交叉操作的代码如下

 %% Mutation 

    Children_group2=cell(PopSize,1);
    for i=1:(PopSize-1)
       temp_chromsome = Children_group1{i};
       %% Mutation for steps
        if rand(1)<Pm
            for j=1:4
                pos1=randi([1,len_of_chromosome]); % Choose the sequence number of a gene to be mutated
                pos2=randi([1,len_of_chromosome]); %  Choose another the sequence number of a gene to be mutated
                Gene=temp_chromsome(1,pos1); 
                temp_chromsome(1,pos1)=temp_chromsome(1,pos2);
                temp_chromsome(1,pos2)=Gene;
            end
        end
       %% Mutation for machine
       if rand(1)<Pm
           for k=1:4
               job = randi([1,num_of_jobs]) ;                                  %random choose job
               tempstep = randi([1,steps_of_job(job)]);                            %random choose step
               newmachine = machine_of_job{job}{tempstep}(randi([1,length(machine_of_job{job}{tempstep})]));%random choose machine
               temp_chromsome(2,sum(steps_of_job(1:job-1))+1)= newmachine;     %replace the old one
           end
       end
       Children_group2{i} = temp_chromsome;    
     end
   
    Children_group2{PopSize}= BestChromosome;
    % complete mutation

6. 实验验证

这里使用两个基准实例，即部分柔性实例 T 8 ∗ 8 T_{8*8} T8∗8​ 和完全柔性实例 T 10 ∗ 10 T_{10*10} T10∗10​

%% T8x8 
% A partial flexible scheduling problem in which 8 jobs are processed 
% on 8 machines, in which the number of available machining machines per
% step of job is less than or equal to the total number of machines
J1 ={[5 3 5 3 3 0 10 9];[10 0 5 8 3 9 9 6];[0 10 0 5 6 2 4 5]};
J2 ={[5 7 3 9 8 0 9 0];[0 8 5 2 6 7 10 9];[0 10 0 5 6 4 1 7];[10 8 9 6 4 7 0 0]};
J3 ={[10 0 0 7 6 5 2 4];[0 10 6 4 8 9 10 0];[1 4 5 6 0 10 0 7]};
J4 ={[3 1 6 5 9 7 8 4];[12 11 7 8 10 5 6 9];[4 6 2 10 3 9 5 7]}; 
J5 ={[3 6 7 8 9 0 10 0];[10 0 7 4 9 8 6 0];[0 9 8 7 4 2 7 0];[11 9 0 6 7 5 3 6]};
J6 ={[6 7 1 4 6 9 0 10];[11 0 9 9 9 7 6 4];[10 5 9 10 11 0 10 0]};
J7 ={[5 4 2 6 7 0 10 0];[0 9 0 9 11 9 10 5];[0 8 9 3 8 6 0 10]};
J8 ={[2 8 5 9 0 4 0 10];[7 4 7 8 9 0 10 0];[9 9 0 8 5 6 7 1];[9 0 3 7 1 5 8 0]};

T8x8={J1;J2;J3;J4;J5;J6;J7;J8};
%% T10x10
% For all flexible scheduling problems of 10 jobs and 10 machines,
% the number of available processing machines in each step of job is equal to 
% the total number of machines
G1={[1 4 6 9 3 5 2 8 9 5];[4 1 1 3 4 8 10 4 11 4];[3 2 5 1 5 6 9 5 10 3]};
G2={[2 10 4 5 9 8 4 15 8 4];[4 8 7 1 9 6 1 10 7 1];[6 11 2 7 5 3 5 14 9 2]};
G3={[8 5 8 9 4 3 5 3 8 1];[9 3 6 1 2 6 4 1 7 2];[7 1 8 5 4 9 1 2 3 4]};
G4={[5 10 6 4 9 5 1 7 1 6];[4 2 3 8 7 4 6 9 8 4];[7 3 12 1 6 5 8 3 5 2]};
G5={[7 10 4 5 6 3 5 15 2 6];[5 6 3 9 8 2 8 6 1 7];[6 1 4 1 10 4 3 11 13 9]};
G6={[8 9 10 8 4 2 7 8 3 10];[7 3 12 5 4 3 6 9 2 15];[4 7 3 6 3 4 1 5 1 11]};
G7={[1 7 8 3 4 9 4 13 10 7];[3 8 1 2 3 6 11 2 13 3];[5 4 2 1 2 1 8 14 5 7]};
G8={[5 7 11 3 2 9 8 5 12 8];[8 3 10 7 5 13 4 6 8 4];[6 2 13 5 4 3 5 7 9 5]};
G9={[3 9 1 3 8 1 6 7 5 4];[4 6 2 5 7 3 1 9 6 7];[8 5 4 8 6 1 2 3 10 12]};
G10={[4 3 1 6 7 1 2 6 20 6];[3 1 8 1 9 4 1 4 17 15];[9 2 4 2 3 5 2 4 10 23]};
T10x10 = {G1;G2;G3;G4;G5;G6;G7;G8;G9;G10};

这里贴上运行8*8实例的运行脚本程序入如下：

clear;
clc;
T = Tmatrix('8x8');
Iterations=100;
PopSize=50;
Pc=0.8;
Pm=0.5;
result=cell(1000,1);

[Chromosome] = POX_GA(T,Iterations,PopSize,Pc,Pm);
[Jobs,Cmax,MachineList,ST,PT] = SemiActiveDecoding(T,Chromosome);
GanntGraf(Jobs,Chromosome(1,:),MachineList,ST,PT,Cmax,'FJSP') ;

在这里插入图片描述

7. 参考文献

https://blog.csdn.net/tauyangdao/article/details/103444415

https://blog.csdn.net/tauyangdao/article/details/103827189

https://zhuanlan.zhihu.com/p/383594362

https://zhuanlan.zhihu.com/p/558800456

柔性作业车间调度
constant_study的博客
03-06 1万+
柔性作业车间调度 1 问题描述 1.1 传统作业车间调度 传统作业车间带调度实例 工件 工序 可选择的加工机器 M1 M2 M3 M4 M5 J1 O11 -- -- 5 -- -- O12 11 -- -- -- -- O13 --
柔性车间作业调度
行者的博客
06-03 1636
考虑n个工件在m个机器上的柔性车间作业调度问题，并且同产品工件工序之间紧邻可以缩短加工时间。
"基于星鸦优化算法(NOA)的柔性作业车间调度问题研究-主函数运行与算法实现",利用星鸦优化算法(NOA)求解标准的柔性作业车间调度问题(Flexible job-shop scheduling p
最新发布
02-06
"基于星鸦优化算法(NOA)的柔性作业车间调度问题研究——主函数运行与算法实现",利用星鸦优化算法(NOA)求解标准的柔性作业车间调度问题(Flexible job-shop scheduling problem, FJSP) 其中：main.m是主函数运行即可；NOA.m是算法的代码；colorplus.p是一个颜色补充包，用于获得甘特图的颜色配置；cheatsheet.png是colorplus.p颜色补充包中的颜色参考示范以及调用方法说明；gantt_chart.m用来绘制甘特图；objective.m是目标函数，即计算Makespan MK.xlsx是柔性作业车间调度问题(Flexible job-shop scheduling problem, FJSP)的经典测试集, 包括MK01, MK02, MK03, MK04, MK05, MK06, MK07, MK08, MK09, MK10 编码方法采用分段编码方式: MSOS, 由两部分组成: 机器选择部分(MS)和工序排序部分(OS)；解码方法采用主动解码方式；具体原理可阅读PDF文件 输出结果包括：Makespan、所有
【车间调度】基于卷积神经网络的柔性作业车间调度问题的两阶段算法（Matlab代码实现）
weixin_67304359的博客
07-29 914
该文提出一种基于卷积神经网络的有效两阶段算法，以求解具有机器故障的柔性作业车间调度问题（FJSP）。建立了以最大完成时间和鲁棒性为目标的双目标动态柔性作业车间调度问题（DFJSP）模型。提出了CNN构建的预测模型，并开发了一个名为RMn的替代指标来评估鲁棒性。实验结果表明，所提两阶段算法对求解DFJSP有效，RMn能够更快、更高效、更准确地评估调度的鲁棒性。柔性作业车间调度问题（Flexible Job Shop Scheduling Problem, FJSP）是一个经典的组合优化问题，在实际生产制造领域
开源项目：灵活工作坊调度（Flexible Job Shop）
gitblog_00832的博客
09-12 435
开源项目：灵活工作坊调度（Flexible Job Shop） flexible-job-shop Python implementation of a genetic algorithm for FJSP. 项目地址: http...
【PFJSP问题】基于被囊群优化算法TSA求解置换流水车间调度问题PFSP附matlab代码
qq_59747472的博客
08-02 433
一、 问题背景与定义置换流水车间调度问题 (Permutation Flow Shop Scheduling Problem, PFJSP) 是一种经典的组合优化问题，其目标是在给定的流水车间环境下，确定最佳的作业排序，以最小化总完工时间 (Makespan)。PFJSP 在现实生产中广泛存在，例如制造业、物流业和服务业等，其高效求解对提高生产效率、降低成本具有重要意义。二、 问题描述PFJSP 可描述如下：车间结构: 包含 𝑚m 个机器，每个机器都依次执行所有作业。
柔性作业车间调度问题（FJSP）
qq_55882840的博客
10-05 5321
如图2.1(a)所示为表2.3中调度问题的一个可行调度的有向图，图2.1(b)所示为对应图2.1(a)的甘特图，其中机器1上的选择S1={O21,O11,O32}，机器2上的选择S2={O31,O12,O23}，机器3上的选择S3={O22,O13,O33}。关键路径的长度等于16。在作业车间调度问题(job shop scheduling problem,JSP)中,加工系统有一组功能不同的机床,待加工的工件包含多道工序,每道工序在一台机床上加工，工件的加工路线互不相同,每个工件工序之间有先后顺序约束。
柔性作业车间调度问题(Flexible Job Scheduling Problem, FJSP)介绍
IT猿手
03-29 2518
柔性作业车间调度问题(Flexible Job Scheduling Problem, FJSP) 的描述如下：n个工件JJ2​..Jn​要在m台机器M1​M2​..Mm​上加工。每个工件包含一道或多道工序，工序顺序是预先确定的，每道工序可以在多台不同加工机器上进行加工，工序的加工时间随加工机器的不同而不同。调度目标是为每道工序选择最合适的机器、确定每台机器上各个工序的最佳加工顺序以及开工时间，使整个系统的某些性能指标达到最优。
柔性作业车间调度问题 (FJSSP)
zhf的博客
07-22 9895
多智能体系统是分布式人工智能（DAI，Distributed Artificial Intelligence）的一个重要分支。 MES(Manufacturing Execution System)制造执行系统 柔性作业车间调度问题 (FJSSP)是组合优化和生产管理领域很重要的研究课题，它是经典的作业车间调度问题 (JSSP)的延伸且被认为是强NP-hard问题。在FJSSP中，同一个工序的...
【车间调度】柔性作业车间调度问题的研究方法
weixin_51656605的博客
01-29 6171
本系列为自己学习调度相关知识的记录，如有误请指出，也欢迎调度方向的小伙伴加我好友共同交流。 从Johnson揭开调度问题研究的序幕以来，调度问题一直是极其困难的组合优化问题，调度模型从简单到复杂，研究方法也随着调度模型的变迁从开始的数学方法到启发式的智能算法。目前解决调度问题的方法主要分为两类：精确方法（exact method）和近似方法（approximation method）。精确方法也可称为最优化方法，能够保证得到全局最优解，但只能解决较小规模的问题，而且速度很慢。近似方法求解时，可以很快地得.
C++遗传算法解决柔性作业车间调度（附测试数据及优解）
08-21
用c++写的遗传算法解决柔性作业车间调度问题，主要参考论文 张国辉, 高亮, 李培根, et al. 改进遗传算法求解柔性作业车间调度问题[J]. 机械工程学报, 2009, 45(7):145-151.
基于NSGA-2的求解多目标柔性车间调度算法（个人原创，供交流学习）
01-23
NSGA_2求解多目标柔性作业车间的调度算法matlab源码（包含gantt 图的绘制），本人原创，亲测有效。
Flexible job-shop scheduling problem by genetic algorithm
01-12
柔性作业车间调度问题（FJSP）是生产cheduling理论中最复杂的问题之一（Meriem and Ghédira, 2004）。由于exact方法无法在合理的计算时间内解决该问题，因此 heuristic方法通常用于寻找近似最优解。在我们之前的...
柔性作业车间调度算例汇总（FJSP算例）.zip
09-03
柔性作业车间调度问题（Flexible Job Shop Scheduling Problem, 简称FJSP）是生产计划与控制领域中的一个重要研究课题。它涉及到如何在多台具有不同加工能力的机器上，有效地安排一系列作业，以最小化总体完工时间、...
FJSP柔性作业车间调度问题编解码
07-12
FJSP（Flexible Job Shop Scheduling Problem）即柔性作业车间调度问题，是一个经典的优化问题，它涉及到如何在考虑各种限制的情况下，合理安排生产线上的任务顺序，以达到最小化完成时间、最大化效率或者最小化成本...
柔性作业车间调度问题 FJSP 常用基准算例
07-12
柔性作业车间调度问题（Flexible Job Shop Scheduling Problem, 简称FJSP）是生产计划与控制领域的一个核心问题，涉及到如何有效地安排生产任务在多个具有不同加工能力的机器上进行，以达到优化目标，如最小化总完成...
FJSP：河马优化算法（Hippopotamus optimization algorithm，HO）求解柔性作业车间调度问题（FJSP），提供MATLAB代码
IT猿手
01-04 1219
河马优化算法（Hippopotamus optimization algorithm，HO）由Amiri等人于2024年提出的一种模拟自然界中河马觅食行为的新型群体智能优化算法。该算法由Mohammad Hussein Amiri等人于2024年2月发表在Nature旗下子刊《Scientific Reports》上。HO算法的灵感来源于河马生活中的三种突出行为模式：幼河马由于好奇心而偏离群体的倾向；河马的防御性行为，当受到捕食者攻击或其他生物侵入领地时触发；河马逃离捕食者的行为。
车间调度丨柔性车间的动态调度问题：重调度
热门推荐
喜欢玩算法的老学长，致力于运筹优化算法的研究
03-07 1万+
车间调度丨重调度问题
柔性作业车间调度问题研究-思考
松间沙路的博客
11-21 1万+
获取更多资讯，赶快关注上面的公众号吧！ 文章目录作业车间调度vs柔性作业车间调度深挖柔性作业车间调度算法层面：问题层面：融合层面：应用层面：结语 最近一段时间写了一些算法原理相关的文章，也得到了不少粉丝的关注，在这里先谢谢大家了。说到算法，归根结底是要解决问题的，不解决问题的算法，就是皮不在无处依附的毛，就是没有嘴唇被冻坏的牙齿。正好今天也和一位来自南京航空航天大学的“爱学习的好孩子”探讨了一下...
柔性作业车间调度mk01
07-27
对于柔性作业车间调度（Flexible Job Shop Scheduling, FJSP），通常需要考虑多个工件、多个机器和多个工序之间的调度问题。在FJSP中，每个工件可能需要在不同的机器上完成不同的工序，而每个机器同时只能处理一个工件。 为了解决FJSP问题，可以采用不同的调度算法和策略，例如遗传算法、模拟退火算法、禁忌搜索等。这些算法可以根据不同的优化目标（如最小化完工时间、最小化延迟等）来进行调度决策。 在实际应用中，还可以结合各种启发式方法和规则来进行调度决策，例如SPT规则（Shortest Processing Time）、EDD规则（Earliest Due Date）、CR规则（Critical Ratio）等。此外，还可以考虑一些约束条件，如机器容量限制、工时限制等。 以上是对柔性作业车间调度的一般介绍，请问还有其他关于FJSP的问题吗？
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_Matthew

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值