1 项目描述
针对带AGV的作业车间调度问题，以最小化完工时间为目标，考虑AGV在装载站、机器、卸载站之间的有效负载时间和空载时间，采用遗传算法进行求解，设计了面向工件运输次数的一维编码，和面向工件运输的驱动解码，以此来联动工件排序和AGV指派两个调度子问题，达到接近最优解的效果。算法采用Bilge和Ulusoy等人设计的40个算例进行验证。
算例下载可前往个人CSDN：机器人作业车间的算例JSP_Transbot.zip-制造文档类资源-CSDN文库进行下载。
2 问题描述
带AGV的作业车间调度问题可描述为：n个工件在m台机器上加工，w台AGV负责工件在机器之间的搬运；每个工件至少有一道工序，每道工序在加工完成后由AGV搬运至下一台机器上进行加工。
对此类问题做如下假设：
（1）机器旁出入缓冲区容量无限大；
（2）所有工件和AGV起始位置和加工完成回到的位置都在L/U站；
（3）不考虑AGV运输过程中的碰撞和故障；
3 算法简述
3.1 编码
编码形式如下，染色体长度为各工序搬运次数的总和，其中VT11表示工件1由L/U站搬运至第一道工序加工处，VT1E表示工序加工完最后一道工序返回L/U站。
3.2 解码
解码采用驱动的方式+间隙解码方法，间隙解码可参考北京科技大学 吴秀丽的某些论文中有提到，贪婪解码的另一种表述。
怎么一个驱动方式呢？
那就是如果这个工件分配了运输任务，那么在运输至下一工序加工机器前，当前工序必须加工完成，以此思想，便可在搬运前驱动该工序加工完成。
3.3 关于AGV的分配
此处由于偷了个小懒，AGV的分配采用随机分配的方式，或者采用最早可用的AGV作为当前搬运工序使用的AGV，这也是算法在某些算例中会陷入局部最优的情形，感兴趣的可加入一维关于AGV的编码。
4 部分算例展示
EX53的算例甘特图如下：
5 部分代码展示
5.1 GA.py
import random
import numpy as np
import os
from utils import RJSP_Env
from Gantt_graph import Gantt
import time
import pickle
class GA:
def __init__(self, args):
# self.Shop_Floor,self.args=RFSP_Env(args)
self.Shop_Floor, self.args = RJSP_Env(args)
self.Pm = 0.2
self.Pc = 0.9
self.Pop_size =200
# 随机产生染色体
def RCH(self):
Chromo1=[]
for i in range(len(self.args.MT)):
Chromo1.extend([i for _ in range(len(self.args.MT[i])-1)])
random.shuffle(Chromo1)
self.args.Chromo_len=len(Chromo1)
Chromo2=[]
# print(Chromo1)
return Chromo1
# 生成初始种群
def CHS(self):
CHS = []
for i in range(self.Pop_size):
CHS.append(self.RCH())
return CHS
# 选择
def Select(self, Fit_value):
Fit = []
for i in range(len(Fit_value)):
fit = 1 / Fit_value[i]
Fit.append(fit)
Fit = np.array(Fit)
idx = np.random.choice(np.arange(len(Fit_value)), size=len(Fit_value), replace=True,
p=(Fit) / (Fit.sum()))
return idx
# 交叉
def Crossover(self, CHS1, CHS2):
Job_list = [i for i in range(self.args.n)]
random.shuffle(Job_list)
r = random.randint(1, self.args.n - 1)
Set1 = Job_list[0:r]
new_CHS1 = list(np.zeros(self.args.Chromo_len, dtype=int))
new_CHS2 = list(np.zeros(self.args.Chromo_len, dtype=int))
for k, v in enumerate(CHS1):
if v in Set1:
new_CHS1[k] = v+1
for i in CHS2:
if i not in Set1:
Site = new_CHS1.index(0)
new_CHS1[Site] = i + 1
for k, v in enumerate(CHS2):
if v not in Set1:
new_CHS2[k] = v + 1
for i in CHS2:
if i in Set1:
Site = new_CHS2.index(0)
new_CHS2[Site] = i + 1
new_CHS1= np.array([j - 1 for j in new_CHS1])
new_CHS2 = np.array([j - 1 for j in new_CHS2])
return new_CHS1,new_CHS2
# 变异
def Mutation(self, CHS):
Tr = [i_num for i_num in range(self.args.Chromo_len)]
# 机器选择部分
r = random.randint(1, self.args.Chromo_len) # 在变异染色体中选择r个位置
random.shuffle(Tr)
T_r = Tr[0:r]
K = []
for i in T_r:
K.append(CHS[i])
random.shuffle(K)
k = 0
for i in T_r:
CHS[i] = K[k]
k += 1
return CHS
#解码
def decode(self,chs,):
self.Shop_Floor.reset()
k = 0
for i in chs:
agv=random.choice([0,1]) #这里目前写的随机，所以得到的结果不是很好，可改成两层编码
K = self.Shop_Floor.scheduling(i,agv)
# Gantt(self.Shop_Floor.Machines, self.Shop_Floor.AGVs)
k += 1
# if done:
# break
return self.Shop_Floor.C_max()
def main(self,target_C=None,file=None):
start=time.time()
BF = []
C = self.CHS()
Fit = []
for C_i in C:
Fit.append(self.decode(C_i))
best_C = None
best_fit = min(Fit)
BF.append(best_fit)
for i in range(100):
C_id = self.Select(Fit)
C = [C[_] for _ in C_id]
for Ci in range(len(C)):
if random.random() < self.Pc:
_C = [C[Ci]]
CHS1, CHS2 = self.Crossover(C[Ci], random.choice(C))
_C.extend([CHS1, CHS2])
Fi = []
for ic in _C:
Fi.append(self.decode(ic))
C[Ci] = _C[Fi.index(min(Fi))]
Fit.append(min(Fi))
elif random.random() < self.Pm:
CHS1 = self.Mutation(C[Ci])
C[Ci] = CHS1
Fit = []
for C_i in C:
fi=self.decode(C_i)
Fit.append(fi)
# Gantt(self.Shop_Floor.Machines, self.Shop_Floor.AGVs)
if fi<=97:
target_C=fi
Gantt(self.Shop_Floor.Machines, self.Shop_Floor.AGVs)
if min(Fit) < best_fit:
best_fit = min(Fit)
best_C = C[Fit.index(min(Fit))]
# print(best_C)
# Gantt(self.Shop_Floor.Machines, self.Shop_Floor.AGVs)
BF.append(best_fit)
# print('迭代次数：',i+1,'完工时间：',best_fit)
x = [_ for _ in range(len(BF))]
# plt.plot(x, BF)
# plt.show()
# best_C.Gantt()
end=time.time()
T=end-start
print('运行时间--->>>>',T)
return best_C,best_fit
if __name__ == "__main__":
import argparse
from Instance.Text_extract import data, data_for_storer
from Instance.data_extract import change
import numpy as np
K=["11",'21','31','41','51','61','71','81','91','101',"12",'22','32','42','52','62','72','82','92','102',
"13",'23','33','43','53','63','73','83','93','103',"14",'24','34','44','54','64','74','84','94','104']
for fi in K:
f='.\Instance\Bilge_Ulusoy\C1\E'+str(53)+'.pkl'
print(f)
n, m, PT, agv_trans, MT, agv_num = data(f)
# n, m, PT, MT=change('la',1)
# agv_trans=[]
# print(agv_trans)
agv_num = 2
parser = argparse.ArgumentParser("Reinforcement Learning experiments for multiagent environments")
# TWO_AGVs_FS_ENV
parser.add_argument("--n", type=int, default=n, help="Job number")
parser.add_argument("--m", type=int, default=m, help="Machine number")
parser.add_argument("--PT", type=list, default=PT, help="PROCESSING TIME OF JOB")
parser.add_argument("--MT", type=list, default=MT, help="PROCESSING TIME OF JOB")
parser.add_argument("--AGV_num", type=int, default=2, help="transportation time between machines")
parser.add_argument("--agv_trans", type=list, default=agv_trans, help="transportation time between machines")
args = parser.parse_args()
print('测试算例:EX',fi)
for i in range(10):
# print( PT, MT)
g = GA(args)
best_C,best_fit=g.main(96)
print(best_fit)
# print(g.RCH())
# g.decode([4, 4 ,0 ,3, 4, 0, 0, 1, 1, 1, 1, 2, 2, 0, 3, 3, 2, 2])
# Gantt(g.Shop_Floor.Machines,g.Shop_Floor.AGVs)5.2 JS_ENV.py
from Flow_Shop_Environment.FS_Env import RFS_Env
from Job_Shop_Environment.JS_Job import Job
import copy
class JS_Env(RFS_Env):
def __init__(self,args):
super().__init__(args)
self.MT=args.MT
def Create_Job(self):
self.Jobs = []
for k in range(self.J_num):
J = Job(k, self.PT[k],self.MT[k])
self.Jobs.append(J)
def reset(self):
self.Create_Item()
for Ji in self.Jobs:
self.Machines[Ji.handling_machine[0]].put_into_job(Ji,0)
Ji.Cur_site=Ji.handling_machine[0]
def scheduling(self,action,agv_num):
done = False
# 空载
agv = self.AGVs[agv_num]
t = agv.end
selected_job = self.Jobs[action]
O_num=copy.copy(selected_job.O_num)
Cur_Machine = self.Machines[selected_job.Cur_site]
target_Machine = self.Machines[selected_job.next_machine()]
trans_t1 = self.agv_trans[agv.Current_Site][Cur_Machine.index]
trans_t2 = self.agv_trans[Cur_Machine.index][target_Machine.index]
# 等待
if selected_job in Cur_Machine.OB:
# 获取AGV的移动开始时间
JS,JE=selected_job.start,selected_job.end
t,trans_t1 = agv.ST_move(selected_job.end, Cur_Machine.index,trans_t1,trans_t2)
else:
JS,JE=Cur_Machine.handling(selected_job)
# 获取AGV的移动开始时间
t,trans_t1 = agv.ST_move(selected_job.end, Cur_Machine.index,trans_t1,trans_t2)
agv.send_to(selected_job.Cur_site, t, trans_t1, load=None)
t1 = t + trans_t1
Cur_Machine.pick_up_job(selected_job)
# 负载转移
agv.send_to(selected_job.next_machine(), t1, trans_t2, load=selected_job.index)
selected_job.Cur_site = selected_job.next_machine()
selected_job.finished_move()
t3 = t1 + trans_t2
selected_job.arrive = t3
target_Machine.put_into_job(selected_job, t3)
if selected_job.Cur_site == self.M_num:
selected_job.J = True
# self.update()
if self.judge_state():
done = True
self.rest_work()
return done,O_num,t,t3,JS,JE
def scheduling1(self,action):
wait_Job_IB, wait_Job_OB=0,0
done = False
# 空载
T=[]
selected_job = self.Jobs[action]
Cur_Machine = self.Machines[selected_job.Cur_site]
target_Machine = self.Machines[selected_job.next_machine()]
Trans=[]
if selected_job not in Cur_Machine.OB:
# 获取AGV的移动开始时间
Cur_Machine.handling(selected_job)
# 获取AGV的移动开始时间
for agv in self.AGVs:
# t = agv.end
trans_t1 = self.agv_trans[agv.Current_Site][Cur_Machine.index]
trans_t2 = self.agv_trans[Cur_Machine.index][target_Machine.index]
Trans.append([trans_t1,trans_t2])
t,trans_t1 = agv.ST_move(selected_job.end, Cur_Machine.index,trans_t1,trans_t2)
T.append(t)
agv=self.AGVs[T.index(min(T))]
t=min(T)
trans_t1,trans_t2=Trans[T.index(min(T))][0],Trans[T.index(min(T))][1]
agv.send_to(selected_job.Cur_site, t, trans_t1, load=None)
t1 = t + trans_t1
wait_Job_IB = selected_job.start - selected_job.arrive
Cur_Machine.pick_up_job(selected_job)
# 负载转移
agv.send_to(selected_job.next_machine(), t1, trans_t2, load=selected_job.index)
# print('这是agv',agv.idx,'动作为',agv._on)
selected_job.Cur_site = selected_job.next_machine()
selected_job.finished_move()
t3 = t1 + trans_t2
selected_job.arrive = t3
target_Machine.put_into_job(selected_job, t3)
if selected_job.Cur_site == self.M_num - 1:
selected_job.J = True
# self.update()
if self.judge_state():
done = True
self.rest_work()
return done, wait_Job_IB, wait_Job_OB
if __name__=="__main__":
from Gantt_graph import Gantt
# from simple_MADRL.Params import args
import random
import pickle
import numpy as np
import argparse
from Env.Instance.Text_extract import data
fee = r"..\Instance\Bilge_Ulusoy\C1\E71.PKl"
n, m, PT, agv_trans, MT, agv_num = data(fee)
# print(PT)
parser = argparse.ArgumentParser("Reinforcement Learning experiments for multiagent environments")
# TWO_AGVs_FS_ENV
parser.add_argument("--n", type=int, default=n, help="Job number")
parser.add_argument("--m", type=int, default=m, help="Machine number")
parser.add_argument("--PT", type=list, default=PT, help="PROCESSING TIME OF JOB")
parser.add_argument("--MT", type=list, default=MT, help="PROCESSING TIME OF JOB")
parser.add_argument("--AGV_num", type=int, default=2, help="transportation time between machines")
parser.add_argument("--agv_trans", type=list, default=agv_trans, help="transportation time between machines")
args = parser.parse_args()
fs=JS_Env(args)
# print(args.PT,args.MT)
fs.reset()
L=[0, 7, 6, 0, 5, 7, 2, 6, 4, 5, 1, 7, 3, 5, 6, 5, 3, 4, 1, 7, 3, 2, 0, 1, 6, 2, 4]
for action in L:
print(action)
K=fs.scheduling1(action)
# Gantt(fs.Machines, fs.AGVs)
# if done:
# break
print(fs.C_max())
Gantt(fs.Machines, fs.AGVs)本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
