CN113536202A - Variable neighborhood search method for minimizing total delay time of two-stage assembly scheduling problem - Google Patents

Abstract

The invention provides a variable neighborhood search method for minimizing the total delay time of a two-stage assembly scheduling problem, three greedy strategies are proposed to obtain a good initial search solution, and three neighborhood structures and a variable neighborhood gradient descent strategy are proposed to increase the probability of finding an optimal solution. The disturbance of disturbance strength can be adjusted according to the increase of a search algebra, and the variable neighborhood search algorithm is established by combining an initial variable neighborhood gradient descent algorithm and a disturbance strategy. The invention does not need to spend time to adjust the parameters; when the allowable time is shorter, a satisfactory solution can be obtained, when more time is given, a better solution can be obtained, the disturbance intensity and the disturbance method can be dynamically adjusted along with the searching, and in addition, the disturbance strategy also changes along with the increase of the continuous and unchangeable algebra of the current best solution, so that the local optimum can be better avoided, the influence of random factors is eliminated, and the algorithm is more stable.

Description

Variable neighborhood search method for minimizing total delay time of two-stage assembly scheduling problem

Technical Field

The invention relates to the field of two-stage assembly scheduling, in particular to a variable neighborhood searching method.

Background

Two-stage assembly scheduling problems (TASPs) are widely present in actual factories such as motorcycle production, fertilizer production systems, computer production, database systems, and the like. In recent years, this problem has been studied extensively. Many researchers have ignored the preparation time of the task on the machine when studying this problem or have assumed that the waiting time is independent of the machining sequence and can be included in the machining time. However, for many application scenarios, the preparation time and the processing time are independent of each other. Recently, more and more researchers have become aware of the importance of studying the two-phase assembly scheduling problem with independent preparation time. A two-stage assembly scheduling problem with 1 machine in each of the two stages was studied by Aydiekd et al described in document [1 ] (A.Aydiekk, H.Aydiekand A.Allahvedi, "minimizing maximum results in assembly times with setup times", International Journal of Production Research,2017,55(24): 7541-. In order to minimize the maximum delay, they propose a scheduling algorithm simulating the combination of annealing and insertion operations, and verify the effectiveness of the newly proposed algorithm through experiments. Missing an expiration date may result in a fine, and thus production managers are particularly concerned with minimizing the overall delay time of the task when planning. However, to our knowledge, only the document [ 2 ] (A. Allahverdi, H. Aydilek, and A. Aydilek, "Two-stage assembly scheduling protocol for minimizing total performance with setup times", Applied chemical modeling, 2016,40(17-18), 7796-. Allahvedi et al [ 2 ] propose an N-SA algorithm and an N-PSA algorithm. They also improve The existing algorithm AA-SA [ 3 ] (A. Allahverdi and H. Aydiek, "The two stage assembly flow scheduling protocol to minor total termination", Journal of Intelligent Manufacturing,2015, 26(2), 225-. Experimental results show that N-PSA is better than N-SA and improved algorithms.

The current prior art has the following disadvantages:

1) the parameter is more difficult to adjust, the scheduling performance depends on parameter adjustment, and the parameter setting is irregular and can not be adjusted easily;

2) the searching performance needs to be improved, the searching time of the existing algorithm is short, but the obtained scheduling performance is unstable, the time is good, the time is bad, and the result is difficult to guarantee.

Disclosure of Invention

In order to overcome the defects of the prior art, the invention provides a variable neighborhood search method for minimizing the total delay time of a two-stage assembly scheduling problem, and the invention provides a variable neighborhood search algorithm for the two-stage assembly scheduling problem containing independent preparation time by aiming at minimizing the total delay time. First, three greedy strategies are proposed to obtain a good initial search solution. Second, three neighborhood structures and a variable neighborhood gradient descent strategy are proposed to increase the probability of finding the optimal solution. Thirdly, a disturbance strategy capable of adjusting the disturbance strength according to the increase of the search algebra is provided. Fourthly, the initial variable neighborhood gradient descent algorithm and the disturbance strategy are combined together to establish a variable neighborhood search algorithm. The invention enables better scheduling than the most advanced methods available.

The technical scheme adopted by the invention for solving the technical problem comprises the following steps:

step 1: two-stage assembly, scheduling and modeling;

the two-stage assembly scheduling problem comprises (m +1) machines and n tasks to be processed, wherein each task is composed of (m +1) subtasks, the first m subtasks are processed on the m machines in the first stage in parallel, and the last task is finished on the assembly machine in the second stage after the first m tasks are finished; all tasks in the system are initially processable; the processing of tasks does not allow preemption; the buffer space between the two phases is infinite; one machine can only process one task at most at one time;

let N_g1, 2.., g } represents a set of positive integers of 1-g, where g is a positive integer; j ═ J_i|i∈N_nRepresents a collection of tasks; m ═ M_j|j∈N_m+1Represents a collection of machines; p is a radical of_ijDenotes J_iE.g. J in M_jThe processing time belongs to M; s_ijDenotes J_iE.g. J in M_jPreparation time of E on M; d_iDenotes J_iThe expiration date of (c); sigma₀An initial schedule indicating that no tasks are scheduled; σ denotes the partial schedule after having | σ | tasks scheduled, where | σ | denotes the number of tasks in σ; sigma_uRepresents a set of unscheduled tasks in σ; sigma' represents sigma_uThe index of the task; sigma [ i ]]An index representing the ith task in σ; d_σ[i]Represents the expiration date of the ith task in σ; p is a radical of_σ[i]jDenotes that the ith task in σ is at M_jThe processing time belongs to M; s_σ[i]jDenotes that the ith task in σ is at M_jPreparation time of E on M; sigma_[k]＝{J_σ[1], J_σ[2],...,J_σ[k]}; f (σ) represents the completion time of σ; f. of_j(σ) denotes σ is at M_jThe completion time on the E M; Δ (σ, i) denotes task J_σ[i]Is arranged at M_m+1Up to result in M_m+1Increased idle time; TT (σ) represents the total delay time of σ; σ denotes σ minimizing the total delay time_uArrangement of the tasks;

