用python实现改进遗传算法求解FJSP问题的完整编码

最新推荐文章于 2024-03-30 10:11:08 发布
最新推荐文章于 2024-03-30 10:11:08 发布
阅读量6.9k 收藏 58
点赞数 16
分类专栏： # Python实现车间调度或论文 论文阅读与实现 文章标签： 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazy_girl_me/article/details/108997109
版权

学习目标：

上两篇内容写了遗传算法求解FJSP算法的编码和初始化以及解码方式，今天把完整的算法代码放上来，与大家一块学习。

完整研究可参考：基于遗传算法求解柔性作业车间调度问题代码实现（包括标准算例准换、编码、解码的详细讲述）_crazy_girl_me的博客-CSDN博客

算法的基本步骤：

1

2

代码：

import numpy as np
import matplotlib.pyplot as plt
import random
import itertools

#全局初始化
def Global_initial(T0,O,GS,MS,n,M,OS_list,OS):
    Machine_time = np.zeros(M,dtype=int)          # 机器时间初始化
    for i in range(GS):
        random.shuffle(OS_list)  # 生成工序排序部分
        OS[i] = np.array(OS_list)
        GJ_list=[]
        for GJ_Num in range(n):         #工件集
            GJ_list.append(GJ_Num)
        random.shuffle(GJ_list)
        for g in GJ_list:    # 随机选择工件集的第一个工件,从工件集中剔除这个工件
            h = np.array(O[g])  # 第一个工件含有的工序
            for j in range(len(h)):  # 从工件的第一个工序开始选择机器
                D = np.array(h[j])
                List_Machine_weizhi = []
                for k in range(len(D)):  # 每道工序可使用的机器以及机器的加工时间
                    Useing_Machine = D[k]
                    if Useing_Machine == 9999:  # 确定可加工该工序的机器
                        continue
                    else:
                        List_Machine_weizhi.append(k)
                Machine_Select = []
                for Machine_add in List_Machine_weizhi:  # 将这道工序的可用机器时间和以前积累的机器时间相加
                    Machine_time[Machine_add] = Machine_time[Machine_add] + D[
                        Machine_add]  # 比较可用机器的时间加上以前累计的机器时间的时间值，并选出时间最小
                    Machine_Select.append(Machine_time[Machine_add])
                Min_time=min(Machine_Select)
                Machine_Index_add = Machine_Select.index(Min_time)
                MS[i][g*3+j] =Machine_Index_add + 1

    CHS1=np.hstack((MS,OS))
    return CHS1
#局部选择
def Local_initial(T0,O,LS,MS,n,M,OS_list,OS):
    for i in range(LS):
        random.shuffle(OS_list)  # 生成工序排序部分
        OS_gongxu = OS_list
        OS[i] = np.array(OS_gongxu)
        GJ_list=[]
        for GJ_Num in range(n):         #工件集
            GJ_list.append(GJ_Num)
        A=0
        for gon in GJ_list:
            Machine_time = np.zeros(M)          # 机器时间初始化
            g = gon                      # 随机选择工件集的第一个工件   #从工件集中剔除这个工件
            h = np.array(O[g])  # 第一个工件及其对应工序的加工时间
            for j in range(len(h)):  # 从工件的第一个工序开始选择机器
                D = np.array(h[j])
                List_Machine_weizhi = []
                for k in range(len(D)):  # 每道工序可使用的机器以及机器的加工时间
                    Useing_Machine = D[k]
                    if Useing_Machine == 9999:  # 确定可加工该工序的机器
                        continue
                    else:
                        List_Machine_weizhi.append(k)
                Machine_Select = []
                for Machine_add in List_Machine_weizhi:  # 将这道工序的可用机器时间和以前积累的机器时间相加
                    Machine_time[Machine_add] = Machine_time[Machine_add] + D[Machine_add]  # 比较可用机器的时间加上以前累计的机器时间的时间值，并选出时间最小
                    Machine_Select.append(Machine_time[Machine_add])
                Machine_Index_add = Machine_Select.index(min(Machine_Select))
                MS[i][g*3+j] = MS[i][g*3+j] + Machine_Index_add + 1
                A+=1
    CHS1=np.hstack((MS,OS))
    return CHS1
