基于遗传算法求解ＪＳＰ问题

已于 2022-04-28 12:00:50 修改
阅读量2k 收藏 20
点赞数 7
分类专栏： 智能优化算法 文章标签： 算法
于 2022-01-07 09:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzqingyun/article/details/122357850
版权

🌞欢迎来到智能优化算法的世界 
🌈博客主页：卿云阁

💌欢迎关注🎉点赞👍收藏⭐️留言📝

🌟本文由卿云阁原创！

🌠本阶段属于筑基阶段之一，希望各位仙友顺利完成突破

📆首发时间：🌹2021年1月7日🌹

✉️希望可以和大家一起完成进阶之路！

🙏作者水平很有限，如果发现错误，请留言轰炸哦！万分感谢！

目录

0️⃣基本介绍

1️⃣代码部分

2️⃣结果

​

0️⃣✨✨✨基本介绍✨✨✨

    n 个不同的工件在 m 台机器上加工，其要满足工序约束 ，即每个工件包含了一道或者是多道工序 ，并且同一个工件所经过的工序有先后的顺序 ，每道工序可以在一台或者多台（这里考虑传统的车间作业，即每道工序在一台机器上加工）机器上进行加工，每个工序的加工时间由加工的机器给定。所需满足的约束条件如下：

1、同一时刻、同一机器只能加工一道工序 ；

2、一道工序同一时刻只能在一台机器上加工，且不能中途中断 ；

3、同一工件的工序先后顺序有约束 ，而不同工件加工工序之间没有先后顺序的约束；

4、不同工件之间优先级是相同的；

5、不考虑机器故障等随机性因素。

调度的目标就是确定每个机器上工序的加工顺序和每个工序的开工时间，使得最大完工时间最小或者其他指标达到最优。  

1️⃣✨✨✨代码部分✨✨✨

（1）main.m
function [ bestgen,bestfitness,bestchrom]=main
clc
clear all
close all
%% 定义工件信息
%操作对应时间 可从txt文件中拷贝替换
W=[29 78  9 36 49 11 62 56 44 21;
   43 90 75 11 69 28 46 46 72 30;
   91 85 39 74 90 10 12 89 45 33;
   81 95 71 99  9 52 85 98 22 43; 
   14  6 22 61 26 69 21 49 72 53; 
   84  2 52 95 48 72 47 65  6 25;
   46 37 61 13 32 21 32 89 30 55; 
   31 86 46 74 32 88 19 48 36 79;
   76 69 76 51 85 11 40 89 26 74; 
   85 13 61  7 64 76 47 52 90 45];
%机器工艺约束 可从txt文件中拷贝替换
Q=[1 2 3 4 5 6 7 8 9 10;
   1 3 5 10 4 2 7 6 8 9;
   2 1 4 3 9 6 8 7 10 5;
   2 3 1 5 7 9 8 4 10 6;
   3 1 2 6 4 5 9 8 10 7;
   3 2 6 4 9 10 1 7 5 8;
   2 1 4 3 7 6 10 9 8 5;
   3 1 2 6 5 7 9 10 8 4;
   1 2 4 6 3 10 7 8 5 9;
   2 1 3 7 9 10 6 4 5 8];
 
n=size(W,1);                    %工件数
m=size(Q,1);                    %机器总数
k=m*n;                          %工序总数
 
 
%% 定义遗传算法参数
sizepop=20;                      %种群大小
maxgen=300;                      %最大遗传代数
lenchrom=k;                     %个体长度
GGAP=0.95;                      %代沟
px=0.8;                         %交叉概率
pm=0.01;                        %变异概率
trace=zeros(2,maxgen);          %寻优结果的初始值
gen=0;                          %代计数器
 
%% 个体初始化
individuals=struct('fitness',zeros(1,sizepop),'chrom',[]);
bestgen=1; %适应度最好的染色体出现的代数
trace1=zeros(1,maxgen);%寻优结果的初始值，画图用
%% 初始化种群
ChromTemp=zeros(1,k);
p=k/n; %每个工件的操作数
for i=1:n
    for j=1:p
        t=(i-1)*n+j;
        ChromTemp(1,t)=i;
    end
