多目标柔性车间调度丨NSGA-II:以算例MK01为例
车间调度系列文章：
- 1、车间调度的编码、解码，调度方案可视化的探讨
- 2、多目标优化:浅谈pareto寻优和非支配排序遗传算法-NSGAII的非支配排序及拥挤度
- 3、柔性车间调度问题:以算例MK01初探数据处理和多个遗传算子
- 4、车间调度丨粒子群算法初探:以算例MK01为例
- 5、车间调度丨布谷鸟算法改进:以算例MK01为例
- 6、车间调度丨自适应灰狼算法改进：以算例MK01为例
- 7、车间调度丨模拟退火算法改进：以算例MK01为例
- 8、车间调度入门系列资料
- 9、多目标柔性车间调度丨改进灰狼算法:以算例MK01为例
- 10、多目标柔性车间调度丨NSGA-II:以算例MK01为例
柔性车间调度问题
柔性车间调度问题可描述为：多个工件在多台机器上加工，工件安排加工时严格按照工序的先后顺序，至少有一道工序有多个可加工机器，在某些优化目标下安排生产。柔性车间调度问题的约束条件如下：
- （1）同一台机器同一时刻只能加工一个工件;
- （2）同一工件的同一道工序在同一时刻被加工的机器数是一;
- （3）任意工序开始加工不能中断;
- （4）各个工件之间不存在的优先级的差别;
- （5）同一工件的工序之间存在先后约束，不同工件的工序之间不存在先后约束;
- （6）所有工件在零时刻都可以被加工。
MK01算例：
10 6 2
6 2 1 5 3 4 3 5 3 3 5 2 1 2 3 4 6 2 3 6 5 2 6 1 1 1 3 1 3 6 6 3 6 4 3
5 1 2 6 1 3 1 1 1 2 2 2 6 4 6 3 6 5 2 6 1 1
5 1 2 6 2 3 4 6 2 3 6 5 2 6 1 1 3 3 4 2 6 6 6 2 1 1 5 5
5 3 6 5 2 6 1 1 1 2 6 1 3 1 3 5 3 3 5 2 1 2 3 4 6 2
6 3 5 3 3 5 2 1 3 6 5 2 6 1 1 1 2 6 2 1 5 3 4 2 2 6 4 6 3 3 4 2 6 6 6
6 2 3 4 6 2 1 1 2 3 3 4 2 6 6 6 1 2 6 3 6 5 2 6 1 1 2 1 3 4 2
5 1 6 1 2 1 3 4 2 3 3 4 2 6 6 6 3 2 6 5 1 1 6 1 3 1
5 2 3 4 6 2 3 3 4 2 6 6 6 3 6 5 2 6 1 1 1 2 6 2 2 6 4 6
6 1 6 1 2 1 1 5 5 3 6 6 3 6 4 3 1 1 2 3 3 4 2 6 6 6 2 2 6 4 6
6 2 3 4 6 2 3 3 4 2 6 6 6 3 5 3 3 5 2 1 1 6 1 2 2 6 4 6 2 1 3 4 2
第一行的10,6是工件数和机器数。
第二行第一个加粗的数字6表示，工件1有6道工序。斜体的2 1 5 3 4，表示工件1的第一道工序有两个可选机器，分别是1和3，加工时间是5和4，后面的3 5 3 3 5 2 1表示工件1的第二道工序有3个可选机器，分别是5,3,2，加工时间是3,5,1，一行就是1个工件的所有工序的可选机器可加工时间，后面的工序以此类推。
下面的每一行以此类推。本系列算例MK01.txt数据文件可在gitee仓库下载：
https://gitee.com/XZDNF-1618/data.git
数学模型
假设条件：
- 1、同一台机器同一时刻只能加工一个工件;
- 2、同一工件的同一道工序在同一时刻被加工的机器数是一;
- 3、任意工序开始加工不能中断;
- 4、各个工件之间不存在的优先级的差别;
- 5、同一工件的工序之间存在先后约束，不同工件的工序之间不存在先后约束;
- 6、所有工件在零时刻都可以被加工。
数学模型
字符说明：
目标函数：
约束条件：
柔性作业车间工具
本文写了甘特图的画图函数；工序，机器，加工时间编码的生成函数；编码的解码函数。甘特图和解码前面推文有介绍，为了能在灰狼算法使用，下面介绍一下编码的生成：
- 步骤1：按照工件的工序数依次生成工序编码如下：
work = [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9]
程序里为方便运算，0表示工件1，依次类推。
- 步骤2：随机打乱work得到如下编码：
job= [7, 1, 7, 9, 4, 6, 4, 2, 4, 6, 5, 0, 5, 1, 1, 5, 1, 6, 3, 2, 4, 9, 2, 3, 8, 8, 4, 0, 0, 7, 7, 6, 1, 8, 9, 0, 2, 9, 3, 6, 8, 7, 5, 8, 9, 9, 3, 4, 3, 2, 5, 5, 0, 0, 8]
job就是一个可行工序编码。
代码在fjsp.py里。
机器和加工时间编码：
随机生成0到1之间的数，如果该随机数小于pi，工序选择加工时间最小的机器，否则随机选择加工机器，pi自行调整。
非支配排序遗传算法-NSGA-II的非支配排序及拥挤度
就当前很多组合优化问题，如车间调度，路径优化等问题。运用非精确算法如粒子群算法、遗传算法、蚁群算法解决问题时，我们总需要经过多次迭代才能找到问题的解。每一次迭代时，总会挑选一个或多个优秀的个体指导着目标优化的方向。对于单目标问题，个体的优劣判断比较容易，即目标值的大小。而多目标问题，因为涉及多个目标，很难判断个体的优劣。就遗传算法解决多目标车间调度问题来说，初始化一定规模的种群，但因为我们无法判断个体的优劣，适应度就无法设计，算法最开始的选择操作都无法进行。当然，pareto解肯定是种群的优秀个体，但其规模，分布情况等，只选择其作为向下迭代的种群是不可行的。
非支配排序遗传算法-NSGAII是2000年提出的，在遗传算法的基础上对选择再生方法进行改进：将每个个体按照他们的支配与非支配关系进行再分层，提出了拥挤度和拥挤度比较算子，代替了需要指定共享半径的适应度共享策略，并在快速排序后的同级比较中作为胜出标准，使准Pareto域中的个体能扩展到整个Pareto域，并均匀分布，保持了种群的多样性。最后再做遗传操作，从而达到求解多目标的问题。
简单来说，就是对多个解按照支配关系进行分层，每层又按照拥挤度大小进行排列，这样就能判断每个个体的优劣，其核心是非支配型排序和拥挤度计算。
非支配型排序方法
n(i) 为在种群中支配个体 i 的解个体的数量。S(i) 为被个体 i 所支配的解个体的集合。
- 首先，找到种群中所有 n(i)=0 的个体，将它们存入当前集合F(1)；
- 然后对于当前集合 F(1) 中的每个个体 j，考察它所支配的个体集 S(j)，将集合 S(j) 中的每个个体 k 的 n(k) 减去1，即支配个体 k 的解个体数减1(因为支配个体 k 的个体 j 已经存入当前集 F(1) )；
- 如 n(k)-1=0则将个体 k 存入另一个集H。最后，将 F(1) 作为第一级非支配个体集合，并赋予该集合内个体一个相同的非支配序 i(rank)，然后继续对 H 作上述分级操作并赋予相应的非支配序，直到所有的个体都被分级。其计算复杂度为O(mN^{2})，m为目标函数个数，N为种群大小。
简单来说，假设有两个解p,q，如果p支配q，则q放到p支配的集合S§ 即里，且n(q)在原来的等级基础上上升一个等级。
分层的逻辑:层级为0的个体是最优的一层，把层级为0的个体取出来之后，被该层支配的所有个体等级减1，以此类推，不断取出等级为0的个体，最终所有剩余个体的等级都会为0，分层结束。
拥挤度计算
密度估计：对同一个前沿面的解集合按各个目标分量大小排序，计算每个解在该分量下的两侧点的距离差值，而后进行累加各个分量上的距离作为拥挤系数。
经过快速非支配排序和拥挤度计算，种群中的每一个个体都得到了两个属性：非支配序rank和拥挤度crowd。利用这两个属性，我们可以区分种群中间任意两个个体间的支配和非支配关系。定义拥挤度比较算子，当且仅当i_rank>j_rank或i_rank=j_rank且i_crowd>j_crowd，有个体i优于个体j。为了简化，直接把个体优劣的比较写进拥挤度程序里。为了更好排序，把每层两端的点的拥挤度设为100000和100001，一层只有一个个体时，因为不存在同级的比较，拥挤度设为1。
具体的介绍自行查阅资料，前面的推文也讲到。
非支配排序遗传算法设计
简单来说：每次迭代以上一次迭代得到种群为基础，工序编码pox交叉后根据拥挤度比较淘汰一半个体，机器编码均匀交叉根据拥挤度淘汰一半个体，第一次迭代以初始种群为基础。
算法步骤：
- 步骤1：初始化多个工序，机器，加工时间编码，解码得到加工时间、机器负荷和能耗
- 步骤2：工序编码进行pox交叉，根据加工时间、机器负荷和能耗，进行非支配排序和拥挤度的计算，淘汰一半个体
- 步骤3：机器编码进行均匀交叉，根据加工时间、机器负荷和能耗，进行非支配排序和拥挤度的计算，淘汰一半个体
- 步骤4：判断是否达到最大迭代次数，是的话输出结果，否则转到步骤2
pox交叉
以mk01为例：初始工件编号为6，对应两个进行交叉的工序编码，0到6基因及其位置保持不变，每个编码6到9的基因位置按顺序填入另一个工序编码6到9的基因。
核心代码：
def job_cross(self,chrom_L1,chrom_L2): #工序的pox交叉
num=list(set(chrom_L1[0]))
np.random.shuffle(num)
index=np.random.randint(0,len(num),1)[0]
jpb_set1=num[:index+1] #固定不变的工件
jpb_set2=num[index+1:] #按顺序读取的工件
C1,C2=np.zeros((1,chrom_L1.shape[1]))-1,np.zeros((1,chrom_L1.shape[1]))-1
sig,svg=[],[]
for i in range(chrom_L1.shape[1]):#固定位置的工序不变
ii,iii=0,0
for j in range(len(jpb_set1)):
if(chrom_L1[0,i]==jpb_set1[j]):
C1[0,i]=chrom_L1[0,i]
else:
ii+=1
if(chrom_L2[0,i]==jpb_set1[j]):
C2[0,i]=chrom_L2[0,i]
else:
iii+=1
if(ii==len(jpb_set1)):
sig.append(chrom_L1[0,i])
if(iii==len(jpb_set1)):
svg.append(chrom_L2[0,i])
signal1,signal2=0,0 #为-1的地方按顺序添加工序编码
for i in range(chrom_L1.shape[1]):
if(C1[0,i]==-1):
C1[0,i]=svg[signal1]
signal1+=1
if(C2[0,i]==-1):
C2[0,i]=sig[signal2]
signal2+=1
return C1,C2
均匀交叉
均匀交叉算子的概念比较简单，简单说一下逻辑：假设两个解的工序编码的第一道工序分别选择了机器1和3，随机生成0，1两个数中的一个，如果随机数是1，交换两个解第一道工序的机器选择，否则保持原选择。
核心代码：
def mac_cross(self,Ma_W1,Tm_W1,Ma_W2,Tm_W2,WCross): #机器均匀交叉
MC1,MC2,TC1,TC2=[],[],[],[]
for i in range(self.job_num):
MC1.append([]),MC2.append([]),TC1.append([]),TC2.append([]);
for j in range(len(WCross[i])):
if(WCross[i][j]==0): #为0时继承另一个父代的加工机器选择
MC1[i].append(Ma_W1[i][j]),MC2[i].append(Ma_W2[i][j]),TC1[i].append(Tm_W1[i][j]),TC2[i].append(Tm_W2[i][j]);
else: #为1时继承父代的机器选择
MC2[i].append(Ma_W1[i][j]),MC1[i].append(Ma_W2[i][j]),TC2[i].append(Tm_W1[i][j]),TC1[i].append(Tm_W2[i][j]);
return MC1,TC1,MC2,TC2
具体的代码细节在代码在nsga_2.py里。
非支配排序和拥挤度
具体的介绍自行查阅资料，前面的推文也讲到。这里贴一下代码，在mult_opt.py里。
代码：
class mul_op():
def divide(self,answer):
S=[[] for i in range(len(answer))]
front = [[]]
n=[0 for i in range(len(answer))]
rank = [0 for i in range(len(answer))]
for p in range(len(answer)):
for q in range(len(answer)):
# 如果p支配q
if (np.array(answer[p])<=np.array(answer[q])).all() and (answer[p]!=answer[q]):
if q not in S[p]:
S[p].append(q) # 同时如果q不属于sp将其添加到sp中
# 如果q支配p
elif (np.array(answer[p])>=np.array(answer[q])).all() and (answer[p]!=answer[q]):
n[p] = n[p] + 1 # 则将np+1
if n[p]==0:
rank[p] = 0
if p not in front[0]:
front[0].append(p)
i = 0
while(front[i] != []):
Q=[]
for p in front[i]:
for q in S[p]:
n[q] =n[q] - 1 # 则将fk中所有给对应的个体np-1
if( n[q]==0): # 如果nq==0
rank[q]=i+1
if q not in Q:
Q.append(q)
i = i+1
front.append(Q)
del front[len(front)-1]
return front
def dis(self,answer):
crowder,crowd=[],[]
front=self.divide(answer)
for i in range(len(front)):
x=[answer[front[i][j]][0] for j in range(len(front[i]))] #取三个目标函数的各个目标
y=[answer[front[i][j]][1] for j in range(len(front[i]))]
z=[answer[front[i][j]][2] for j in range(len(front[i]))]
sig=front[i]
clo=[[] for j in range(len(front[i]))]
if(len(sig)>1): #每层的个体大于1个做拥挤度计算
x_index,y_index,z_index=np.array(x).argsort(),np.array(y).argsort(),np.array(z).argsort()
x.sort(),y.sort();z.sort()
dis1,dis2,dis3=[],[],[]
dis1.append(100000);dis2.append(100000);dis3.append(100000)
if(len(sig)>2): #大于2个做中间个体的拥挤度计算
for k in range(1,len(sig)-1):
distance1,distance2,distance3=(x[k+1]-x[k-1])/(x[-1]-x[0]),(y[k+1]-y[k-1])/(y[-1]-y[0]),(z[k+1]-z[k-1])/(z[-1]-z[0])
dis1.append(distance1);dis2.append(distance2);dis3.append(distance3)
dis1.append(100001);dis2.append(100001);dis3.append(100001)
crow=[]
x_index=x_index.tolist()
y_index=y_index.tolist()
z_index=z_index.tolist()
for m in range(len(sig)):
index1,index2,index3=x_index.index(m),y_index.index(m),z_index.index(m)
cro=dis1[index1]+dis2[index2]+dis3[index3]
crow.append(cro)
crowd.append(crow)
index=np.array(crow).argsort()
for n in range(len(index)): #拥挤度排列并取出
clo[n]=sig[index[n]]
for o in range(len(clo)-1,-1,-1):
crowder.append(clo[o])
else:
crowder.append(front[i][0])
crowd.append([1])
return front,crowd,crowder
结果
代码运行环境
windows系统，python3.6.0,第三方库及版本号如下：
numpy==1.18.5
matplotlib==3.2.1
第三方库需要在安装完python之后，额外安装，以前文章有讲述过安装第三方库的解决办法。
功率设计
机器的负载和空载功率设计如下：
p1=[2,1.6,1.8,2.4,2.4,4.1]
p2=[0.6,0.6,0.5,0.4,0.4,0.6]
具体的解码在fjsp.py文件里。
主函数
设计主函数如下：
oj=data_deal(10,6) #工件数，机器数
Tmachine,Tmachinetime,tdx,work,tom=oj.cacu()
parm_data=[Tmachine,Tmachinetime,tdx,work,tom]
to=FJSP(10,6,0.5,parm_data) #工件数，机器数，选择最短机器的概率和mk01的数据
oh=mul_op()
ho=nsga_II(50,100,to,oh,work,10) #数50,100,10分别代表迭代的次数、种群的规模、工件数
#to是柔性车间模块，oh是多目标模块
pareto,pareto_job,pareto_machine,pareto_time,fit_every=ho.nsga_total() #最后一次迭代的最优解
print(pareto)
oh.draw_change(fit_every) #每次迭代过程中pareto解中3个目标的变化
oh.draw_3d(pareto) #结果的3维图
sig=0
job,machine=np.array([pareto_job[sig]]),np.array([pareto_machine[sig]])
machine_time=np.array([pareto_time[sig]])
# C_finish,Twork,E_all,list_M,list_S,list_W,tmax=to.caculate(job,machine,machine_time)
to.draw(job,machine,machine_time)#画pareto解的第一个解的甘特图
运行结果
结果如下：
帕累托解中完工时间、负荷、能耗随迭代次数的变化图如下：
帕累托解的3维图如下：
帕累托解的第一个解的甘特图如下：
代码
有5个py文件和一个mk01的text文档：
完整算法源码+数据：见下方微信公众号：关注后回复：车间调度
# 微信公众号：学长带你飞
# 主要更新方向：1、车辆路径问题求解算法
# 2、学术写作技巧
# 3、读书感悟
# @Author : Jack Hao
公众号二维码：