f_j(σ)(j∈N_m+1) F (σ), and Δ (σ, i) (i ∈ N)_|σ|) The calculation formula of (a) is as follows:

wherein f is_m+1(σ_[0])＝0

f(σ)＝max{f_j(σ)|j∈N_m+1}＝f_m+1(σ)

Task J_σ[j]Delay time calculation ofThe following were used:

TT(σ,j)＝max{0,f_m+1(σ)-d_σ[j]}

thus TT (σ) is calculated as follows:

step 2: three greedy strategies

The task with large delay is prioritized to avoid the delay time of the task from increasing; in addition, moving tasks with deadlines much greater than completion time backward does not increase their latency; based on the inspiration, a greedy strategy is proposed:

greedy strategy 1:

inputting: one partial scheduling σ;

and (3) outputting: one sigma_uPermutation of intermediate tasks σ_u1；

Step 2.1:

(empty set);

step 2.2: if it is not

Entering a cycle of 2.2.1-2.2.3, and ending if not;

step 2.2.1: given J_i∈σ_uLet I (σ, J)_i)＝max{max_j∈Nm{f_j(σ)+t_ij+s_ij},f_m+1(σ)+s_i(m+1)}+ p_i(m+1)-d_i；

Step 2.2.2: find J_k∈σ_uSuch that I (σ, J)_k)＝max{I(σ,J_i)|J_i∈σ}；

Step 2.2.3: will J_kInsert into sigma_u1Tail part, will J_kInserting into the tail part of sigma, inserting J_kFrom σ_uDeleting;

step 2.3: output sigma_u1；

For each non-scheduled task J, in order to better schedule the non-scheduled tasks_i∈σ_uTwo other indicators are given:

(1)

(2)

greedy strategy 2 will σ_uAccording to the index (1) theta₁(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u2Greedy strategy 3 will σ_uAccording to the index (2) theta₂(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u3；

And step 3: variable neighborhood search algorithm

Variable Neighbor Search (VNS) is a meta-heuristic algorithm that systematically searches for different Neighborhood structures to avoid local optimality by invoking a Variable Neighbor Drop (VND) method by the system; if the current best scheduling is still not improved after all the neighborhood structures are tried once, executing a perturbation strategy, and alternately executing the VND and the perturbation strategy until a termination condition is met; the steps of VND, perturbation policy and VNS are as follows:

step 3.1VND

Firstly, three neighborhood structures used in VND are provided, wherein sigma represents a schedule, and x and y belong to N_nRepresents two different positions in σ;

neighborhood 1: swap (σ, x, y), will task σ [ x ]]Move to position y, task σ [ y ]]Move to position x, order

Represents a set of neighborhoods 1;

neighborhood 2: insert (sigma)X, y) if x<y, will task σ [ x]Move to position y, task σ [ x +1 ]],σ[x+2],..., σ[y]Move to position x, x +1,.., y-1, respectively; if x>y, will task σ [ x]Move to position y, task σ [ x-1 ]],σ[x -2],...,σ[y]Move to position x, x-1, ·, y +1, respectively; order to

Representing a neighborhood 2 set;

neighborhood 3: inverse (σ, x, y), if x<y, will task σ [ x]Move to position y, task σ [ y ]]Move to position x, let σ₁Represents the schedule obtained after the move and executes Inverse (σ)₁X +1, y-1); if x>y, return σ, order

Representing a set of neighborhoods 3.

VND first exploration

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

Once the current best solution is updated, the VND is re-started

Starting exploration; if the current best solution isExploration of

If the VND is still not updated, the VND is terminated; the best solution is the solution with the minimum total delay time found currently;

step 3.2 perturbation strategy (Sharking)