#随机选择
def Random_initial(T0,O,RS,MS,n,M,OS_list,OS):
    for i in range(RS):
        random.shuffle(OS_list)  # 生成工序排序部分
        OS_gongxu = OS_list
        OS[i] = np.array(OS_gongxu)
        GJ_list=[]
        for GJ_Num in range(n):         #工件集
            GJ_list.append(GJ_Num)
        A=0
        for gon in GJ_list:
            Machine_time = np.zeros(M)          # 机器时间初始化
            g = gon                      # 随机选择工件集的第一个工件   #从工件集中剔除这个工件
            h = np.array(O[g])  # 第一个工件及其对应工序的加工时间
            for j in range(len(h)):  # 从工件的第一个工序开始选择机器
                D = np.array(h[j])
                List_Machine_weizhi = []
                for k in range(len(D)):  # 每道工序可使用的机器以及机器的加工时间
                    Useing_Machine = D[k]
                    if Useing_Machine == 9999:  # 确定可加工该工序的机器
                        continue
                    else:
                        List_Machine_weizhi.append(k)
                Machine_Select = []
                for Machine_add in List_Machine_weizhi:  # 将这道工序的可用机器时间和以前积累的机器时间相加
                    Machine_time[Machine_add] = Machine_time[Machine_add] + D[
                        Machine_add]  # 比较可用机器的时间加上以前累计的机器时间的时间值，并选出时间最小
                    Machine_Select.append(Machine_time[Machine_add])
                Machine_Index_add = Machine_Select.index(random.choice(Machine_Select))

                MS[i][A] = MS[i][A] + Machine_Index_add + 1
                A+=1
    CHS1=np.hstack((MS,OS))
    return CHS1
