多目标柔性车间调度丨mogv算法:以算例MK01为例

车间调度系列文章：

• 1、车间调度的编码、解码，调度方案可视化的探讨

• 2、多目标优化:浅谈pareto寻优和非支配排序遗传算法-NSGAII的非支配排序及拥挤度

• 3、柔性车间调度问题:以算例MK01初探数据处理和多个遗传算子

• 4、车间调度丨粒子群算法初探:以算例MK01为例

• 5、车间调度丨布谷鸟算法改进:以算例MK01为例

• 6、车间调度丨自适应灰狼算法改进：以算例MK01为例

• 7、车间调度丨模拟退火算法改进：以算例MK01为例

• 8、车间调度入门系列资料

• 9、多目标柔性车间调度丨改进灰狼算法:以算例MK01为例

• 10、多目标柔性车间调度丨NSGA-II:以算例MK01为例

• 11、书本算法重现丨遗传算法：以MK01为例

• 12、书本算法重现丨元胞粒子群算法：以MK01为例

• 13、车间调度丨遗传算法求解动态调度问题：重调度

• 14、柔性车间调度问题丨一种贪婪策略的应用:以算例MK02例

• 15、柔性车间调度问题丨教学优化算法和均匀交叉算子:以算例MK01例

• 16、多目标柔性车间调度丨mogv算法:以算例MK01为例

柔性车间调度问题

柔性车间调度问题可描述为：多个工件在多台机器上加工，工件安排加工时严格按照工序的先后顺序，至少有一道工序有多个可加工机器，在某些优化目标下安排生产。柔性车间调度问题的约束条件如下：

• （1）同一台机器同一时刻只能加工一个工件;
• （2）同一工件的同一道工序在同一时刻被加工的机器数是一;
• （3）任意工序开始加工不能中断;
• （4）各个工件之间不存在的优先级的差别;
• （5）同一工件的工序之间存在先后约束，不同工件的工序之间不存在先后约束;
• （6）所有工件在零时刻都可以被加工。

MK01算例：

算例的工件数和机器数分别是10和6。

excel的第一行和第一列是编号，不用考虑，修改与否也不影响。

第一行第一个数字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个工件的所有工序的可选机器可加工时间，后面的工序以此类推。

数学模型

符号定义：

n	工件总数	makespani	工件i的完工时间
m	机器总数	makespan	最大完工时间
i,h	工件号	Load_max	机器总负荷
j,k	工序号	Load_all	总能耗
z	机器号	Xijz	工序oij是否在机器z上加工，为0-1变量，在z上加工为1
qi	工件i的工序数	Gijhk	工序oij和工序ohk的先后顺序，为0-1变量，ij在前为1
oij	工件i的第j道工序	M	一个大正实数
Mij	工序oij的可选机器	Tijz	工序oij在机器z的加工时间
Sij	工序oij的开工时间
Cij	工序oij的完工时间
Load_z	机器负荷

模型：

目标函数：

柔性作业车间工具

工序编码

• 步骤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就是一个可行工序编码。

机器和加工时间编码：

参考文献的3种机器编码生成方法：全局选择、局部选择和随机选择。

对于6个加工机器的mk01。

全局选择：依次安排每个工件的加工，每道工序选择最小负荷的机器。

局部选择：依次安排每个工件的加工，每次安排完一个工件加工后，各个机器的负荷清0，每道工序选择最小负荷的机器。

随机选择：依次安排每个工件的加工，每道工序随机选择可加工机器

核心代码

if r<self.p1 or r>1-self.p2: 
    for k in range(len(n_machine)):
        m=int(n_machine[k])-1
        index_select.append(m)
        t=n_time[k]
        a_global[0,m]+=t               #全局负荷计算
        a_part[0,m]+=t                 #局部负荷计算
    
    if r<self.p1:                       #全局选择
        select=a_global[:,index_select]
        idx_select=np.argmin(select[0])
    else:                               #局部选择
        select=a_part[:,index_select]
        idx_select=np.argmin(select[0])
    m_select=n_machine[idx_select]
    t_index=n_machine.index(m_select)
    machine.append(m_select)
    machine_time.append(n_time[t_index])