The effect of the perturbation strategy is to jump out of local optimality. The intensity of perturbation strategies is usually invariant (Roshanaei V., B. Naderi, F. Jolai, and M. khalili, "A variable neighbor search for job shop scheduling with set-up times to minimize makespan," Future Generation Computer Systems,2009,25(6):654 661). Since the current best solution becomes better as the search proceeds, the difficulty of jumping out of the local optimum becomes greater. Therefore, as the search progresses, the perturbation should be stronger and stronger.

Let q denote the number of times the current best solution has not been updated, q_maxRepresenting the maximum times of no update of the current best solution, sigma representing the scheduling sequence to be disturbed, if q is less than or equal to q_max3, repeating the selection of two positions x and y and performing Swap (σ, x, y) q times; if q is_max/3<q≤2*q_max3, repeating the selection of two positions x and y and performing Insert (σ, x, y) q times; if 2 x q_max/3 <q≤q_maxRepeatedly selecting two positions x and y and performing Inverse (sigma, x, y) q times;

step 3.3VNS

Let three greedy strategies use sigma₀The outputs obtained for the inputs are respectively sigma_u1，σ_u2And σ_u3Let Ω (σ)₀) Is expressed as sigma_u1，σ_u2And σ_u3Scheduling sequence with the smallest total delay time, i.e., TT (omega (sigma))₀))＝min{TT(σ_u1),TT(σ_u2),TT(σ_u3) VNS alternately for Ω (σ)₀) Executing VND and perturbation strategy, and making q represent the number of times that the current best solution is not updated, q_maxRepresenting the maximum number of times that the current best solution is not updated, if the current best solution is updated after the VND is executed, then let q be 1, otherwise let q be 1; if q is q_maxThen VNS resumes from qStarting the search as soon as the CPU time of the VNS operation exceeds a maximum CPU time, T_mThe execution of VNS is terminated.

The specific steps of the VND (σ) are as follows:

inputting: one scheduling σ;

and (3) outputting: best current scheduling σ₁；

Step 3.1.1: let sigma₁＝σ；t＝1；

Step 3.1.2: if t is less than or equal to 3, circularly executing the step 3.1.2.1, and skipping to the step 3.1.3 if t is greater than 3;

step 3.1.2.1: if present

So that

Then let σ₁＝σ₂And t is 1; otherwise, t is added by 1;

step 3.1.3: output sigma₁。

The perturbation strategy Sharking (q, sigma)₁,q_max) The method comprises the following specific steps:

inputting: the number of current iterations q, a schedule σ, and q_max；

And (3) outputting: perturbed scheduling σ₁；

Step 3.2.1: let sigma₁＝σ,i＝1；

Step 3.2.2: if i is less than or equal to q, circularly executing the step 3.2.2.1-3.2.2.3, otherwise, jumping to 3.2.3;

step 3.2.2.1: randomly from N_nTwo positions x and y are selected;

step 3.2.2.2: if q is less than or equal to q_max(v)/3, then let σ ═ Swap (σ, x, y); if q is_max/3<q≤2*q_max(v 3), then let σ Insert (σ, x, y); if 2 x q_max/3<q≤q_maxThen let σ equalInverse(σ,x,y)；

Step 3.2.2.3: adding 1 to i;

step 3.2.3: output sigma₁。

The specific steps of the VNS are as follows:

inputting: omega (sigma)₀),T_m；

And (3) outputting: an optimized scheduling σ₁；

Step 3.3.1: let sigma₁＝VND(σ),q＝1,flag＝true,

Step 3.3.2: if flag is true, then loop through steps 3.3.2.1 and 3.3.2.2, otherwise go to step 3.3.3;

step 3.3.2.1: let q be 1;

step 3.3.2.2: if q is less than or equal to q_maxIf yes, circularly executing the step 3.3.2.2.1-3.3.2.2.4, otherwise, skipping to the step 3.3.3;

step 3.3.2.2.1: let sigma₂＝Sharking(q,σ₁,q_max)；

Step 3.3.2.2.2: let sigma₃＝VND(σ₂)；

Step 3.3.2.2.3: if TT (σ)₃)≤TT(σ₁) If so, let σ₁＝σ₃And q is 1, otherwise, adding 1 to q;

step 3.3.2.2.4: if the CPU time is greater than T_mJump to step 3.3.3, if CPU time is less than or equal to T_mGo to step 3.3.2.2;

step 3.3.3: output sigma₁。

The invention has the beneficial effects that:

(1) the variable neighborhood searching method provided by the invention only comprises one parameter (maximum CPU time), and the maximum CPU time can be set according to actual requirements, so that the method does not need to spend time for parameter adjustment; when the allowable time is smaller, a satisfactory solution can be obtained, and when more time is given, a better solution can be obtained;

(2) the disturbance strength is enhanced along with the increase of the continuous and unchangeable algebra of the current best solution, the disturbance intensity and the disturbance method can be dynamically adjusted along with the search, and in addition, the disturbance strategy also changes along with the increase of the continuous and unchangeable algebra of the current best solution, so that the situation that the current best solution falls into local optimum can be better avoided;