end  
%% 原始工件序列
for i=1:sizepop
    %随机产生一个种群
    individuals.chrom(i,:)=ChromTemp(randperm(length(ChromTemp))); %随机产生染色体
    x=individuals.chrom(i,:);
    individuals.fitness(i)=makespan(x,n,k,m,W,Q); 
end
fprintf('初始化种群')
individuals.chrom
individuals.fitness
 
%% 找最好的染色体
[bestfitness, bestindex]=min(individuals.fitness);
bestchrom=individuals.chrom(bestindex,:);  %最好的染色体
avgfitness=sum(individuals.fitness)/sizepop; %染色体的平均适应度
trace=[];
 
%% 进化开始
for i=1:maxgen    
    temp1=individuals;
    %选择
    temp2=Select(individuals,sizepop,GGAP);  
    %交叉
    temp2.chrom=Cross(px,temp2.chrom,lenchrom,n);  
    %变异
    temp2.chrom=Mutation(pm,temp2.chrom,lenchrom);  
    %保优
    individuals.chrom=remain(temp1,temp2,sizepop,GGAP);
    
    %计算适应度
    for j=1:sizepop
        x=individuals.chrom(j,:);
        individuals.fitness(j)=makespan(x,n,k,m,W,Q);
    end
    
    %找到最优染色体及它们在种群中的位置
    [newbestfitness,newbestindex]=min(individuals.fitness);
    trace1(1,i)=newbestfitness; %记下每代的最优值
     %代替上一次进化中最好的染色体
    if bestfitness>newbestfitness
        bestfitness=newbestfitness;
        bestchrom=individuals.chrom(newbestindex,:);
        bestgen=i;
    end
    avgfitness=sum(individuals.fitness)/sizepop;
    trace=[trace;avgfitness bestfitness];  %记录每一代最好的适应度和平均适应度   
end %进化结束
 
%% 画甘特图
gant(bestchrom,n,k,m,W,Q); 
%% 画进化图
figure(1);
plot(1:maxgen,trace(:,1),1:maxgen,trace(:,2));
grid on;
legend('适应度平均值','适应度最优值')
xlabel('遗传代数')
ylabel('适应度值')
title('进化过程')
end	

（2）Cross.m
function [ ret ] = Cross( px,chrom,lenchrom,n )
%本函数完成交叉操作
%px input:交叉概率
%chrom input:染色体群
%sizepop input:种群规模
%lenchrom input:染色体长度
%ret output:交叉后的染色体
sizepop=size(chrom,1);
i=1;
randjob=4; %变动工件数
while i<=sizepop   %是否进行交叉操作由交叉概率决定(continue控制)
    %随机选择两个染色体进行交叉
    temp=randperm(sizepop);
    index=temp(1:2);
    s1=chrom(index(1),:);
    s2=chrom(index(2),:);
    %初始化中间片段
    s11=zeros(1,n*2);
    s22=zeros(1,n*2);
    index=zeros(2,n*2);
    %交叉概率决定是否交叉
    pick=rand;
    while pick==0
        pick=rand;
    end
    id1=1;
    id2=1;
    if pick<px
        %随机选择两个工件
        tempjob=randperm(n);
        job1=tempjob(1,1);
        job2=tempjob(1,2);
        job3=tempjob(1,3);
        job4=tempjob(1,4);
        %job5=tempjob(1,5);
        for j=1:lenchrom
            if s1(1,j)==job1
                index(1,id1)=j;
                s11(1,id1)=job1;
                id1=id1+1;    
            end
            if s1(1,j)==job2
                index(1,id1)=j;
                s11(1,id1)=job2;
                id1=id1+1;
            end
            if s1(1,j)==job3
                 index(1,id1)=j;
                 s11(1,id1)=job3;
                 id1=id1+1;
            end     
            if s1(1,j)==job4
                 index(1,id1)=j;
                 s11(1,id1)=job4;
                 id1=id1+1;
            end
           
        end
        for j=1:lenchrom
            if s2(1,j)==job1
                index(2,id2)=j;
                s22(1,id2)=job1;
                id2=id2+1;           
            end
            if s2(1,j)==job2
                index(2,id2)=j;
                s22(1,id2)=job2;
                id2=id2+1;
            end
            if s2(1,j)==job3
                index(2,id2)=j;
                s22(1,id2)=job3;
                id2=id2+1;
            end           
            if s2(1,j)==job4
                index(2,id2)=j;
                s22(1,id2)=job4;
                id2=id2+1;
            end
            
        end        
        %交叉后的第一条染色体
        for j=1:(randjob*n)
            id1=index(1,j);          
            s1(1,id1)=s22(1,j);
        end
        %交叉后的第二条染色体
        for j=1:(randjob*n)
            id2=index(2,j);
            s2(1,id2)=s11(1,j);
        end;
    end
    if i==sizepop   %调整ret染色体数目，控制为奇数
        ret(i,:)=s1;
    else
        ret(i,:)=s1;
        ret((i+1),:)=s2;   
    end
    i=i+2;