else:                                       #否则随机挑选机器                                
    index=np.random.randint(0,len(n_time),1)
    machine.append(n_machine[index[0]])
    machine_time.append(n_time[index[0]])

一次随机生成的机器和加工时间编码如下：

machine=[3.0, 2.0, 6.0, 1.0, 3.0, 4.0, 2.0, 3.0, 1.0, 4.0, 1.0, 2.0, 6.0, 1.0, 3.0, 1.0, 1.0, 2.0, 3.0, 5.0, 6.0, 2.0, 1.0, 2.0, 1.0, 4.0, 6.0, 6.0, 1.0, 2.0, 2.0, 1.0, 4.0, 6.0, 4.0, 3.0, 5.0, 3.0, 6.0, 2.0, 1.0, 2.0, 4.0, 6.0, 1.0, 4.0, 1.0, 2.0, 4.0, 6.0, 2.0, 5.0, 6.0, 4.0, 1.0]

machine_time=[4.0, 1.0, 2.0, 1.0, 1.0, 3.0, 6.0, 1.0, 2.0, 6.0, 1.0, 6.0, 2.0, 1.0, 4.0, 1.0, 1.0, 6.0, 1.0, 3.0, 2.0, 1.0, 1.0, 6.0, 5.0, 6.0, 6.0, 2.0, 2.0, 6.0, 6.0, 1.0, 2.0, 1.0, 2.0, 4.0, 1.0, 1.0, 2.0, 6.0, 1.0, 6.0, 6.0, 1.0, 1.0, 3.0, 2.0, 6.0, 6.0, 2.0, 6.0, 3.0, 1.0, 6.0, 3.0]

由算例知道工件1有6道工序，所以machine和machine_time的前6个数表示工件1的6道工序依次在机器3.0、2.0、6.0、 1.0、 3.0、4.0加工，加工时间是4.0、1.0、2.0、 1.0、1.0、 3.0。小数点是因为数据类型是浮点型，不影响，为了美观也可变为整型。

同理工件2有5道工序，所以machine和machine_time的第7到11个数表示工件2的5道工序依次在机器 2.0、3.0、1.0、4.0、 1.0加工，加工时间是 6.0, 1.0, 2.0, 6.0, 1.0，后续编码依次类推。

插入式解码：

参考文献的介绍：

简单来说：每次安排工序的加工机器，首先找对应加工机器的空闲时间，尽量把工序安排空闲时间里。
核心代码：

if jobtime[0,svg] >0 :                            #如果工序不是第一道工序
    if len(rest[sig])>0 :                         #如果空闲时间非空
        for m in range(len(rest[sig])-1,-1,-1):   #空闲时间从后往前遍历
            if rest[sig][m][1]<=jobtime[0,svg] :  #如果某个空闲时间段小于等于上一道工序的完工时间
                break                             #结束遍历
            else:                                 #否则
                begin=max(jobtime[0,svg],rest[sig][m][0])  #可开工时间是上一道工序的完工时间和空闲片段开始时间最大值
                
                if begin+machine_time[index] <= rest[sig][m][1] : #如果空闲时间段满足要求
                    startime=begin                #更新开工时间
                    signal=1
                    del rest[sig][m]              #删掉空闲时间段
                    break

if signal==0 :                                    #如果不可插入
    startime=max(jobtime[0,svg],tmm[0,sig])       #开工时间是加工机器结束时间和上一道工序完工时间的最大值

if startime>tmm[0,sig] and signal==0:             #如果不可插入且开工时间大于加工机器的完工时间
    rest[sig].append([tmm[0,sig],startime])       #添加时间段到空闲时间里
if signal==0 :                                    #如果不可插入
    tmm[0,sig]=startime+machine_time[index]       #更新机器的结束时间
if signal>0 :                                     #如果可插入
    signal=0                                      #不更新机器结束时间，且可插入信号归零

jobtime[0,svg]=startime+machine_time[index]       #更新工序完工时间
load_m[0,sig]+=machine_time[index]                #更新对应机器的负荷

对本文来说，一次插入成功后，就把当前插入的空闲时间段删除，虽然插入后，时间段仍然可能剩余空闲时间，但认为剩余较短，不考虑。

代码在fjsp.py里。

MOGV算法设计