(3) a variable neighborhood search framework is provided, which can search the variable neighborhood by the iteration number q ═ q_maxSearching is started from q to 1 again until the appointed running time is reached, the randomness of the disturbance strategy can be eliminated, and the influence of random factors is eliminated to a certain extent, so that the algorithm is more stable;

(4) three greedy strategies are proposed to obtain a better initial solution, and three neighborhood operations and a neighborhood gradient descent algorithm are proposed to increase the probability of finding an optimal solution.

Detailed Description

The present invention will be further described with reference to the following examples.

Step 1: two-stage assembly, scheduling and modeling;

the two-stage assembly scheduling problem comprises (m +1) machines and n tasks to be processed, wherein each task is composed of (m +1) subtasks, the first m subtasks are processed on the m machines in the first stage in parallel, and the last task is finished on the assembly machine in the second stage after the first m tasks are finished; all tasks in the system are initially processable; the processing of tasks does not allow preemption; the buffer space between the two phases is infinite; one machine can only process one task at most at one time;

let N_g1, 2.., g } represents a set of positive integers of 1-g, where g is a positive integer; j ═ J_i|i∈N_nRepresents a collection of tasks; m ═ M_j|j∈N_m+1Represents a collection of machines; p is a radical of_ijDenotes J_iE.g. J in M_jThe processing time belongs to M; s_ijDenotes J_iE.g. J in M_jPreparation time of E on M; d_iDenotes J_iThe expiration date of (c); sigma₀An initial schedule indicating that no tasks are scheduled; sigma means having aPartial scheduling after | tasks are scheduled, where | σ | represents the number of tasks in σ; sigma_uRepresents a set of unscheduled tasks in σ; sigma' represents sigma_uThe index of the task; sigma [ i ]]An index representing the ith task in σ; d_σ[i]Represents the expiration date of the ith task in σ; p is a radical of_σ[i]jDenotes that the ith task in σ is at M_jThe processing time belongs to M; s_σ[i]jDenotes that the ith task in σ is at M_jPreparation time of E on M; sigma_[k]＝{J_σ[1], J_σ[2],...,J_σ[k]}; f (σ) represents the completion time of σ; f. of_j(σ) denotes σ is at M_jThe completion time on the E M; Δ (σ, i) denotes task J_σ[i]Is arranged at M_m+1Up to result in M_m+1Increased idle time; TT (σ) represents the total delay time of σ; σ denotes σ minimizing the total delay time_uArrangement of the tasks;

f_j(σ)(j∈N_m+1) F (σ), and Δ (σ, i) (i ∈ N)_|σ|) The calculation formula of (a) is as follows:

wherein f is_m+1(σ_[0])＝0

f(σ)＝max{f_j(σ)|j∈N_m+1}＝f_m+1(σ)

Task J_σ[j]The delay time of (d) is calculated as follows:

TT(σ,j)＝max{0,f_m+1(σ)-d_σ[j]}

thus TT (σ) is calculated as follows:

step 2: three greedy strategies

The task with large delay is prioritized to avoid the delay time of the task from increasing; in addition, moving tasks with deadlines much greater than completion time backward does not increase their latency; based on the inspiration, a greedy strategy is proposed:

greedy strategy 1:

inputting: one partial scheduling σ;

and (3) outputting: one sigma_uPermutation of intermediate tasks σ_u1；

Step 2.1:

(empty set);

step 2.2: if it is not

Entering a cycle of 2.2.1-2.2.3, and ending if not;

step 2.2.1: given J_i∈σ_uLet us order

Step 2.2.2: find J_k∈σ_uSuch that I (σ, J)_k)＝max{I(σ,J_i)|J_i∈σ}；

Step 2.2.3: will J_kInsert into sigma_u1Tail part, will J_kInserting into the tail part of sigma, inserting J_kFrom σ_uDeleting;

step 2.3: output sigma_u1；

For each non-scheduled task J, in order to better schedule the non-scheduled tasks_i∈σ_uTwo other indicators are given:

(1)

(2)

greedy strategy 2 will σ_uAccording to the index (1) theta₁(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u2Greedy strategy 3 will σ_uAccording to the index (2) theta₂(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u3；

And step 3: variable neighborhood search algorithm

Variable Neighbor Search (VNS) is a meta-heuristic algorithm that systematically searches for different Neighborhood structures to avoid local optimality by invoking a Variable Neighbor Drop (VND) method by the system; if the current best scheduling is still not improved after all the neighborhood structures are tried once, executing a perturbation strategy, and alternately executing the VND and the perturbation strategy until a termination condition is met; the steps of VND, perturbation policy and VNS are as follows:

step 3.1VND

Firstly, three neighborhood structures used in VND are provided, wherein sigma represents a schedule, and x and y belong to N_nRepresents two different positions in σ;

neighborhood 1: swap (σ, x, y), will task σ [ x ]]Move to position y, task σ [ y ]]Move to position x, order

Represents a set of neighborhoods 1;

