前面的文章，已经给出了遗传算法求解柔性作业车间调度问题的
编码和初始化：
初始版本：https://blog.csdn.net/crazy_girl_me/article/details/108868977（里面有具体的编码解码步骤）
改进链接：https://blog.csdn.net/crazy_girl_me/article/details/114780122
解码：
初始版本：https://blog.csdn.net/crazy_girl_me/article/details/108960996（给出具体流程信息）
改进版本：https://blog.csdn.net/crazy_girl_me/article/details/114787030
今天写一下交叉变异：
1 交叉操作
交叉的目的是利用父代个体经过一定操作组合后产生新个体，在尽量降低有效模式被破坏的概率基础上对解空间进行有效搜索。交叉操作是主要的遗传操作，GA的性能在很大程度上依赖于所使用的交叉操作，它决定了GA的全局搜索能力。GA中常见的交叉操作有：单点交叉（single point crossover,SPX）、多点交叉（multiple point crossover,MPX）、均匀交叉）（uniform crossover,UX）、部分映射交叉（partially mapping crossover,PMX）、次序交叉（order crossover,OX）、线性次序交叉(LOX)、基于位置的交叉(PX)、循环交叉（CX）、基于工件顺序的交叉（POX）。
对FJSP问题：
机器选择部分
代码：
def Crossover_Machine(self,CHS1,CHS2,T0):
T_r=[j for j in range(T0)]
r = random.randint(1, 10) # 在区间[1,T0]内产生一个整数r
random.shuffle(T_r)
R = T_r[0:r] # 按照随机数r产生r个互不相等的整数
# 将父代的染色体复制到子代中去，保持他们的顺序和位置
OS_1=CHS1[T0:2*T0]
OS_2 = CHS2[T0:2 * T0]
C_1 = CHS2[0:T0]
C_2 = CHS1[0:T0]
for i in R:
K,K_2 = C_1[i],C_2[i]
C_1[i],C_2[i] = K_2,K
CHS1=np.hstack((C_1,OS_1))
CHS2 = np.hstack((C_2, OS_2))
return CHS1,CHS2工序排序部分
def Crossover_Operation(self,CHS1, CHS2, T0, J_num):
OS_1 = CHS1[T0:2 * T0]
OS_2 = CHS2[T0:2 * T0]
MS_1 =CHS1[0:T0]
MS_2 = CHS2[0:T0]
Job_list = [i for i in range(J_num)]
random.shuffle(Job_list)
r = random.randint(1, J_num - 1)
Set1 = Job_list[0:r]
Set2 = Job_list[r:J_num]
new_os = list(np.zeros(T0, dtype=int))
for k, v in enumerate(OS_1):
if v in Set1:
new_os[k] = v + 1
for i in OS_2:
if i not in Set1:
Site = new_os.index(0)
new_os[Site] = i + 1
new_os = np.array([j - 1 for j in new_os])
CHS1=np.hstack((MS_1,new_os))
CHS2 = np.hstack((MS_2, new_os))
return CHS1,CHS22 变异部分
变异操作通过随机改变染色体的某些基因对染色体进行较小扰动来生成新的个体，增加种群多样性，并在一定程度上影响着GA的局部搜索能力。
机器选择部分
代码：
def Variation_Machine(self,CHS,O,T0,J):
Tr=[i_num for i_num in range(T0)]
MS=CHS[0:T0]
OS=CHS[T0:2*T0]
# 机器选择部分
r = random.randint(1, T0 - 1) # 在变异染色体中选择r个位置
random.shuffle(Tr)
T_r = Tr[0:r]
for i in T_r:
Job=self.reduction(i,J,T0)
O_i=Job[0]
O_j =Job[1]
Machine_using = O[O_i][O_j]
Machine_time = []
for j in Machine_using:
if j != 9999:
Machine_time.append(j)
Min_index = Machine_time.index(min(Machine_time))
MS[i] = Min_index
CHS=np.hstack((MS,OS))
return CHS工序排序部分：
def Variation_Operation(self, CHS,T0,J_num,J,Processing_time,M_num):
MS=CHS[0:T0]
OS=list(CHS[T0:2*T0])
r=random.randint(1,J_num-1)
Tr=[i for i in range(J_num)]
random.shuffle(Tr)
Tr=Tr[0:r]
J_os=dict(enumerate(OS)) #随机选择r个不同的基因
J_os = sorted(J_os.items(), key=lambda d: d[1])
Site=[]
for i in range(r):
Site.append(OS.index(Tr[i]))
A=list(itertools.permutations(Tr, r))
A_CHS=[]
for i in range(len(A)):
for j in range(len(A[i])):
OS[Site[j]]=A[i][j]
C_I=np.hstack((MS,OS))
A_CHS.append(C_I)
Fit = []
for i in range(len(A_CHS)):
d = Decode(J, Processing_time, M_num)
Fit.append(d.Decode_1(CHS, T0))
return A_CHS[Fit.index(min(Fit))]