#染色体解码
#JM与T的关系是一一对应的
def Chromosome_decoding(CHS,O,T0,n):
    JM = np.zeros((4, 3), dtype=int)  # JM(j,h)表示工件Ji的工序Oh的机器号
    T = np.zeros((4, 3), dtype=int)  # T（j,h）表示工件Jj的工序Oh的加工时间

    # 步骤1：对机器选择部分进行解码，从左到右依次读取并转换成机器顺序矩阵JM和时间顺序矩阵T
    MS = CHS[0:12]
    OS = CHS[12:24]
    GX_num = 0
    for J_j in MS:  # 将机器选择部分转换成机器顺序矩阵和时间顺序矩阵
        GX_num += 1
        JM_j = int((GX_num-1) / 3)  #机器顺序矩阵的横坐标
        JM_h = int((GX_num-1) % 3)       #机器顺序矩阵的纵坐标
        O_j =np.array(O[JM_j][JM_h])
        Mac_using = []
        Mac_time = []
        for Mac_num in range(len(O_j)):  # 寻找MS对应部分的机器时间和机器顺序
            if O_j[Mac_num] != 9999:
                Mac_using.append(Mac_num)
                Mac_time.append(O_j[Mac_num])
            else:
                continue
        JM[JM_j][JM_h] += Mac_using[J_j-1]  # 机器顺序矩阵
        T[JM_j][JM_h] += Mac_time[J_j-1]  # 时间顺序矩阵

    # 步骤2：按照步骤1对应的T和JM依次得到每个工件工序对应的加工机器和加工时间
    Start_time=np.zeros((6,12),dtype=int)   #机器开始加工的时间
    End_time=np.zeros((6,12),dtype=int)     #机器结束加工的时间
    Opearation = np.zeros((6, 12), dtype=int)

    Counter_List=[]
    T_count=0
    for OS_j in OS:  # 通过机器顺序矩阵和时间顺序矩阵的到工序的加工机器和加工时间
        T_count+=1
        Counter_List.append(OS_j)
        M_i_h=Counter_List.count(OS_j)      #该工件的第几道工序
        M_i = JM[OS_j-1][M_i_h-1]         #这道工序使用的机器
        P_ij=T[OS_j-1][M_i_h-1]             #这道工序的加工时间
        M_n_list=[]
        for M_n in End_time[M_i]:     #确定工序为机器M_i的第几道加工工序
            if M_n!=0:
                M_n_list.append(M_n)
        # 工件O_jh是机器M_i的第一道加工工序，直接从机器M_i的零时刻进行加工
        if M_i_h==1 and len(M_n_list)==0 :
            Start_time[M_i][T_count-1]=0
            End_time[M_i][T_count-1]+=P_ij
            Opearation[M_i][T_count-1]=OS_j
        # 工序O_jh是机器M_i的第一道工序
        elif len(M_n_list)==0 and M_i_h>1:
            #寻找该工件上一道工序的完工时间：
            SD_Machine=JM[OS_j-1][M_i_h-2]
            SD_count=0
            SD_c=0
            for SD_i in OS:
                SD_count+=1
                if SD_i==OS_j:
                    SD_c+=1
                    if SD_c==M_i_h-1:
                        break

            S=End_time[SD_Machine][SD_count-1]
            Start_time[M_i][T_count - 1] =S
            End_time[M_i][T_count - 1] = S+ P_ij
            Opearation[M_i][T_count - 1] = OS_j

        elif len(M_n_list)!=0 and M_i_h==1:
            List_start_0=[]
            List_end_0=[]
            List_index_0=[]
            for L_i in range(len(End_time[M_i])):
                if End_time[M_i][L_i]!=0:
                    List_start_0.append(Start_time[M_i][L_i])
                    List_end_0.append(End_time[M_i][L_i])
                    List_index_0.append(L_i)
            disp = zip(List_index_0,List_end_0)
            disp_1=zip(List_index_0,List_start_0)
            Disp_1 = dict(disp)
            Disp_2 = dict(disp_1)
            A = sorted(Disp_1.items(), key=lambda item: item[1])
            B = sorted(Disp_2.items(), key=lambda item: item[1])
            D_1= dict(A)
            D_2=dict(B)
            List_start=[]
            List_end=[]
            List_index=[]
            for k in D_1:
                List_end.append(D_1[k])
                List_index.append(k)
            for k_1 in D_2:
                List_start.append(D_2[k_1])
            Lst=[]
            Lst_index=[]
            for L_j in range(len(List_end)-1):
                if List_start[L_j+1]-List_end[L_j]>=P_ij:
                    Lst.append(List_start[L_j+1]-List_end[L_j])
                    Lst_index.append(List_index[L_j])
            if len(Lst)!=0:
                L_m_list = []
                for L_m in Lst:
                    L_m_list.append(L_m)
                    if L_m>=P_ij:
                        L_P=Lst_index[Lst.index(L_m)]
                        Start_time[M_i][T_count - 1]=End_time[M_i][L_P]
                        break
                    while len(L_m_list)==len(Lst):
                        Start_time[M_i][T_count - 1] = max(End_time[M_i])
                        break
            else:
                Start_time[M_i][T_count - 1] = max(End_time[M_i])
            End_time[M_i][T_count-1]=Start_time[M_i][T_count-1]+P_ij
            Opearation[M_i][T_count - 1] = OS_j

        #加工工序不是机器和工件的第一道工序
        else:
            SC_Machine = JM[OS_j - 1][M_i_h - 2]  # 这个工件上一道工序的使用机器
            CO_er = 0
            CON_er = 0
            for Max_i in OS:
                CO_er += 1
                if Max_i == OS_j:
                    CON_er += 1
                    if CON_er == M_i_h - 1:
                        break
            SC_endtime = End_time[SC_Machine][CO_er - 1]  # 这个工件的上一道工序的结束时间
            SD_S=[]
            SD_E=[]
            SD_index=[]
            for SD_i in range(len(End_time[M_i])):
                if End_time[M_i][SD_i]!=0:
                    SD_E.append(End_time[M_i][SD_i])
                    SD_S.append(Start_time[M_i][SD_i])
                    SD_index.append(SD_i)
            disp_2 = zip(SD_index, SD_E)
            disp_3 = zip(SD_index, SD_S)
            Disp_3 = dict(disp_2)
            Disp_4 = dict(disp_3)
            C_1 = sorted(Disp_3.items(), key=lambda item: item[1])
            D_4 = sorted(Disp_4.items(), key=lambda item: item[1])
            D_5 = dict(C_1)
            D_6 = dict(D_4)
            List_start_1 = []
            List_end_1 = []
            List_index_1 = []
            for k_2 in D_5:
                List_end_1.append(D_5[k_2])
                List_index_1.append(k_2)
            for k_3 in D_6:
                List_start_1.append(D_6[k_3])
            Lst_1 = []
            Lst_index_1=[]
            for L_j_1 in range(len(List_end_1) - 1):
                if List_start_1[L_j_1 + 1] - List_end_1[L_j_1]>=P_ij:
                    Lst_1.append(List_start_1[L_j_1 + 1] - List_end_1[L_j_1])
                    Lst_index_1.append(List_index_1[L_j_1])
            if len(Lst_1)!=0:
                L_M_1_list=[]
                for L_M_1 in Lst_1:
                    L_M_1_list.append(L_M_1)
                    if L_M_1 >= P_ij:
                        List_Count_1 = Lst_index_1[Lst_1.index(L_M_1)]
                        L_M= List_index_1[List_index_1.index(List_Count_1)+1]
                        if End_time[M_i][List_Count_1]>=SC_endtime or Start_time[M_i][L_M]-SC_endtime>=P_ij:
                            Start_time[M_i][T_count-1]=End_time[M_i][List_Count_1]
                            break
                    while len(L_M_1_list)==len(Lst_1):
                        if max(End_time[M_i]) >= SC_endtime:
                            Start_time[M_i][T_count - 1] = max(End_time[M_i])
                        else:
                            Start_time[M_i][T_count - 1] = SC_endtime
                        break

            else:
                if max(End_time[M_i])>=SC_endtime:
                    Start_time[M_i][T_count - 1] = max(End_time[M_i])
                else:
                    Start_time[M_i][T_count - 1]=SC_endtime
            End_time[M_i][T_count-1]=Start_time[M_i][T_count-1]+P_ij
            Opearation[M_i][T_count - 1] = OS_j
    return Start_time,End_time,Opearation