neighborhood 2: insert (σ, x, y), if x<y, will task σ [ x]Move to position y, task σ [ x +1 ]],σ[x+2],..., σ[y]Move to position x, x +1,.., y-1, respectively; if x>y, will task σ [ x]Move to position y, task σ [ x-1 ]],σ[x -2],...,σ[y]Move to position x, x-1, ·, y +1, respectively; order to

Representing a neighborhood 2 set;

neighborhood 3: inverse (σ, x, y), if x<y, will task σ [ x]Move to position y, task σ [ y ]]Move to position x, let σ₁Represents the schedule obtained after the move and executes Inverse (σ)₁X +1, y-1); if x>y, return σ, order

Representing a set of neighborhoods 3.

VND first exploration

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

Once the current best solution is updated, the VND is re-started

Starting exploration; if the current best solution is under exploration

Then still has noIf the VND is updated, the VND is terminated; the best solution is the solution with the minimum total delay time found currently;

step 3.2 perturbation strategy (Sharking)

The effect of the perturbation strategy is to jump out of local optimality. The intensity of perturbation strategies is usually invariant (Roshanaei V., B. Naderi, F. Jolai, and M. khalili, "A variable neighbor search for job shop scheduling with set-up times to minimize makespan," Future Generation Computer Systems,2009,25(6):654 661). Since the current best solution becomes better as the search proceeds, the difficulty of jumping out of the local optimum becomes greater. Therefore, as the search progresses, the perturbation should be stronger and stronger.

Let q denote the number of times the current best solution has not been updated, q_maxRepresenting the maximum times of no update of the current best solution, sigma representing the scheduling sequence to be disturbed, if q is less than or equal to q_max3, repeating the selection of two positions x and y and performing Swap (σ, x, y) q times; if q is_max/3<q≤2*q_max3, repeating the selection of two positions x and y and performing Insert (σ, x, y) q times; if 2 x q_max/3 <q≤q_maxRepeatedly selecting two positions x and y and performing Inverse (sigma, x, y) q times;

step 3.3VNS

Let three greedy strategies use sigma₀The outputs obtained for the inputs are respectively sigma_u1，σ_u2And σ_u3Let Ω (σ)₀) Is expressed as sigma_u1，σ_u2And σ_u3Scheduling sequence with the smallest total delay time, i.e., TT (omega (sigma))₀))＝min{TT(σ_u1),TT(σ_u2),TT(σ_u3) VNS alternately for Ω (σ)₀) Executing VND and perturbation strategy, and making q represent the number of times that the current best solution is not updated, q_maxRepresenting the maximum number of times that the current best solution is not updated, if the current best solution is updated after the VND is executed, then let q be 1, otherwise let q be 1; if q is q_maxThen the VNS starts the search again from q ═ 1 once the CPU time for which the VNS is running exceeds a maximum CPU time, i.e. T_mThe execution of VNS is terminated.

The experimental results are as follows:

VNS is realized by C + +, is compiled by MSbuild 4.0, and runs on a personal computer with 3.4-GHz CPU and 16GB memory. The operating system of the computer is Windows 7 professional edition. Allahverdi et al in [ 2 ] verified that the N-PSA algorithm is superior to all existing scheduling algorithms aiming at minimizing the total delay time of the two-stage assembly scheduling problem. Therefore, to verify the effectiveness of VNS, it is only necessary to compare it to N-PSA.

To generate a random two-stage assembly scheduling problem, the number of workpieces n, the number of machines m, the processing time, the preparation time, and the deadline of the workpieces need to be known. The number of workpieces considered in Allahverdi et al in reference [ 2 ] is 50,60,70, 80. The invention contemplates a wider range of workpieces, with n being 30,50,80, 120. The other parameter settings are the same as in document [ 2 ], i.e. m is 5,10, and 12; p is a radical of_ij(i∈N_n,j∈N_m+1) Random from [1,100 ]]Uniformly extracting; s_ij(i∈N_n,j∈N_m+1) Random from [1,100k ]]Uniformly extracting, wherein k is 0,0.5, 1; d_i(i∈N_n) Random slave [ LC_max(1-T-R/2),LC_max(1-T+R/2)]Internal uniform extraction, where T is 0.2,0.4, and 0.6, R is 0.2,0.6, and 1,

a total of 108 sets of m, n, T, and R distinct two-stage assembly scheduling problems are generated, with 10 two-stage assembly scheduling problems within each set. Each 108 groups is a data set, yielding a total of 3 data sets with k values of 0,0.5, and 1, respectively. These two-phase assembly scheduling problems can be downloaded from GitHub with the download link https:// GitHub. com/JianchaoLuo/Results-for-TASPs.

The parameter settings of N-PSA are the same as in literature [ 2 ]. The present application tested two VNS algorithms with maximum run times of 10s and 30s, respectively, denoted as VNS10 and VNS30, respectively.

The best scheduled quantities obtained for the three test data sets, N-PSA, VNS10, and VNS30 are shown in tables 1-3. To save space, only the number of best schedules are listed, and data for detailed schedules and total delay time can be downloaded from the following website: https:// github. com/jianchaoLuo/Results-for-TASPs.

