Optimization of the Flow-Shop Scheduling Problem under Time Constraints with PSO Algorithm ^†

Abstract

This study aims to minimize the makespan objective function in a Flow-Shop environment, considering two crucial temporal constraints: “Waiting time” and “Release date”. Given the NP-hardness of this scheduling problem, we employed an enhanced metaheuristic called particle swarm optimization (PSO) to find the optimal solution. Through a series of experiments conducted on a specific set of benchmark instances, we evaluated the performance of our approach by comparing the obtained results against the lower bound (LB). This comparison showcased the effectiveness of our proposed method in addressing this complex scheduling problem.

1. Introduction

In production management, the scheduling optimization process aims to determine a sequence of tasks, taking into consideration various constraints, to enhance productivity and establish a more efficient production system.

Our research stands out due to the integration of two time constraints which are the waiting time and release date, attempting to minimize the makespan criterion. Adding these constraints makes the problem more complex and closer to reality; however, it is well-known as NP-hard according to the literature, making it computationally challenging. In this case, we turn to advanced optimization techniques to find optimal or nearly optimal solutions. One such technique is particle swarm optimization (PSO), a metaheuristic known for its ability to handle complex optimization problems by using the collective intelligence of particles navigating the search space.

In evaluating our research’s effectiveness, we employed our methodology on a series of benchmark tests and used the deviation index (DIV) for a more in-depth analysis of the results. The findings appear to be extremely encouraging.

2. Flow-Shop Scheduling under Waiting Time and Release Date Constraints

In accordance with Graham’s proposed classification, the problem under consideration can be represented as F|r, Wait − Time|C_max.

2.1. Description of the Problem

We have a set of N jobs that need to be assigned and processed on a set of M machines. The objective is to find the optimal sequence of jobs on machines that optimizes the makespan within wait time and release date constraints to improve process efficiency.

Key attributes of a flow shop are:

• Each job follows a production line flow and remains confined to it, traversing all M machines sequentially (ranging from M1 to Mm).
• The production line can manufacture various products.
• Notably, each machine can handle only one task at a given moment, while each job can be processed by only one machine at a time.
• Importantly, task processing occurs continuously, without any interruptions
• The predetermined processing times p_i,j for each task, remain constant throughout.
• Equally, the waiting time and release date for tasks are predetermined and remain consistent.

2.1.1. Makespan Objective Function

In a scheduling problem, the makespan function measures the total duration required to conclude all tasks. Attaining an optimal makespan in the flow shop leads to improved productivity, optimized resource allocation, meeting deadlines, and reduced costs. Several approaches have been proposed to minimize makespan in flow-shop, such as; three metaheuristics (AIS, IG, AIS–IG), that offer improved solutions and scalability [1]. CDS heuristic compared with PSO metaheuristic and a proposed method that combines SPT and permutation rules [2]. A hybrid algorithm combining tabu search with genetic algorithm improves scheduling solutions [3], A novel tie-breaking rule enhances the NEH heuristic, improving scheduling in flow shops efficiently [4].

2.1.2. Wait Time and Release Date Constraints

• The wait time constraint in scheduling determines the maximum allowed time a task can wait after its release before starting the process. Mainly, it resolves conflicts by prioritizing tasks based on urgency or with shorter waiting times. It is used, for example, to wait until the temperature of the part or equipment decreases before further processing.
• The release date specifies the earliest time the task can start and thereby affects task star times. In addition, it contributes to coordinating tasks and ensures that tasks start on time to meet specific scheduling requirements. This constraint is usually used in the assembly process for task coordination.

To our knowledge, no study has yet combined these two constraints, although some research has explored them individually [5,6]. Adding these two constraints increases the problem’s complexity, requiring the use of advanced algorithms, like particle swarm optimization (PSO).

2.2. Mathematical Problem Formulation

To establish the mathematical model for this scheduling problem, we introduce additional notation presented in

Table 1. Parameters and binary variables used in the mathematical model.