#交叉操作
#机器选择部分
def Crossover_Machine(T0,T_r,CHS1,CHS2):



    r=random.randint(0,T0)    #在区间[1,T0]内产生一个整数r
    random.shuffle(T_r)
    R=T_r[0:r]                  #按照随机数r产生r个互不相等的整数
    #将父代的染色体复制到子代中去，保持他们的顺序和位置
    C_1=CHS2
    C_2=CHS1
    for i in R:
        K=CHS1[i]
        K_2=CHS2[i]
        C_1[i]=K
        C_2[i]=K_2
    return C_1,C_2
#工序排序部分
def Crossover_Operation(O_set,CHS1,CHS2):
    r=2
    random.shuffle(O_set)
    O_1=O_set[0:r]      #将工件集划分为Jobset1和Jobset2
    O_2=O_set[r:4]
    C_1=np.zeros(12,dtype=int)
    C_2=np.zeros(12,dtype=int)
    Count_i=0
    Count=0
    C_index1=[]
    C_index2=[]
    for j in CHS1:      #复制父代染色体P1、P2中包含工件集Jobset1/Jobset2中的工件复制到C1/C2中，保持他们的顺序
        Count_i+=1
        for i in O_1:
            if j==i:
                C_1[Count_i-1]=j
    for j_1 in CHS2:
        Count+=1
        for i_1 in O_2:
            if j_1==i_1:
                C_2[Count-1]=j_1
    Count_2=0
    for j_2 in CHS1:
        Count_2+=1
        for i_2 in O_2:
            if j_2==i_2:
                C_index1.append(Count_2-1)
    Count_3=0
    for j_3 in CHS2:
        Count_3+=1
        for i_3 in O_1:
            if j_3==i_3:
                C_index2.append(Count_3-1)
    new_CHS1 = np.delete(CHS1, C_index1)
    new_CHS2 = np.delete(CHS2, C_index2)
    Count_4=0
    for k in range(len(CHS1)):
        if C_1[k]==0:
            C_1[k]=new_CHS2[Count_4]
            Count_4+=1
    Count_5=0
    for k_1 in range(len(CHS2)):
        if C_2[k_1]==0:
            C_2[k_1]=new_CHS1[Count_5]
            Count_5+=1
    return C_1,C_2