具体的算法参考文献有介绍，介绍一下步骤：
1、算法步骤：

• 步骤1：固定比例全局选择、局部选择和随机选择3种方式初始多个工序、机器、加工时间编码，并解码

• 步骤2：nsga2的方法计算拥挤距离，pareto解，初始pareto解就为记忆库

• 步骤3：动态概率Pc下从记忆库选择一个个体，种群中轮盘赌选择一个个体，否则1-Pc概率下从种群轮盘赌选取两个个体

• 步骤4：对选择个体的工序编码进行pox交叉，机器编码进行均匀交叉，产生2个新个体

• 步骤5：对新种群的个体，在变异概率Pm下对工序编码进行领域搜索变异，对机器编码进行选择最短加工机器变异

• 步骤6：交叉和变异直到新个体数达到种群规模

• 步骤7：合并记忆库和新种群，nsga2的方法计算拥挤距离，pareto解，新的pareto解为记忆库

• 步骤8：判断是否达到最大迭代次数，是的话输出结果，否则转到步骤3

nsga2的方法可以看以前的推文，相比于原文，减少了记忆库的变领域搜索，因为实现比较麻烦且记忆库已经是比较优秀的解了。

2、轮盘赌选择

轮盘赌法是模拟博彩游戏的轮盘赌，扇形的面积对应它所表示的染色体的适应值的大小，适应度值越大个体被选择的可能性也就越大。轮盘赌法的关键部分是概率和累计概率的计算，具体的步骤如下：

python里实现比较容易，代码如下：

def select(self,num,fit):
    fit=np.array(fit)
    idx=np.random.choice(np.arange(self.popsize),size=num,replace=False,p=fit/fit.sum())
    return idx

返回的是轮盘赌选择出的位置索引，其意思是self.popsize个体中选出num个个体，每个个体的选中概率是fit/fit.sum()，replace=False表示不重复。

本文的fit用的是完工时间分之一，完工时间短，适应度越高，当然，对于多目标问题，可以自行设计适应度计算方式，可以多个目标自行组合等等。

3、工序的pox交叉
以mk01为例：随机0到9的一个数为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

4、机器的均匀交叉

均匀交叉算子的概念比较简单，简单说一下逻辑：假设两个解的工序编码的第一道工序分别选择了机器1和3，随机生成0，1两个数中的一个，如果随机数是1，交换两个解第一道工序的机器选择，否则保持原选择。

代码：

def ma_cross(self,m1,t1,m2,t2):  #机器均匀交叉
    MC1,MC2,TC1,TC2=[],[],[],[]
    for i in range(m1.shape[0]):     
        index=np.random.randint(0,2,1)[0]
        if(index==0):  #为0时继承继承父代的机器选择
            MC1.append(m1[i]),MC2.append(m2[i]),TC1.append(t1[i]),TC2.append(t2[i]);
        else:                #为1时另一个父代的加工机器选择
            MC2.append(m1[i]),MC1.append(m2[i]),TC2.append(t1[i]),TC1.append(t2[i]);
    return MC1,TC1,MC2,TC2

5、领域搜索变异

参考文献的算法步骤和示意图如下：

步骤1： 在变异染色体中随机选择ｒ个不同基因，并生成其排序的所有邻域。

步骤２ 评价所有邻域的适应值，选出最佳个体作为子代。

可以看出，邻域搜索就是对r个基因进行排队，邻域的个数是r!-1,查阅资料，找到一种递归的方法实现这一过程：固定位置的基因不变放到第一个，依次降低r个基因的个数，降低到固定位置的基因和变动位置的基因只有1个时，可变位置与不变位置基因合并。

以上面的[3,1,2]进行介绍：

位置1的基因不变放到第一位，剩余[1,2],

[1,2]只有两个，分别固定第一个位置和第二个位置基因不变，合并得到[1,2]和[2,1]，然后与外层的基因合并得到[3,1,2],和[3,2,1]

[3,1,2]其他位置的邻域也按照这种方法生成：

代码：