As can be seen from table 1, VNS30 gave the best solution for 992 of the 1080 random two-stage assembly scheduling problems in the k ═ 0 dataset, while VNS10, N-PSA gave the best scheduling of 764 and 413 problems, respectively. As can be seen from table 2, VNS30 gave the best solution for 979 of the 1080 random two-stage assembly scheduling problems in the dataset with k ═ 0.5, while VNS10 and N-PSA gave the best scheduling of 791 and 421 problems, respectively. As can be seen from table 3, VNS30 gave the best solution for 997 of the 1080 random two-stage assembly scheduling problems in the k ═ 1 dataset, while VNS10 and N-PSA gave the best scheduling of 802 and 440 problems, respectively. Clearly, VNS30 performed best, followed by VNS 10. Furthermore, VNS 30's performance is very stable for the two-stage assembly scheduling problem of different parameters. Finally, for the two-stage assembly scheduling problem of n 80 and 120, and T0.6, VNS30 and VNS10 get all the best schedules, which indicates that VNS performs particularly well for the large-scale, close-off-day two-stage assembly scheduling problem.

Table 1 number of optimal solutions obtained for the two-stage fitting scheduling problem N-PSA, VNS10, and VNS30 with k being 0.

Table 2 number of optimal solutions obtained for the two-stage assembly scheduling problem N-PSA, VNS10, and VNS30 with k 0.5.

TABLE 3 number of optimal solutions obtained for the two-stage fitting scheduling problem N-PSA, VNS10, and VNS30 for k ═ 1

To further validate the performance of VNS30 and N-PSA on small scale problems, the present invention randomly generated 120 sets of two-stage assembly scheduling problems with parameters T0.4 and 0.6, R0.6 and 1.0, N6, 7,8,9, and 10, k 0.5 and 1, and m 5,10, and 12, respectively. There are 10 two-stage assembly scheduling problems within each group. Note that the parameter settings for these two-stage assembly scheduling problems are the same as in document [ 2 ]. Optimal scheduling of small scale problems results from a brute force approach. The results of the experiments are shown in tables 4 and 5, where only the average relative error is listed for space saving. The relative error is defined as follows: (total delay time of scheduling obtained by a certain algorithm-total delay time of optimal scheduling)/(total delay time of optimal scheduling + 0.1). Note that to avoid dividing by 0, 0.1 is added to the denominator. The detailed two-stage assembly scheduling problem and the resulting scheduling sequences and total delay times for the scheduling sequences can be downloaded from the following website: https:// github. com/jianchaoLuo/Results-for-TASPs.

As can be seen from tables 4 and 5, N-PSA yields the optimal solution for the 73 out of 120 sets of the two-stage assembly scheduling problem, while VNS30 yields the optimal solution for the 115 out of 120 sets of the two-stage assembly scheduling problem. The average relative error of the N-PSA derived schedule is in the range of 0-0.3802, and the average relative error of the VNS30 derived schedule is in the range of 0-0.00079. Clearly, VNS30 still performed better than N-PSA for small scale problems.

TABLE 4 average relative error of scheduling obtained for small scale problem N-PSA

TABLE 5 average relative error of resulting schedules for the small scale problem VNS30

For most two-phase assembly scheduling problems, the run time of the N-PSA is less than 1s, which is the least time consuming in existing algorithms. To compare VNS and N-PSA with very tight allowable CPU time, VNS with a maximum CPU time of 1s, denoted as VNS1, was further tested on the three data sets mentioned before. A simple comparison is shown in table 6. The detailed two-stage assembly scheduling problem and the resulting scheduling sequences and the total delay times of the scheduling sequences can be downloaded from the following website: https:// github. com/jianchaoLuo/Results-for-TASPs. As can be seen from Table 6, VNS1 performed much better than N-PSA.

TABLE 6 comparison of VNS1 and N-PSA

	Better than	Is equal to	Is worse than
				k＝0	612	415	53
k＝0.5	612	431	37
				k＝1.0	589	439	52

In summary, the present invention has the following advantages:

(1) a new disturbance strategy is provided to dynamically adjust the disturbance intensity and the strategy, so that the situation that the disturbance intensity falls into local optimum is effectively avoided;

(2) a new variable neighborhood searching framework is provided, so that the algorithm can quickly update the current optimal solution and has stable performance;

(3) three greedy strategies, three neighborhood structures and a neighborhood gradient descent algorithm are provided to increase the probability of finding the optimal solution.

Claims (4)

1. A variable neighborhood search method for minimizing the total delay time of a two-stage assembly scheduling problem is characterized by comprising the following steps:

step 1: two-stage assembly, scheduling and modeling;

the two-stage assembly scheduling problem comprises (m +1) machines and n tasks to be processed, wherein each task is composed of (m +1) subtasks, the first m subtasks are processed on the m machines in the first stage in parallel, and the last task is finished on the assembly machine in the second stage after the first m tasks are finished; all tasks in the system are initially processable; the processing of tasks does not allow preemption; the buffer space between the two phases is infinite; one machine can only process one task at most at one time;