Parameter	Signification	Parameter	Signification
$i,j$	Index of jobs	$c$	Completion time
$k$	Index of machines	$s$	Starting time
${\pi }_i$	$i\mathrm{th}$ job in the sequence $\pi$	$w$	waiting time
$n$	Number of jobs to be processed	$r$	Release date
$m$	Number of processing machines	$G$	Large positive number
$p$	Processing time	${\delta }_{{\pi }_i,k}$ ${\mu }_{ijk}$	Take 1; if $i$ is processing on machine $k$, and 0 otherwise Take 1; if $i$ is processed before $j, \left(i\prec j\right)$ on $k$ and 0 otherwise

.

$$C_{max}=min\left(max\left(c_{{\pi }_i,m}\right)\right)\hspace{1em}\hspace{1em} \forall i\in n$$

(1)

$$c_{{\pi }_i,k+1}\ge c_{{\pi }_i,k}+w_{{\pi }_i,k+1}+p_{{\pi }_i,k+1}\hspace{1em}\hspace{1em} \forall i\in n ; k\in m-1$$

(2)

$$c_{{\pi }_j,k}-c_{{\pi }_i,k}+G\left(3-{\delta }_{{\pi }_i,k}-{\delta }_{j,k}-{\mu }_{{\pi }_i,{\pi }_j,k}\right) \ge p_{{\pi }_i,k}+w_{{\pi }_j,k}\hspace{1em}\hspace{1em} \forall i,j\in n ,i\ne j , k\in m$$

(3)

$$c_{{\pi }_i,k}-c_{{\pi }_j,k}+G\left(2-{\delta }_{{\pi }_i,k}-{\delta }_{{\pi }_j,k}-{\mu }_{{\pi }_j,{\pi }_i,k}\right)\ge p_{{\pi }_i,k}+w_{{\pi }_i,k}\hspace{1em}\hspace{1em} \forall i,j\in n ,i\ne j , k\in m$$

(4)

$$c_{1,1}=r_1+p_{1,1}$$

(5)

$$c_{{\pi }_i,1}=max\left(r_{{\pi }_i},c_{{\pi }_{i-1},1}\right)+p_{{\pi }_i,1}\hspace{1em}\hspace{1em} \forall i\in n+1$$

(6)

$${\displaystyle \sum }_{1\le k\le m}{\delta }_{{\pi }_i,k}=m\hspace{1em}\hspace{1em} \forall i\in n$$

(7)

$${\displaystyle \sum }_{1\le i\le n}{\delta }_{{\pi }_i,k}=n\hspace{1em}\hspace{1em} \forall k\in m$$

(8)

(1) The makespan objective function. (2) The succession of the same job on the machines. within a given sequence. (3) And (4) signifying one machine can treat one task at the same time in the same job’s sequence, considering the wait time constraint. (5) Completion time of the first job in the first machine including the release date. (6) Completion time of all jobs in the first machine. (7) A job visits all machines once. (8) Each machine processes only one job at a time.

2.3. Complexity of the Problem

The complexity of the scheduling problem is widely acknowledged in research as being NP-hard beyond five machines m ≥ 5 [7,8,9,10], indicating their challenging nature to resolve. Approaches based on heuristic or metaheuristic methods are necessary to tackle this problem. Although optimality is not guaranteed with these methods, they do provide effective approximations

3. Particle Swarm Optimization (PSO)

The particle swarm optimization (PSO) algorithm, derived from the social dynamics observed in avian and aquatic species, employs particles that represent solutions to explore the multidimensional solution space to attain optimal or near-optimal results. PSO’s efficacy lies in its capacity to strike a balance between exploration and exploitation of the search space, making it adept at addressing complex challenges, inclusive of NP-hard issues. This algorithm has proven its effectiveness in flow-shop scheduling, as showcased in several research studies [11,12,13,14].

4. Experimental Evaluation and Results

To conduct our experiment, we implemented a particle swarm optimization (PSO) algorithm using (MATLAB R2018b) in a computer: Intel(R) Core (TM) i5-7200U CPU, 2.50 GHz, 2.71 GHz,4.00 Go memory, and a database sourced from the following site: https://github.com/chneau/go-taillard/tree/master/instances (accessed on 16 April 2023).

Table 2. Summary table of the found results for all instances.

	Instance	CPU	DIV	Global Fitness	LB