def ways(self,mul):
    if len(mul)<2:                          #基因个数降低为1取原值
        return [mul]
    else :                                  #否则遍历基因
        result=[]
        for i in range(len(mul)) :   
            select=mul[i]                   #不变位置
            last=mul[:i]+mul[i+1:]          #可变位置
            for mu in self.ways(last):      #原函数递归，减少基因个数
                result.append([select]+mu)  #合并可变与不变位置的基因
    return result[1:]                       #返回除原位置的所有邻域

输入[3,1,2],结果是[[3, 2, 1], [1, 3, 2], [1, 2, 3], [2, 3, 1], [2, 1, 3]]

本文设计整个邻域搜索变异的逻辑：新解没有完全劣于原解就更新编码

代码：

def job_mul(self,w,m,t):
    r=np.random.randint(2,5,1)[0]                   #2到5随机生成一个数
    mul=random.sample(range(w.shape[0]),r)          #0到55生成不重复的r个位置

    C_finish,load_max,load_all,_,_,_,_=self.to.caculate(w,m,t) 
    t1=[C_finish,load_max,load_all]                  #原编码的目标计算
    
    res=np.arange(r).tolist()
    result=self.ways(res)
    mul=np.array(mul)
    for re in result :                              #位置索引
        w[mul]=w[mul[re]]                           #更新编码
        C_finish,load_max,load_all,_,_,_,_=self.to.caculate(w,m,t)
        t2=[C_finish,load_max,load_all]          #新编码的目标计算
        if (np.array(t2)>np.array(t1)).all() :   #如果新编码的3个目标都劣于原目标，不更新编码
            w[mul[re]]=w[mul]
        else:                                    #否则，更新编码，并更新目标
            t1=t2
    return w,m,t

领域搜索的计算量是巨大的，相当于穷举r个位置的所有排列组合，本文暂时先设为r设为2到5之间，可以自行调整。

6、最短加工机器变异

比较简单，就是工序选择最短加工时间的机器，当然，如果原工序已经选择了最大短加工时间的机器，该变异不会对编码产生改变。

代码：

def ma_mul(self,w,m,t):
    r=np.random.randint(1,w.shape[0]+1,1)[0]  #变异的数量
    mul=random.sample(range(w.shape[0]),r)    #变异的位置
    count=np.zeros((1,self.job_num),dtype=np.int)
    signal=0
    sig=0

    for i in range(len(self.machines)):
        for j in range(self.machines[i]):
            if signal<len(mul) and sig == mul[signal] :
                highs=self.tom[sig][count[0,sig]]
                lows=self.tom[sig][count[0,sig]]-self.tdx[sig][count[0,sig]]
                n_machine=self.Tmachine[sig,lows:highs].tolist()
                n_time=self.Tmachinetime[sig,lows:highs].tolist()

                time=min(n_time)         #最短加工时间的
                index=n_time.index(time)即
                mac=n_machine[index]     #最短加工时间的机器

                m[sig]=mac               #更新编码
                t[sig]=time
                signal+=1
            sig+=1
        return w,m,t

整个算法迭代的核心代码：

Pc=1-gen/self.generation                          #动态交叉概率
fit=[1/answer[k][0] for k in range(len(answer))]  #完工时间分之1做适应度

for i in range(0,self.popsize,2):                #种群规模下每次选2个个体
    if np.random.rand()<Pc:
        loc1=np.random.randint(len(pareto))      #记忆库pareto随机挑选1个个体
        loc2=self.select(1,fit)[0]               #迭代种群中轮盘赌选1个个体
        W1,M1,T1=pareto_job[loc1],pareto_machine[loc1],pareto_time[loc1]
        W2,M2,T2=work_job[loc2],work_M[loc2],work_T[loc2]
    else:
        idx=self.select(2,fit)                   #否则轮盘赌选择2个个体
        loc1,loc2=idx[0],idx[1]
        W1,M1,T1=work_job[loc1],work_M[loc1],work_T[loc1]
        W2,M2,T2=work_job[loc2],work_M[loc2],work_T[loc2]
    W1,W2=self.job_cross(W1,W2)                 #工序交叉
    M1,T1,M2,T2=self.ma_cross(M1,T1,M2,T2)      #机器交叉

    if np.random.rand()<self.Pm :              #变异概率
        W1,M1,T1=self.ma_mul(W1,M1,T1)         #机器变异
        W1,M1,T1=self.job_mul(W1,M1,T1)        #工序变异      
    if np.random.rand()<self.Pm :
        W2,M2,T2=self.ma_mul(W2,M2,T2)
        W2,M2,T2=self.job_mul(W2,M2,T2)