let N_g1, 2.., g } represents a set of positive integers of 1-g, where g is a positive integer; j ═ J_i|i∈N_nRepresents a collection of tasks; m ═ M_j|j∈N_m+1Represents a collection of machines; p is a radical of_ijDenotes J_iIs e.g. J atM_jThe processing time belongs to M; s_ijDenotes J_iE.g. J in M_jPreparation time of E on M; d_iDenotes J_iThe expiration date of (c); sigma₀An initial schedule indicating that no tasks are scheduled; σ denotes the partial schedule after having | σ | tasks scheduled, where | σ | denotes the number of tasks in σ; sigma_uRepresents a set of unscheduled tasks in σ; sigma' represents sigma_uThe index of the task; sigma [ i ]]An index representing the ith task in σ; d_σ[i]Represents the expiration date of the ith task in σ; p is a radical of_σ[i]jDenotes that the ith task in σ is at M_jThe processing time belongs to M; s_σ[i]jDenotes that the ith task in σ is at M_jPreparation time of E on M; sigma_[k]＝{J_σ[1],J_σ[2],...,J_σ[k]}; f (σ) represents the completion time of σ; f. of_j(σ) denotes σ is at M_jThe completion time on the E M; Δ (σ, i) denotes task J_σ[i]Is arranged at M_m+1Up to result in M_m+1Increased idle time; TT (σ) represents the total delay time of σ; σ denotes σ minimizing the total delay time_uArrangement of the tasks;

f_j(σ)(j∈N_m+1) F (σ), and Δ (σ, i) (i ∈ N)_|σ|) The calculation formula of (a) is as follows:

wherein f is_m+1(σ_[0])＝0

f(σ)＝max{f_j(σ)|j∈N_m+1}＝f_m+1(σ)

Task J_σ[j]The delay time of (d) is calculated as follows:

TT(σ,j)＝max{0,f_m+1(σ)-d_σ[j]}

thus TT (σ) is calculated as follows:

step 2: three greedy strategies

The task with large delay is prioritized to avoid the delay time of the task from increasing; in addition, moving tasks with deadlines much greater than completion time backward does not increase their latency; based on the inspiration, a greedy strategy is proposed:

greedy strategy 1:

inputting: one partial scheduling σ;

and (3) outputting: one sigma_uPermutation of intermediate tasks σ_u1；

Step 2.1:

(empty set);

step 2.2: if it is not

Entering a cycle of 2.2.1-2.2.3, and ending if not;

step 2.2.1: given J_i∈σ_uLet us order

Step 2.2.2: find J_k∈σ_uSuch that I (σ, J)_k)＝max{I(σ,J_i)|J_i∈σ}；

Step 2.2.3: will J_kInsert into sigma_u1Tail part, will J_kInserted into the tail of sigma, willJ_kFrom σ_uDeleting;

step 2.3: output sigma_u1；

For each non-scheduled task J, in order to better schedule the non-scheduled tasks_i∈σ_uTwo other indicators are given:

(1)

(2)

greedy strategy 2 will σ_uAccording to the index (1) theta₁(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u2Greedy strategy 3 will σ_uAccording to the index (2) theta₂(σ,J_i) Sequencing in ascending order to obtain the sequence sigma_u3；

And step 3: variable neighborhood search algorithm

Variable Neighbor Search (VNS) is a meta-heuristic algorithm that systematically searches for different Neighborhood structures to avoid local optimality by invoking a Variable Neighbor Drop (VND) method by the system; if the current best scheduling is still not improved after all the neighborhood structures are tried once, executing a perturbation strategy, and alternately executing the VND and the perturbation strategy until a termination condition is met; the steps of VND, perturbation policy and VNS are as follows:

step 3.1VND

Firstly, three neighborhood structures used in VND are provided, wherein sigma represents a schedule, and x and y belong to N_nRepresents two different positions in σ;

neighborhood 1: swap (σ, x, y), will task σ [ x ]]Move to position y, task σ [ y ]]Move to position x, order

Represents a set of neighborhoods 1;

neighborhood 2: insert (σ, x, y), if x<y, will task σ [ x]Move to position y, task σ [ x +1 ]],σ[x+2],...,σ[y]Move to position x, x +1,.., y-1, respectively; if x>y, will task σ [ x]Move to position y, task σ [ x-1 ]],σ[x-2],...,σ[y]Move to position x, x-1, ·, y +1, respectively; order to

Representing a neighborhood 2 set;

neighborhood 3: inverse (σ, x, y), if x<y, will task σ [ x]Move to position y, task σ [ y ]]Move to position x, let σ₁Represents the schedule obtained after the move and executes Inverse (σ)₁X +1, y-1); if x>y, return σ, order

Representing a set of neighborhoods 3.

VND first exploration

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

If it is exploring

Later, the current best solution is not updated, and the VND begins exploring

Once the current best solution is updated, the VND is re-started

Starting exploration; if the current best solution is under exploration