01	20_05	0.9989923	4.491525424	1233	1180
02	20_10	1.198532533	3.875476493	1635	1574
03	20_20	1.469578899	28.16153029	2412	1882
04	50_05	2.479333432	5.095541401	2831	2983
05	50_10	2.824219993	10.24390244	3390	3075
06	50_20	3.489259796	18.55670103	4370	3686
07	100_05	4.850529547	−3.572082799	5264	5459
08	100_10	5.528670233	3.163265306	6066	5880
09	100_20	6.834969121	10.83619019	7436	6709
10	200_10	10.9573531	1.223295807	11,419	11,281
11	200_20	13.69698202	8.222240623	13,070	12,077
12	500_20	34.14775248	1.413757345	29,339	28,930

represents a summary of the found results for twelve instances. The steps of the experiment are detailed as follows:

a.

The experiment encompassed 12 benchmarks, each one comprising 10 distinct instances. We conducted 10 tests for each of these 12 benchmarks.

b.

Each benchmark is characterized by two elements: the number of jobs requiring processing and the number of processing machines.

c.

We focused on the following dimensions for small-sized problems: (20 × 05; 20 × 10; 20 × 20; 50 × 05; 50 × 10; 50 × 20).

d.

For larger-sized problems, we utilized the following dimensions: (100 × 05, 100 × 10, 100 × 20, 200 × 10, 200 × 20, and 500 × 20).

e.

Each trial yielded the following results: CMax, deviation (Div), Lower Bound, and the CPU time.

f.

To enhance the result analysis, we selected the best 10 makespan values.

g.

For a better interpretation of the results, we employed the relative “index of deviation”.

$$\mathrm{Div}=\frac{\mathrm{Global} \mathrm{fitness} - \mathrm{Lower} \mathrm{Bound}}{\mathrm{Lower} \mathrm{Bound} }\times 100$$

(9)

The values of this index range between 0 and 100, with lower values indicating better results.

Note: We made modifications to the lower bound values extracted from the database since we introduced new constraints, whereas the database values were originally unconstrained.

The following Figure 1 illustrates the values from Table 2. In Figure 1a, we observe a linear increase in the values of makespan and lower bound as the complexity of the problem grows. However, once we reach the (100 × 20) instance, we notice exponential growth in both. The two curves are almost identical showing that the values found by our approaches are very close to the optimal. Figure 1b, demonstrates that CPU time values increase proportionally with problem complexity.

To identify the factors influencing the complexity of the problem, we compared the results of one instance to those of a larger instance. Our observations indicate that as the number of jobs increases, the complexity of the problem increases significantly. However, when the number of machines increases, the complexity also rises, but to a lesser extent.

In summary, our study reveals that the increase in the number of jobs directly contributes to an increase in the complexity of the problem and discusses the impact of integrating waiting time and releasing date constraints on the scheduling decisions.

For better clarity, Figure 1c represents the deviation index (DIV), used to quantify the gap between the lower bound values and the makespan values obtained through our approach. This indicator ranges from 0 to 100, and the values obtained in our study are closer to 0 than 100. Furthermore, the negative value in line 7 of Table 2 indicates that the found solution is better than the optimal one provided by LB, thereby demonstrating the effectiveness of our method.

Figure 2 is an example illustrating a Gantt chart of a sequence of 5 jobs, each represented by different colors, showcasing the impact of the waiting time constraint. For instance, the first job, represented by the brown color, completed its processing on the first machine at time 4. However, it had to wait until time 7 before starting its processing on machine 2, despite the availability of machine 2.

5. Conclusions

In conclusion, in this study we used the PSO algorithm to generate a sequence of jobs while minimizing the makespan function under the constraints of waiting time and release date in a flow-shop production workshop. These time constraints made the problem more complex. To our knowledge, there has been no prior work discussing these constraints simultaneously in a flow shop type workshop. We tested our approach on a set of benchmarks using the deviation index (DIV) to evaluate its effectiveness. Our approach produced values close to 0, thus indicating its performance. Our study also showed that the number of jobs has a great influence on the complexity of the system.