end
end
 
(3)gant.m
%% 本函数用来画出最优值的甘特图
%  n input:     工件总数
%  m input:     机器总数
%  k input:     工序总数
%  Q input:     机器序号矩阵,n*k
%  W input:     操作时间矩阵,n*k
%  Y1p output:    各工件各工序的开始时刻，可根据它绘出甘特图
%  Y2p output:    各工件各工序的结束时刻，可根据它绘出甘特图
%  M0      机器空闲时间段的计数
%  M1      机器空闲时间矩阵
%  op_num  工件工序号
 
op_num=ones(1,n);%三个工件待加工的工序号，初始化为1，即从第一道工序开始加工
 
%初始化各工序在机床上对应的开始时间和结束时间
Y1p=zeros(n,m);
Y2p=zeros(n,m);
 
M0=ones(1,m); %计数用，表示各机床的整空闲时间段数量
M1=zeros(m,80); %初始化机床空闲时间矩阵，三行分别对应三台机床。每一行20个数，分为10组，相邻两个数为一组，表示一个空闲时间段的起止时间
for machine_num=1:m
    M1(machine_num,1:2)=[0 2000];
end
%M1(1:m,1:2)=[0 2000;0 2000;0 2000;0 2000;0 2000;0 2000;0 2000;0 2000;0 2000;0 2000]; %设置各个机床的初始空闲时间段
%%活动化安排工序
for r=1:k
    job=chrom(r);%确定当前调度工件
    operation=op_num(1,job);%确定当前调度工序
    machine=Q(job,operation);%确定当前调度机床
    operation_time=W(job,operation);%确定调度工序的加工时间
    %安排当前调度工件的首道工序
    if operation==1
        p=M0(1,machine);%当前调度机床的空闲时间段数量
        for i=1:p
            %该机床第i个空闲时间段的起止时间a和b
            a=M1(machine,i*2-1);
            b=M1(machine,i*2);
            %该工序是否能插入该空闲时间段
            if a+operation_time==b %空闲时间长度等于加工时长
                %确定当前调度工件的起止时间
                Y1p(job,operation)=a;
                Y2p(job,operation)=b;
                %更新第i个空闲时间段的起止时间
                M1(machine,i*2-1)=0;
                M1(machine,i*2)=0;              
                break;
            end;
            if a+operation_time<b %空闲时间长度大于加工时长
                Y1p(job,operation)=a;
                Y2p(job,operation)=a+operation_time;
                M1(machine,i*2-1)=a+operation_time;
                M1(machine,i*2)=b;              
                break;
            end;
        end
    %不是第一道工序   
    else
        p=M0(1,machine);
        for i=1:p
            a=M1(machine,i*2-1);
            b=M1(machine,i*2);
            early=Y2p(job,operation-1); %获取当前调度工序的最早允许加工时间        
            if early<=a %最早允许加工时间早于或等于空闲时间段起始点
                if a+operation_time==b  %从空闲时间段起始点开始加工，空闲时间段结束点正好完成加工
                    Y1p(job,operation)=a;
                    Y2p(job,operation)=b;
                    M1(machine,i*2-1)=0;
                    M1(machine,i*2)=0;                  
                    break;
                end;
                if a+operation_time<b  %从空闲时间段起始点开始加工，空闲时间段结束点前完成加工
                    Y1p(job,operation)=a;
                    Y2p(job,operation)=a+operation_time;
                    M1(machine,i*2-1)=a+operation_time;
                    M1(machine,i*2)=b;                 
                    break;
                end;
            end;
            if early>a %最早允许加工时间迟于空闲时间段起始点
                if early+operation_time==b %从最早允许加工时间开始加工，空闲时间段结束点正好完成加工
                    Y1p(job,operation)=early;
                    Y2p(job,operation)=b;
                    M1(machine,i*2-1)=a;
                    M1(machine,i*2)=early;                   
                    break;
                end;
                if early+operation_time<b %从最早允许加工时间开始加工，空闲时间段结束点前完成加工
                    Y1p(job,operation)=early;
                    Y2p(job,operation)=early+operation_time;
                    M1(machine,i*2-1)=a;
                    M1(machine,i*2)=early;
                    %该空闲被一分为二，更新第二个子空闲时间段，将其排在原空闲时间矩阵最后一个时间段之后
                    M1(machine,p*2+1)=early+operation_time;
                    M1(machine,p*2+2)=b;
                    M0(machine)=M0(machine)+1;%更新该机器的空闲阶段数
                    break;
                end;
            end;
        end         
    end;
    op_num(1,job)=op_num(1,job)+1;%更新工件的待加工工序号  
    finish=max(Y2p);
    minf=finish(1,m);