If the VND is still not updated, the VND is terminated; the best solution is the solution with the minimum total delay time found currently;

step 3.2 perturbation strategy (Sharking)

The effect of the perturbation strategy is to jump out of local optimality. The intensity of perturbation strategies is usually invariant (Roshanaei V., B.Naderi, F.Jolai, and M.Khalii, "A variable neighbor search for job shop scheduling with set-up times to minimize makespan," Future Generation Computer Systems,2009,25(6):654 661). Since the current best solution becomes better as the search proceeds, the difficulty of jumping out of the local optimum becomes greater. Therefore, as the search progresses, the perturbation should be stronger and stronger.

Let q denote the number of times the current best solution has not been updated, q_maxRepresenting the maximum times of no update of the current best solution, sigma representing the scheduling sequence to be disturbed, if q is less than or equal to q_max3, repeating the selection of two positions x and y and performing Swap (σ, x, y) q times; if q is_max/3<q≤2*q_max3, repeating the selection of two positions x and y and performing Insert (σ, x, y) q times; if 2 x q_max/3<q≤q_maxRepeatedly selecting two positions x and y and performing Inverse (sigma, x, y) q times;

step 3.3VNS

Let three greedy strategies use sigma₀The outputs obtained for the inputs are respectively sigma_u1，σ_u2And σ_u3Let Ω (σ)₀) Is expressed as sigma_u1，σ_u2And σ_u3Scheduling sequence with the smallest total delay time, i.e., TT (omega (sigma))₀))＝min{TT(σ_u1),TT(σ_u2),TT(σ_u3) VNS alternately for Ω (σ)₀) Enforcing VND and perturbation policiesLet q denote the number of times the current best solution has not been updated, q_maxRepresenting the maximum number of times that the current best solution is not updated, if the current best solution is updated after the VND is executed, then let q be 1, otherwise let q be 1; if q is q_maxThen the VNS starts the search again from q ═ 1 once the CPU time for which the VNS is running exceeds a maximum CPU time, i.e. T_mThe execution of VNS is terminated.

2. The variable neighborhood search method of minimizing the total delay time of a two-stage assembly scheduling problem of claim 1, wherein:

the specific steps of the VND (σ) are as follows:

inputting: one scheduling σ;

and (3) outputting: best current scheduling σ₁；

Step 3.1.1: let sigma₁＝σ；t＝1；

Step 3.1.2: if t is less than or equal to 3, circularly executing the step 3.1.2.1, and skipping to the step 3.1.3 if t is greater than 3;

step 3.1.2.1: if present

So that

And TT (sigma)₂)<TT(σ₁) Then let σ₁＝σ₂And t is 1; otherwise, t is added by 1;

step 3.1.3: output sigma₁。

3. The variable neighborhood search method of minimizing the total delay time of a two-stage assembly scheduling problem of claim 1, wherein:

the perturbation strategy Sharking (q, sigma)₁,q_max) The method comprises the following specific steps:

inputting: the number of current iterations q, a schedule σ, and q_max；

And (3) outputting: perturbed scheduling σ₁；

Step 3.2.1: let sigma₁＝σ,i＝1；

Step 3.2.2: if i is less than or equal to q, circularly executing the step 3.2.2.1-3.2.2.3, otherwise, jumping to 3.2.3;

step 3.2.2.1: randomly from N_nTwo positions x and y are selected;

step 3.2.2.2: if q is less than or equal to q_max(v)/3, then let σ ═ Swap (σ, x, y); if q is_max/3<q≤2*q_max(v 3), then let σ Insert (σ, x, y); if 2 x q_max/3<q≤q_maxLet σ equal Inverse (σ, x, y);

step 3.2.2.3: adding 1 to i;

step 3.2.3: output sigma₁。

4. The variable neighborhood search method of minimizing the total delay time of a two-stage assembly scheduling problem of claim 1, wherein:

the specific steps of the VNS are as follows:

inputting: omega (sigma)₀),T_m；

And (3) outputting: an optimized scheduling σ₁；

Step 3.3.1: let sigma₁＝VND(σ),q＝1,flag＝true,

Step 3.3.2: if flag is true, then loop through steps 3.3.2.1 and 3.3.2.2, otherwise go to step 3.3.3;

step 3.3.2.1: let q be 1;

step 3.3.2.2: if q is less than or equal to q_maxIf yes, circularly executing the step 3.3.2.2.1-3.3.2.2.4, otherwise, skipping to the step 3.3.3;

step 3.3.2.2.1: let sigma₂＝Sharking(q,σ₁,q_max)；

Step 3.3.2.2.2: let sigma₃＝VND(σ₂)；

Step 3.3.2.2.3: if TT (σ)₃)≤TT(σ₁) If so, let σ₁＝σ₃And q is 1, otherwise, adding 1 to q;

step 3.3.2.2.4: if the CPU time is greater than T_mJump to step 3.3.3, if CPU time is less than or equal to T_mGo to step 3.3.2.2;

step 3.3.3: output sigma₁。