以上所有代码放在MOGV.py里。

7、pareto结果去重

pareto结果会出现重复的目标，可能是因为多个解对应相同的目标，也可能是nsga2的算子设计有问题，或者其他原因。原因暂且不论，为了美观和简洁，对pareto最后的解进行去重，当然，理论上会舍弃一些解，不需要的可以不用这一步。

去重很简单，相当于用新的列表存储原pareto的解，初始新列表为空

每一次遍历原pareto解的元素，如果新列表不存在该元素就添加，否则不添加

代码：

def pareto_simplyfy(self,pareto):
    pareto_un=[]
    index=[]
    for i in range(len(pareto)):
        if pareto[i] not in pareto_un:  #新列表不存在原pareto的元素就添加机器
            pareto_un.append(pareto[i])
            index.append(i)             #记录位置
    return pareto_un,index

代码在multi_opt.py里

结果

代码运行环境
windows系统，python3.6.0,第三方库及版本号如下：

numpy==1.18.5
matplotlib==3.2.1

第三方库需要在安装完python之后，额外安装，以前文章→点击我跳转有讲述过安装第三方库的解决办法。

命令

da=data_deal(10,6)                   #工件数，机器数
Tmachine,Tmachinetime,tdx,work,tom,machines=da.cacu()
parm_data=[Tmachine,Tmachinetime,tdx,work,tom,machines]
fj=FJSP(10,6,0.3,0.4,parm_data)      #工件数，机器数，全局与局部选择的概率和mk01的数据，第三种选择概率是1-0.3-0.4
mu=mul_op()                          #多目标模块                 

parm_mo=[50,100,1]                    #mogv算法的参数，依次是迭代次数，种群规模，变异概率       
mod=[fj,mu]                          #柔性模块和多目标模块
mo=mogv(10,parm_mo,mod,parm_data)    #工件数，算法参数，功能模块，mk01数据
pareto,pareto_job,pareto_machine,pareto_time,fit_every=mo.mog()
print('\n原pareto解：\n',pareto)                        #原pareto结果

pareto_un,index=mu.pareto_simplyfy(pareto)
print('\n去重pareto解：\n',pareto_un)                     #去重pareto结果
job_un,machine_un,time_un=pareto_job[index],pareto_machine[index],pareto_time[index]

mu.draw_change(fit_every)           #每次迭代过程中pareto解中3个目标的变化
mu.draw_3d(pareto)                  #3维图              

sig=0                               #取pareto的第一个解
job,machine,machine_time=job_un[sig],machine_un[sig],time_un[sig]

C_finish,load_max,load_all,list_M,list_S,list_W,tmax=fj.caculate(job,machine,machine_time)
fj.draw(job,machine,machine_time)  #画甘特图

运行结果

一次迭代结果如下：

3个目标的最大、平均、最小值随迭代次数的变化图如下：

3维图：

一个解的甘特图如下：

从结果上看，相同算例下，已经和之前文章已经介绍过的灰狼算法持平，是比较优秀的算法了。

结论

• 本文的工作量较大，涉及的内容较多，有编码、解码、多目标优化、nsga2等等。

• 算法大部分完全是复现原论文，也有自己的设计，文章的算法也有比较详细的介绍，插入式解码和邻域搜索等一些方法是比较不错的，希望对大家的论文有一些参考价值。

• excel数据可更改，工件数、机器数、工件的工序数、工序的可加工机器数等数据对得上就能运行。

• 参考文献：柔性作业车间调度智能算法及其应用-高亮（第七章)

源代码

有5个py文件和一个mk01的excel文件：

篇幅问题，代码附在后面。

演示视频：

多目标求解柔性车间调度问题丨MOGV算法

完整算法源码+数据：见下方微信公众号：关注后回复：车间调度

# 微信公众号：学长带你飞
# 主要更新方向：1、车辆路径和柔性车间调度问题求解算法
#              2、学术写作技巧
#              3、读书感悟
# @Author  : Jack Hao

公众号二维码：