end;
 
%画甘特图
figure(2);
w=0.5;       %横条宽度 
set(gcf,'color','w'); 
color=[0.97 0.97 1;
       1 0.93 0.83;
       0.69 0.87 0.90;
       1.00 0.84 0;
       0.91 0.58 0.47;
       0.48 0.98 0;
       0.23 0.70 0.44;
       1 0.85 0.72;
       0.61 0.43 1.00;
       0.21 0.35 0.80;
       0.38 0.45 0;
       1 0 0.25;
       0.8 0.25 0.3;
       0.8 0.8 0.1;
       0.75 0.64 0.81];
for job=1:n 
    for operation=1:(k/n)
        operation_time=W(job,operation);
        machine=Q(job,operation);
        x=[Y1p(job,operation) Y1p(job,operation) Y2p(job,operation) Y2p(job,operation)]; 
        y=machine+[-w/2 w/2 w/2 -w/2];
        p=patch('xdata',x,'ydata',y,'facecolor',color(job,:),'edgecolor','k'); 
        txt=sprintf('J%d',job);%将工序号和加工时间连成字符串
        text(Y1p(job,operation)+0.2,machine,txt); 
     end;
end;
xlabel('processing time(s)'); 
ylabel('Machine'); 
axis([0 minf 0 m+1]); 
set(gca,'Box','on'); 
set(gca,'YTick',0:10); 
set(gca,'YTickLabel',{'';num2str((1:m)','M%d');''});  
 
end
 

（4）makespan.m
function [ minf ] = makespan( chrom,n,k,m,W,Q )
%% 本函数用来计算最小化的最大完工时间
%  n input:     工件总数
%  m input:     机器总数
%  k input:     工序总数
%  Q input:     机器序号矩阵,n*k
%  W input:     操作时间矩阵,n*k
%  Y1p output:    各工件各工序的开始时刻，可根据它绘出甘特图
%  Y2p output:    各工件各工序的结束时刻，可根据它绘出甘特图
%  M0      机器空闲时间段的计数
%  M1      机器空闲时间矩阵
%  op_num  工件工序号
 
op_num=ones(1,n);%n个工件待加工的工序号，初始化为1，即从第一道工序开始加工
 
%初始化各工序在机床上对应的开始时间和结束时间
Y1p=zeros(n,m);
Y2p=zeros(n,m);
 
M0=ones(1,m); %计数用，表示各机床的整空闲时间段数量
M1=zeros(m,100); %初始化机床空闲时间矩阵，三行分别对应三台机床。每一行20个数，分为10组，相邻两个数为一组，表示一个空闲时间段的起止时间
for machine_num=1:m
    M1(machine_num,1:2)=[0 2000];
end
%%活动化安排工序
for r=1:k
    job=chrom(r);%确定当前调度工件
    operation=op_num(1,job);%确定当前调度工序
    machine=Q(job,operation);%确定当前调度机床
    operation_time=W(job,operation);%确定调度工序的加工时间
    %安排当前调度工件的首道工序
    if operation==1
        p=M0(1,machine);%当前调度机床的空闲时间段数量
        for i=1:p
            %该机床第i个空闲时间段的起止时间a和b
            a=M1(machine,i*2-1);
            b=M1(machine,i*2);
            %该工序是否能插入该空闲时间段
            if a+operation_time==b %空闲时间长度等于加工时长
                %确定当前调度工件的起止时间
                Y1p(job,operation)=a;
                Y2p(job,operation)=b;
                %更新第i个空闲时间段的起止时间
                M1(machine,i*2-1)=0;
                M1(machine,i*2)=0;              
                break;
            end;
            if a+operation_time<b %空闲时间长度大于加工时长
                Y1p(job,operation)=a;
                Y2p(job,operation)=a+operation_time;
                M1(machine,i*2-1)=a+operation_time;
                M1(machine,i*2)=b;              
                break;
            end;
        end
    %不是第一道工序   
    else
        p=M0(1,machine);
        for i=1:p
            a=M1(machine,i*2-1);
            b=M1(machine,i*2);
            early=Y2p(job,operation-1); %获取当前调度工序的最早允许加工时间        
            if early<=a %最早允许加工时间早于或等于空闲时间段起始点
                if a+operation_time==b  %从空闲时间段起始点开始加工，空闲时间段结束点正好完成加工
                    Y1p(job,operation)=a;
                    Y2p(job,operation)=b;
                    M1(machine,i*2-1)=0;
                    M1(machine,i*2)=0;                  
                    break;
                end;
                if a+operation_time<b  %从空闲时间段起始点开始加工，空闲时间段结束点前完成加工
                    Y1p(job,operation)=a;
                    Y2p(job,operation)=a+operation_time;
                    M1(machine,i*2-1)=a+operation_time;
                    M1(machine,i*2)=b;                 
                    break;
                end;
            end;
            if early>a %最早允许加工时间迟于空闲时间段起始点
                if early+operation_time==b %从最早允许加工时间开始加工，空闲时间段结束点正好完成加工
                    Y1p(job,operation)=early;
                    Y2p(job,operation)=b;
                    M1(machine,i*2-1)=a;
                    M1(machine,i*2)=early;                   
                    break;
                end;
                if early+operation_time<b %从最早允许加工时间开始加工，空闲时间段结束点前完成加工
                    Y1p(job,operation)=early;
                    Y2p(job,operation)=early+operation_time;
                    M1(machine,i*2-1)=a;
                    M1(machine,i*2)=early;
                    %该空闲被一分为二，更新第二个子空闲时间段，将其排在原空闲时间矩阵最后一个时间段之后
                    M1(machine,p*2+1)=early+operation_time;
                    M1(machine,p*2+2)=b;
                    M0(machine)=M0(machine)+1;%更新该机器的空闲阶段数
                    break;
                end;
            end;
        end         
    end;
    op_num(1,job)=op_num(1,job)+1;%更新工件的待加工工序号
end;
    finish=max(Y2p);
    minf=finish(1,m);
end
 



（5）Mutation.m
function [ ret ] = Mutation( pm,chrom,lenchrom )
%本函数完成变异操作
%pm input:变异概率
%chrom input:染色体群
%sizepop input:种群规模
%lenchrom input:染色体长度
%pop input:当前种群的进化代数和最大的进化代数信息
%ret output:变异后的染色体
sizepop=size(chrom,1);
for i=1:sizepop
    %随机选择一个染色体进行变异
    index=randi(sizepop,1,1);
    %变异概率决定该轮循环是否进行变异
    pick=rand;
    if pick<pm
        %选随机选择两个位置交换基因
        pos=randperm(lenchrom);
        pos1=pos(1,1);
        pos2=pos(1,2);
        v=chrom(index,:);
        gene1=v(1,pos1);
        gene2=v(1,pos2);
        v(1,pos1)=gene2;
        v(1,pos2)=gene1;
        chrom(index,:)=v;       
    end
end
ret=chrom;
end
 

（6）Select.m
function [ ret ] = Select( individuals,sizepop,GGAP )
%本函数对每一代种群中的染色体进行选择，以进行后面的交叉和变异。选择方法采用轮盘赌方式
%individuals input:种群信息
%sizepop input:种群规模
%ret output:经过选择后的种群
goodpop=ceil(sizepop*(1-GGAP)); %计算保优个体数
temppop=sizepop-goodpop; %计算临时子代个体数
%% 计算累计概率
individuals.fitness=1./(individuals.fitness);  %求最小值，函数值小的适应度大
sumfitness=sum(individuals.fitness);   %求总适应度
p=individuals.fitness./sumfitness;    %归一化
sump=zeros(1,sizepop);  %初始化累计概率
%计算累计概率
for i=1:sizepop 
    for j=1:i
        sump(1,i)=sump(1,i)+p(j);
    end
end
%% 轮盘赌选择
index=zeros(1,temppop); %记录每次轮盘赌被选择个体的索引号
for i=1:temppop  %转temppop次轮盘
    pick=rand;
    while pick==0
        pick=rand;
    end
    for j=1:sizepop
        if pick<=sump(1,j)   %寻找到落入区间的染色体，其索引号为j
            index(1,i)=j;
            break;
        end
    end
end
%% 产生子种群
ret=struct('fitness',zeros(1,temppop),'chrom',[]);
ret.chrom=individuals.chrom(index,:);
ret.fitness=individuals.fitness(index);
end

2️⃣✨✨✨结果✨✨✨ 

算例

10*10
%工件操作对应时间
W=[29 78  9 36 49 11 62 56 44 21;
   43 90 75 11 69 28 46 46 72 30;
   91 85 39 74 90 10 12 89 45 33;
   81 95 71 99  9 52 85 98 22 43; 
   14  6 22 61 26 69 21 49 72 53; 
   84  2 52 95 48 72 47 65  6 25;
   46 37 61 13 32 21 32 89 30 55; 
   31 86 46 74 32 88 19 48 36 79;
   76 69 76 51 85 11 40 89 26 74; 
   85 13 61  7 64 76 47 52 90 45];
%机器工艺约束
Q=[1 2 3 4 5 6 7 8 9 10;
   1 3 5 10 4 2 7 6 8 9;
   2 1 4 3 9 6 8 7 10 5;
   2 3 1 5 7 9 8 4 10 6;
   3 1 2 6 4 5 9 8 10 7;
   3 2 6 4 9 10 1 7 5 8;
   2 1 4 3 7 6 10 9 8 5;
   3 1 2 6 5 7 9 10 8 4;
   1 2 4 6 3 10 7 8 5 9;
   2 1 3 7 9 10 6 4 5 8];

6*6
%操作对应时间
W=[1 3  6  7  3 6;
   8 5 10 10 10 4;
   5 4  8  9  1 7;
   5 5  5  3  8 9;
   9 3  5  4  3 1;
   3 3  9 10  4 1];
%机器工艺约束
Q=[3 1 2 4 6 5;
   2 3 5 6 1 4;
   3 4 6 1 2 5;
   2 1 3 4 5 6;
   3 2 5 6 1 4;
   2 4 6 1 5 3];
3*3
%操作对应时间
W=[5 1 3;
   2 1 4;
   3 6 8];
%机器工艺约束
Q=[1 3 2;
   2 1 3;
   3 1 2];

卿云阁
关注
专栏目录
【老生谈算法】MATLAB实现车间作业调度问题（JSP）遗传算法通用源码——JSP
m0_53407570的博客
06-03 804
车间作业调度问题（JSP）是一类满足任务配置和顺序约束要求的资源分配问题，是最难的组合优化问题之一。下面的MATLAB源代码可用于求解标准JSP问题，虽然采用的是最普通的遗传算法，但在编解码环节，采用了十分巧妙的设计，可以大幅提高搜索效率。 源代码运行结果展示： 车间作业调度问题matlab源码如下，有需要的朋友可以点击进行下载............
遗传算法实现的JSP作业调度
11-29
用遗传算法实现的JSP调度程序。希望对人工智能初学者有用。
【车间调度】基于遗传算法求解单件作业生产调度JSP问题，最短完工时间附Matlab代码
最新发布
matlab_dingdang的博客
06-30 505
单件作业生产调度问题 (Job Shop Scheduling Problem，JSP) 是一个经典的组合优化问题，其目标是在有限的资源条件下，合理安排一系列作业在不同机器上的加工顺序，以优化某个目标函数，例如最短完工时间、最小化最大完工时间、最小化总加工时间等。JSP 问题广泛存在于制造业、物流、交通等领域，其求解结果直接影响生产效率和成本控制。本文将针对单件作业生产调度问题，以最短完工时间为目标函数，采用遗传算法进行求解。遗传算法是一种模拟自然界生物进化过程的启发式搜索算法，它通过群体中的个体间的信息交
Python遗传算法解决作业调度问题（JSP）
Juuunn的博客
11-17 5940
import matplotlib.pyplot as plt from collections import OrderedDict import random import copy import datetime jobs = 5 # 工件数 machines = 4 # 机器数 population_num = 10 # 种群规模 population = [] # 初始种群 variation_rate = 0.8 # 变异率 iters = 50 # 进化次数 target_poi
基于遗传算法的车间作业调度（JSP_GA）
12-08
采用基于工序编码的交叉算子，对传统车间调度问题使用遗传算法求解。并采用基准的实例进行验证，例如FT6 或者MT6等。注释比较全面，代码可读性好。
遗传算法求解FJSP问题
Xmmm0569的博客
12-01 1646
工件某工序不能在机器上加工以-1表示，可以的话时间写好 输入形式： [ [[5, 8, 11, -1, -1, -1, -1, -1, 9], [-1, -1, -1, 4, 6, 4, -1, -1, -1], [6, -1, -1, -1, 5, -1, -1, 7, -1], [-1, -1, 5, -1, -1, 5, -1, 8, -1], [11, -1, -1, 9, 4, 8, -1, -1, -1]], [[5, 4, -1, -1, .
JSP中的简单算法
Himalaya-hsf
08-26 1028
冒泡排序 // 有一个数组 数组中都是数值 请从小到大排序 var arr = [10, 189, 999, 20, 14, 6, 88, 190, 54]; // => [6, 10, 14, 20, 54, 88, 190] // 思路： // 循环两两比较 如果第一个数比第二个数大 就换位置 否则不换 /...
基于遗传算法求解车间调度python源码
05-20
JSP问题描述：一个加工系统有M台机器，要求加工N个作业，其中，作业i包含工序数为Li。令，则L为任务集的总工序数。其中，各工序的加工时间已确定，并且每个作业必须按照工序的先后顺序加工。调度的任务是安排所有...
基于独立种群遗传算法求解JSP问题.pdf
11-21
【基于独立种群遗传算法求解JSP问题】 车间调度问题（Job Shop Scheduling Problem，JSP）是一个经典的复杂优化问题，通常出现在生产计划和控制领域。它涉及到多个任务（工件）在多台设备（机器）上的顺序安排，...
车间调度基于matlab遗传算法求解车间调度问题【含Matlab源码 1396期】.zip
12-26
4.4.1 遗传算法GA/蚁群算法ACO车间调度问题JSP 4.4.2 粒子群算法PSO/蛙跳算法SFLA车间调度问题JSP 4.4.3 灰狼算法GWO/狼群算法WPA车间调度问题JSP 4.4.4 鲸鱼算法WOA/麻雀算法SSA车间调度问题JSP 4.4.5 萤火虫算法FA...
遗传算法求解混合流水车间调度问题-Python版，号主自己写的
03-02
在这个特定的场景中，"遗传算法求解混合流水车间调度问题-Python版"是一个应用遗传算法来解决实际工业生产中的调度问题的实例。 混合流水车间调度问题（Hybrid Flow Shop Scheduling Problem, FJSP）是运营管理领域...
模拟退火算法解决置换流水车间调度问题JSP(python实现)-含程序流程图等
06-19
模拟退火算法解决置换流水车间调度问题(python实现) Use Simulated Annealing Algorithm for the basic Job Shop Scheduling Problem With Python 作业车间调度问题（JSP）是计算机科学和运筹学中的一个热门优化问题。它专注于在特定时间将作业分配给有限的资源。模拟退火算法（SSA）是一种基于蒙特卡罗迭代求解策略的通用随机全局搜索优化算法。其出发点是基于物理固体材料退火处理与一般组合优化问题之间的相似性。在一定的初始温度下，结合概率和降温，在解空间中找到目标函数的全局最优解。在本文中，我在JSP上使用了该算法，并通过十个实例得到了调度顺序。
基于关键路径疫苗的免疫遗传算法求解JSP问题.pdf
11-21
基于关键路径疫苗的免疫遗传算法求解JSP问题.pdf
【车间调度】基于matlab NSGA-2算法求解多目标车间调度问题【含Matlab源码 893期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
05-16 4109
NSGA-2算法求解多目标车间调度问题 完整的代码，方可运行；可提供运行操作视频！适合小白！
插入变异的matlab代码实现（遗传算法解JSP）
weixin_51743747的博客
05-24 1368
插入变异的matlab代码实现（遗传算法解JSP）插入变异伪代码matlab代码实现 插入变异 插入变异（insertion mutation）通过将某基因座上的基因插入到染色体的其他基因座上产生新的染色体，具体操作过程如下。 Step1：随机选择一条染色体????； Step2：随机选择染色体????上的一个基因，将这个基因随机移动到染色体中的其他基因座上，生成子代染色体????。 伪代码 顺序选择种群个体，设置变异概率，选择个体中OS编码部分； 产生两个1：D之间的随机数pos1和pos2，判断pos1
JSP相关的一些问题与分析
西召
06-08 6936
JSP作为JavaEE最流行的表现层技术，并非不可替代，实际上随着JavaEE技术的发展，又出现了FreeMaker、Velocity等表现层技术，虽然这些技术可以取代JSP作为表现层的角色，但是JSP作为最早的JavaEE规范之一，JSP依然广泛用于各种Java应用之中。 JSP全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计，它是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似AS
车间作业调度（jsp）智能算法求解精讲
cxw2545724522的博客
06-15 8546
前言 本人之间接触了车间作业调度问题（jsp），凭借好奇之心，看了几篇论文，设计了智能算法进行了求解。 一、经典问题描述 直接借了一张图可以很好的描述经典JSP问题的本质。 其中提及的关键路径的长度就是节拍时间也是生产完工所需的最短时间。我们要优化的目标函数就这个节拍时间，那么如何设计一个优化的逻辑才能得到更短的节拍时间呢？ 二、问题分析与研究 问题分析之前直接上一张由遗传算法优化求解JSP问题的甘特图，其中涉及的经典算例是6个工件在6台机器上加工，且最优解是55。 ..
遗传算法详解与改良遗传算法
saint_mariao的博客
12-10 5287
1.遗传算法简介 遗传算法是用于解决NP难问题如JSP问题，TSP问题常用的启发式算法。上世纪７０年代由美国的John holland提出，是运用计算机仿真，通过交叉变异等方式，模拟自然进化过程搜索最优解的方法。 2.初始种群的选择 在求解取值连续的问题时可使用完全随机的值，但在求解旅行商问题等非连续的问题时通常采用改良圈法，得到一个相对较优的解，然后再利用遗传算法得出最优解。 改良圈法基本原理 对于随机产生的某条路线 Cij=w1w2w3...wu−1wuwu+1...wv−1wvwv+1. C_{ij}
遗传算法解决JSP ft06
09-03
- *1* *2* *3* [【车间调度】基于遗传算法求解车间调度问题（含甘特图）附matlab代码](https://blog.csdn.net/matlab_dingdang/article/details/127835773)[target="_blank" data-report-click={"spm":"1018.2226....
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

卿云阁

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

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

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

打赏作者

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

抵扣说明：

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

余额充值