#变异操作
#机器变异部分
def Variation_Machine(Tr,O,MS):
    #机器选择部分
    r=random.randint(1,11)        #在变异染色体中选择r个位置
    random.shuffle(Tr)
    T_r=Tr[0:r]
    for i in T_r:
        O_i=int(i/3)
        O_j=i%3
        Machine_using=O[O_i][O_j]
        Machine_index=[]
        for j in Machine_using:
            if j!=9999:
                Machine_index.append(j)
        Min=Machine_index[0]
        Min_index=0
        for j_1 in range(len(Machine_index)):
            if Machine_index[j_1]0:                 #设定结束的约束条件
        Max_Itertions-=1
        S=Select(Fit,POP_SIZE)
        C_I=[]
        for j in S:
            C_I.append(C[j])
        C_J=np.array(C_I)
        P_c=random.uniform(0.6,0.8)     #确定交叉概率
        P_m=random.uniform(0.005,0.006) #确定变异概率
        P_C=int(P_c*(len(S)))
        P_M=int(P_m*(len(S)))
        S_list=np.random.permutation(range(len(S)))
        PC=S_list[0:P_C]
        for k in range(0,len(PC),2):
            CHS_1=C_J[PC[k]]
            if k+1

结果分析：

3

4

码丽莲梦露
关注
  • 16
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
python实现的改进的遗传算法解决工件生产安排
09-05
自己写的改进遗传算法的python程序。
改进遗传算法求解FJSP—西门子极客挑战赛
qq_44776064的博客
10-03 532
例如：有A,B两个零件，A的加工步骤为(A1,A2)，B的加工步骤为（B1,B2), 候选机器为M1, M2, M3。B2在M3的加工时间为4，在M1的加工时间为2. 则根据条件，在初始时刻，我们可以选择开始加工A或B；第二行 6 1 3 2 1 1 3 1 2 6 1 4 7 1 6 3 1 5 3 代表：零件1一共有6个步骤，（1 3 1）表示第一个步骤可以在1台机器上进行加工，机器序号是3，所需时间为1。第一行6 6 1 代表：一共有6个零件，6台机器，每个步骤只能在1台机器上进行加工。
改进差分进化算法及其求解柔性作业车间调度问题（Python代码实现）
weixin_46039719的博客
10-28 1824
柔性作业车间调度问题（Flexible job shop scheduling problem,FJSP）作为一种典型的优化问题,通过启发式算法求解,可以在资源有限的前提下,得到完工时间更小的调度方案。print("按照基于全局与局部初始化策略的DE算法求得的最好的最大完工时间：",min(DE_base))print("按照基于全局与局部初始化策略的DE算法求得的最好的工艺方案：",gbestpop)ax1.set_title("全局最优解的变化情况")ax1.set_xlabel('迭代次数')
柔性作业车间调度问题(Flexible Job Scheduling Problem, FJSP)详细介绍
最新发布
03-30 619
柔性作业车间调度问题（Flexible Job Shop Scheduling Problem，FJSP），是一种经典的组合优化问题。在FJSP问题中，有多个作业需要在多个机器上进行加工，每个作业由一系列工序组成，每个工序需要在特定的机器上完成。同时，每个机器一次只能处理一个工序，且每个工序的处理时间可能不同。FJSP问题的目标是找到一个最优的作业调度方案，使得所有作业的完成时间最小化。这个问题的难点在于需要考虑到多个作业、多个机器和多个工序之间的复杂关系，并且需要在有限的时间内找到最优解。
用python实现基于遗传算法求解柔性作业车间调度问题代码实现（包括标准算例准换、编码、解码、交叉、变异的详细讲述）
热门推荐
太剧烈的快乐与太剧烈的悲哀是有相同之点的——同样地需要远离人群！
06-23 1万+
FJSP标准算例转换代码链接： https://blog.csdn.net/crazy_girl_me/article/details/116058503 GA求解FJSP编码和初始化链接： https://blog.csdn.net/crazy_girl_me/article/details/116058503 绘制甘特图：https://blog.csdn.net/crazy_girl_me/article/details/110895843 GA求解FJSP的交叉变异操作：https://b
麻雀算法SSA解决柔性作业车间调度问题FJSP
weixin_46471774的博客
04-09 1721
柔性作业车间调度问题（flexible job shop scheduling problem，FJSP）的描述如下：ｎ个工件（JJ，…，J）要在ｍ台机器（MM，…，M）上加工；每个工件包含一道或多道工序；工序顺序是预先确定的；每道工序可以在多台不同加工机器上进行加工；工序的加工时间随加工机器的不同而不同；调度目标是为每道工序选择最合适的机器，确定每台机器上各道工序的最佳加工顺序及开工时间，使整个系统的某些性能指标达到最优。
FJSP_柔性车间_FJSP调度_FJSP_matlab
09-11
matlab求解柔性作业车间调度问题 (Flexible Job-shop Scheduling Problem
FJSP 的遗传算法的 Python 实现_python_代码_下载
06-18
一种有效的混合遗传算法和禁忌搜索灵活的车间调度问题
基于Python和笛卡尔遗传规划（Cartesian Genetic Programming, CGP)，对柔性车间调度问题FJSP求解
jsjytc的博客
08-31 1780
前言 实习阶段在研究柔性车间调度，即(Flexible Job-shop Scheduling Problem, FJSP)的问题，公司的前辈已经使用了很多方法实现了对复杂的实际调度问题进行求解。我做的部分主要是在公开数据集上，尝试用遗传规划(Genetic Programming)去求解FJSP问题。经过比对，发现在公开数据集上使用GP方法求解FJSP问题，收敛速度比遗传算法要更快。本文...
【数学建模】实验二【一】Python实现模拟退火算法
远
05-12 869
关于模拟退火算法 这个网上的教程已经很多很详细了，比如 现代优化算法 （一）：模拟退火算法 及应用举例 这里摘取部分，不详述 应用举例 例 已知敌方 100 个目标的经度、纬度如表 1 所示。 数据集下载 链接：https://pan.baidu.com/s/1AmLRAZ4ypbUkUOijWmbCvQ 提取码：ygtl Python代码 我们编写如下的 Python 程序如下： from math import pi, sin, cos, acos, exp import matplotli
改进遗传算法代码
qq_40840797的博客
03-22 314
该算法采用二进制编码，选择了精英保留策略、基于局部优化的交叉和变异算子以及随机扰动机制来保持种群多样性。同时，该算法还采用了多进程并行化的方法，以加快求解速度。
【生产调度】基于遗传算法求解柔性生产调度（FJSP）问题含Matlab源码.zip
04-01
【生产调度】基于遗传算法求解柔性生产调度（FJSP）问题含Matlab源码
基于遗传算法求解车间调度python源码
05-20
作业车间调度问题（Job Shop Scheduling, JSP）是最经典的几个NP-hard问题之一。其应用领域极其广泛，涉及航母调度，机场飞机调度，港口码头货船调度，汽车加工流水线等。 JSP问题描述：一个加工系统有M台机器，要求加工N个作业，其中，作业i包含工序数为Li。令，则L为任务集的总工序数。其中，各工序的加工时间已确定，并且每个作业必须按照工序的先后顺序加工。调度的任务是安排所有作业的加工调度排序，约束条件被满足的同时，使性能指标得到优化。
求解柔性作业车间调度问题 的遗传 算法实现_python_代码_下载
06-19
求解调度问题的遗传算法 求解柔性作业车间调度问题的遗传算法实现 此代码使用遗传算法解决调度问题
用python实现教学算法求解多目标FJSP问题
11-08
这个资源是python实现的教与学算法求解多目标柔性作业车间调度问题的代码
python遗传算法 源代码
11-05
python遗传算法 源代码python遗传算法 源代码python遗传算法 源代码
flexible-job-shop:FJSP遗传算法的Python实现
05-15
FJSP的遗传算法的Python实现。 基于李新宇和高良[1]的论文。 代码结构 该代码旨在按照本文第4节的内容进行阅读。 拟议房委会的工作流程（4.1） main.py 编码和解码（4.2） encoding.py，decoding.py 遗传算子（4.3） 遗传学 通过禁忌搜索进行本地搜索（4.4） 本节已被忽略 终止标准（4.5） 终止 用法 要从Brandimarte数据对Mk02问题运行算法，请执行以下操作： $ python3 main.py test_data/Brandimarte_Data/Text/Mk02.fjs 测试数据可以在上找到。 参考 [1]李新宇和高良。 一种有效的混合遗传算法和禁忌搜索，解决柔性作业车间调度问题。国际生产经济杂志，174：93 – 110，2016
柔性作业车间调度问题 FJSP 常用基准算例
07-12
柔性作业车间调度问题 FJSP 常用基准算例
混合遗传算法求解FJSP柔性作业车间最优化调度问题
01-07
0、柔性作业调用问题介绍 调度问题是制造流程规划和管理中最关键的问题之一。 这个领域最困难的问题之一是作业车间调度问题（Job-shop Scheduling Problem, JSP)，该问题中，一组机器需处理一组工件，每个工件由一系列具有先后顺序约束的工序形成，每个工序只需要一台机器，机器一直可用，可以一次处理一个操作而不会中断。决策内容包括如何对机器上的工序进行排序，已优化给定的性能指标。JSP的典型性能指标是完工时间 (makespan)，即完成所有工作所需的时间。JSP是一个众所周知的NP难题。柔性作业车间调度问题（Flexible Job-shop Scheduling Probl
fjsp python 遗传算法
10-28
遗传算法是一种模拟自然选择和遗传机制的搜索和优化方法，该方法通常用于解决复杂的优化问题。而Python是一种高级编程语言，具有简洁的语法和强大的库支持。因此，使用Python实现遗传算法可以方便地编写和调试算法，并且可以利用其丰富的库来加速算法的运行和优化。 在Python中，首先需要定义问题的适应度函数，它用于评估每个个体的适应程度。然后，定义一些遗传算法的基本操作，如选择、交叉和变异。选择操作根据个体的适应程度来保留一部分较优的个体。交叉操作随机选择两个个体，并通过交换部分遗传信息来产生新的个体。变异操作通过在个体中引入随机变化来增加多样性。 接下来，需要初始化一组个体作为初始种群，并迭代执行选择、交叉和变异操作直至满足停止准则。停止准则可以是达到一定迭代次数或达到问题的最优解。 为了实现这些操作，Python提供了许多功能强大的库，如NumPy用于处理数组和矩阵计算，Matplotlib用于绘制和可视化结果，以及其他一些优化库如DEAP等，可以方便地实现遗传算法的各个步骤。 总结来说，使用Python实现遗传算法可以方便地编写、调试和优化算法，同时利用丰富的库支持，可以快速地实现复杂的优化问题。这对于对遗传算法和优化问题感兴趣的研究人员和工程师来说，是一个非常有吸引力和有用的选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

码丽莲梦露

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

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

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

打赏作者

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

抵扣说明：

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

余额充值