A Local and Global Search Combine Particle Swarm Optimization Algorithm for Job-Shop Scheduling to Minimize Makespan

Abstract

The Job-shop scheduling problem (JSSP) is a branch of production scheduling, which is among the hardest combinatorial optimization problems. Many different approaches have been applied to optimize JSSP, but for some JSSP even with moderate size cannot be solved to guarantee optimality. The original particle swarm optimization algorithm (OPSOA), generally, is used to solve continuous problems, and rarely to optimize discrete problems such as JSSP. In OPSOA, through research I find that it has a tendency to get stuck in a near optimal solution especially for middle and large size problems. The local and global search combine particle swarm optimization algorithm (LGSCPSOA) is used to solve JSSP, where particle-updating mechanism benefits from the searching experience of one particle itself, the best of all particles in the swarm, and the best of particles in neighborhood population. The new coding method is used in LGSCPSOA to optimize JSSP, and it gets all sequences are feasible solutions. Three representative instances are made computational experiment, and simulation shows that the LGSCPSOA is efficacious for JSSP to minimize makespan.

1. Introduction

The job-shop scheduling problem (JSSP) is very important in field of production management. The JSSP has been proved to be a difficult task for human planners and schedulers, particularly if optimal solutions are required. With traditional optimization approaches, finding optimal solution to large size combinatorial problems is not a practicable option, because of the vast amount of computer time needed to find such solutions. Predecessors have proposed many different approaches to optimize JSSP and have obtained some harvest, but by current algorithms, even moderately sized problems cannot be solved to guarantee optimality. One of the first attempts to optimize a simple JSSP through application of genetic algorithm can be seen in the research of Davis in 1985. Since then, a significant number of successful applications of GAs to JSSP have appeared in [1–4], and so forth. Gharbi and Haouari have used an approximate decomposition algorithm for scheduling on parallel machines [5]. Xia and Wu presented an effective hybrid optimization approach for multiobjective feasible JSSP in [6]. Many researches show that GAs that are used to solve JSSP are feasible, however, their performance is far from satisfactory. Particle swarm optimization (PSO) is an evolutionary computation technique developed by Eberhart and Kennedy in 1995 [7, 8], inspired by social behavior of bird flocking or fish schooling. Similar to genetic algorithms (GA), PSO is a population-based optimization tool. In recent years, there have been a lot of works focused on the PSO that have been applied widely in the function optimization, artificial neural network training, pattern recognition, fuzzy control, and some other fields where GA can be applied, but PSOA used to solve discrete optimization problem such as JSSP does not have a rich literature. Clerc and Kennedy in [9] have researched the particle swarm stability and convergence in a multidimensional complex space. Goh et al. researched on competitive and cooperative coevolutionary approach to multiobjective particle swarm optimization algorithm design [10]. Eberhart and Shi have researched inertia weights and constriction factors, developments, applications, and resources of particle swarm optimization in [11, 12], at the same time they have presented a modified particle swarm optimizer in [13]. Shi et al. presented an improved GA and a novel PSO-GA-based hybrid algorithm in [14]. Fan has presented a modification to PSOA in [15] and He et al. have put forward a particle swarm optimizer with passive congregation in [16]. Kennedy and Mendes in [17] investigated the impacts of population structures to the search performance of SPSO. Robinson et al. in [18] have investigated particle swarm, genetic algorithm, and their hybrids. Chen and Li [19, 20], Shi and Eberhart [21], and Trelea [22] have researched parameter selection of particle swarm optimization, respectively. Yin and Zhang presented a new heuristic algorithm for solving the JSSP [23]. Lian et al. in [24] presented a similar particle swarm optimization algorithm, and through simulation experiment showed that it was effective to solve optimization problems especially with large size.

In this paper, a local and global search combine particle swarm optimization algorithm (LGSCPSOA) is used for JSSP to minimize the makespan. In LGSCPSOA the new coding scheme is used, which gets every particle is feasible scheduling. This work differs from the existing ones at least in three aspects. It firstly proposes LGSCPSOA for JSSP; the second is to investigate the effectiveness of various parameters for different size JSSP; the third, computational experiments are performed to show that the LGSCPSOA is valid for JSSP. The rest of the paper is organized as follows. Section 2 gives a definition of the JSSP and formulates its model that is minimum makespan. The LGSCPSOA implementation for JSSP is presented in Section 3. Section 4 discusses experimental results obtained by LGSCPSOA with different parameters on public benchmark JSSP. Finally, Section 5 summarizes the contribution of this paper and conclusions.

2. JSSP Description

In the static JSSP, a finite number of jobs are to be processed by a finite number of machines. Each job consists of a predetermined sequence of task operations, each of which needs to be processed without preemption for a given period of time on a given machine. Tasks of the same job cannot be processed concurrently and each job must visit each machine exactly once. Each operation cannot be commenced until the processing is completed, if the precedent operation is still being processed. A schedule is an assignment of operations to time slots on a machine. The makespan of JSSP is maximum completion time of all jobs, and the objective is to find a schedule that minimizes the makespan. A good schedule is one that minimizes the total amount of time machines are idle.

The JSSP Description
Let n jobs (𝑗=1,2,…,𝑛) be processed on m machines 𝑀₁,𝑀₂,…,𝑀_𝑚. Job 𝑗 consists of operations sequence 𝑂_1𝑗,𝑂_2𝑗,…,𝑂_𝑖𝑗,…, which must be processed with precedence constraints of the form 𝑂_𝑖𝑗→𝑂_𝑖+1,𝑗(𝑖=1,2,…,𝑚_𝑗−1). Each operation 𝑂_𝑖𝑗 being processed needs 𝑇_𝑖𝑗(𝑖=1,2,…,𝑚,𝑗=1,2,…,𝑛) time units on one machine of 𝑀₁,𝑀₂,…,𝑀_𝑚. All jobs are available at time zero and the operation of each job on a machine requires an uninterrupted period of time. This problem is called the job-shop scheduling problem (JSSP). Its model is set up as follows.
Let: 𝐽={1,2,…,𝑛} for the job set;
𝑝_𝑘𝑗=find(𝑂_𝑖𝑗==𝑘∣𝑖=1,2,…,𝑚) denote machine number of working procedure order 𝑘 of job 𝑗 process;
𝐶(𝑖,𝑗) for the completion time of job j on machine i as follows: 𝐶(1,1)=𝐶(𝑝_{(𝑂11−1)1},1)+𝑇(1,1),𝐶(1,𝑗)=max{𝐶(1,𝑗^′),𝐶(𝑃_{(𝑂1𝑗−1)},𝑗)}+𝑇(1,𝑗),𝐶(𝑖,1)=𝐶(𝑝_{(𝑂𝑖1−1)1},1)+𝑇(𝑖,1),𝐶(𝑖,𝑗)=max{𝐶(𝑖,𝑗^′),𝐶(𝑝_{(𝑂𝑖𝑗−1)𝑗},𝑗)}+𝑇(𝑖,𝑗). (2.1)

Remark 2.1. For 𝑗=1,…,𝑛; 𝑖=1,…,𝑚, 𝑗^′ is anterior processing job of job 𝑗 on machine 𝑖.
The relation calculation makespan is as follows: 𝐶_max=max_{1≤𝑖≤𝑚}max_{1≤𝑗≤𝑛}𝐶(𝑖,𝑗). (2.2)

The scheduling problem is to find out the best operation sequences on all machines in order to minimize makespan. In this case, the makespan implies the criterion to be optimized.

In follow section, propose LGSCPSOA and use it to find a near optimal schedule whose makespan is the minimum over the set of all possible feasible schedules.

3. LGSCPSO Algorithm

3.1. Original Particle Swarm Optimization

Particle swarm optimization (PSO) is an evolutionary computation technique mimicking the behavior of flying birds and their means of information exchange. The system of PSO is initialized with a population (named swarm in PSO) of random solutions and searches for optima by updating generations. Each individual or potential solution, named particle, flies with a velocity which is adjusted according to the flying experiences of its own and its colleagues. PSOA has been developing rapidly and has been applied widely since it was introduced, as it is easily understood and realized. In PSOA, the potential solutions are “flown” through the problem space by following the current optimum particles, and the detailed information will be given in following.

Suppose that the searching space is N-dimensional and m particles form the colony. The ith particle represents an N-dimensional vector 𝑋_𝑖(𝑖=1,2,…,𝑚), and it means that the ith particle locates at 𝑋_𝑖=(𝑥_𝑖1,𝑥_𝑖2,…,𝑥_𝑖𝐷) in the searching space. The particle’s fitness could be calculated through putting its position into a designated objective function. The ith particle’s “flying” velocity is also an N-dimensional vector as 𝑉_𝑖=(𝑣_𝑖1,𝑣_𝑖2,…,𝑣_𝑖𝐷). Denote the best position of the ith particle as 𝑃_𝑖=(𝑝_𝑖1,𝑝_𝑖2,…,𝑝_𝑖𝐷), and the best position of all colonies as 𝑃_𝑔=(𝑝_𝑔1,𝑝_𝑔2,…,𝑝_𝑔𝐷), respectively. The original particle swarm optimization algorithm (OPSOA) could be performed by the following equations [7, 8]:𝑣_𝑖𝑑(𝑘+1)=𝑣_𝑖𝑑(𝑘)+𝑐₁𝑟₁(𝑝_𝑖𝑑(𝑘)−𝑥_𝑖𝑑(𝑘))+𝑐₂𝑟₂(𝑝_𝑔𝑑(𝑘)−𝑥_𝑖𝑑𝑥(𝑘)),_𝑖𝑑(𝑘+1)=𝑥_𝑖𝑑(𝑘)+𝑣_𝑖𝑑(𝑘+1), (3.1) where k represents the iterative number, 𝑐₁,𝑐₂ are learning factors, usually 𝑐₁=𝑐₂=2. 𝑟₁, 𝑟₂ are random numbers between (0, 1). The termination criterion for the iterations is determined according to whether the max generation or a designated value of the fitness of 𝑃_𝑔 is reached.

3.2. LGSCPSOA for JSSP

3.2.1. Coding Scheme in LGSCPSOA for JSSP

OPSOA has been introduced as an optimization technique in real-number space, but many optimization problems in discrete space such as JSSP. OPSOA has a disadvantage tendency to get stuck in a near optimal solution and may find it difficult to improve solution accuracy by fine tuning. This section presents LGSCPSOA to optimize JSSP in discrete space, and develop an effective “problem mapping” and “solution generation” mechanism.

In many algorithms for JSSP using the machine coding, and it gets some sequences are not feasible solutions. In LGSCPSOA the working procedure coding is used, and it gives birth to all children (sequences) are feasible solutions.

Suppose 𝑋=[𝑥₁,𝑥₂,…,𝑥_𝑛](𝑥_𝑖∈𝑅,𝑖=1,2,…𝑛) be one random particle, following steps make particles able to denote JSSP scheduling and will be used in LGSCPSOA to solve JSSP. (1)Sorting the weight 𝑋=[𝑥₁,𝑥₂,…,𝑥_𝑛] from small to large gets 𝑋^′=[𝑥^′₁,𝑥^′₂,…,𝑥^′_𝑛], and using 𝑦_𝑖 denotes the position of 𝑥^′_𝑖 in 𝑋=[𝑥₁,𝑥₂,…,𝑥_𝑛]. Obtain the new sequence 𝑌=[𝑦₁,𝑦₂,…,𝑦_𝑛]. For example, 3×2 JSSP, 𝑋=[0.8637,0.1872,0.8725,0.6442,0.2132,0.6429], sorting X gets 𝑋^′=[0.1872,0.2132,0.6429,0.6442,0.8637,0.8725], then get the new sequence 𝑌=[2,5,6,4,1,3];(2)Every weight of sequence Y is divided by machine number M, and then rounded towards plus infinity to get a final one feasible solution sequence. For the above above example 𝑌/2=[2/2,5/2,6/2,4/2,1/2,3/2] then rounded towards plus infinity to obtain a final solution sequence se=[1,3,3,2,1,2];(3)Working procedure coding: Suppose 𝑛×𝑚 JSSP, randomly give birth to following sequence: se(sequence)=[1,3,…,𝑛,5,3,…,𝑛,…,1,2,…,𝑛], (3.2) where the number indicates job and the same number denotes different working procedure of the job according to their order of appearance in se. For example, the 3×2 JSSP, solution sequence se=[1,3,3,2,1,2], which denote in turn process working procedure 1 of job 1, working procedure 1 of job 3, working procedure 2 of job 3, working procedure 1 of job 2, working procedure 2 of job 1, and lastly process working procedure 2 of job 2. Using this working procedure coding scheme makes every sequences is feasible solutions.

3.2.2. Iterative Model of the LGSCPSOA

In OPSOA, the information of individual best and global best are shared only by next generation particles. Based on OPSOA, in this paper, I firstly present LGSCPSOA, in which it also adequately utilizes information of the best particle of every generation population, at the same time; in every generation, introducing into some best particles displaces random selecting particles in population. The detailed information will be given in the following.

Suppose that the searching space is n-dimensional and m particles form the colony. The ith particle represents an n-dimensional vector 𝑋_𝑖(𝑖=1,2,…,𝑚), and it means that the ith particle locates at 𝑋_𝑖=(𝑥_𝑖1,𝑥_𝑖2,…,𝑥_𝑖𝑛) in the searching space. The position of each particle is a potential result. We could calculate the particle’s fitness by putting its position into a designated objective function. When the fitness is lower, the corresponding 𝑋_𝑖 is “better.” The ith particle’s “flying” velocity is also an n-dimensional vector as 𝑉_𝑖=(𝑣_𝑖1,𝑣_𝑖2,…,𝑣_𝑖𝑛). Denote the best position of the ith particles as 𝑃_𝑖=(𝑝_𝑖1,𝑝_𝑖2,…,𝑝_𝑖𝑛), the best position of the kth generation population (local best particle) as 𝑃_𝑙=(𝑝_𝑙1,𝑝_𝑙2,…,𝑝_𝑙𝑛), and the best position of all colonies (global best particle) as 𝑃_𝑔=(𝑝₁,𝑝₂,…,𝑝_𝑛), respectively. Using the best particle of every generation population merges into the local best particle population and displaces random selecting particles in local best generation. After finding three best values, the particle updates its velocity and positions with the following formulas:𝑣_𝑖𝑑(𝑘+1)=𝑤𝑣_𝑖𝑑(𝑘)+𝑐₁𝑟₁(𝛼(𝑝_𝑖𝑑(𝑘)−𝑥_𝑖𝑑(𝑘))+(1−𝛼)(𝑝_𝑙𝑑(𝑘)−𝑥_𝑖𝑑(𝑘)))+𝑐₂𝑟₂(𝑝_𝑔𝑑(𝑘)−𝑥_𝑖𝑑𝑥(𝑘)),_𝑖𝑑(𝑘+1)=𝑥_𝑖𝑑(𝑘)+𝑣_𝑖𝑑𝑃(𝑘+1)(𝑖=1,2,…,𝑚;𝑑=1,2,…,𝑛)_𝑙(𝑘+1)=𝑃_𝑙(𝑘−1,𝑘−2,…,1)∪𝑃_𝑙(𝑘), (3.3)(3.4)(3.5) where w is an inertia weight, which is initialized typically in the range of [0,1]. The local best particle of 𝑘 generation is u% of the k generation neighborhood particles whole number. 𝛼∈[0,1] is weight index that is chosen according to different optimization problems, which reflects relatively important degree of best position of the ith particle and the kth generation population particle. The variables 𝑐₁ and 𝑐₂ are acceleration constants, which control how far a particle will move in a single iteration, and other parameters are the same as in (2.1) and (2.2). The termination criterion for the iterations is determined according to whether the end generation or a designated value of the fitness of 𝑃_𝑔 is reached. In LGSCPSOA, each particle of the swarm shares mutual information and benefits from previous experiences of all other colleagues during the search process.

3.2.3. Pseudo Code of LGSCPSOA

(See Algorithm 1).

Step 1: Initialize parameters; including swarm size PS, end of generation G, and other    parameters will be used in LGSCPSOA; Step 2: Segment and scheduling;  (i)      Generate stochastically initialization population and velocity using Section 3.2.1 coding       scheme  (ii)   Evaluate each particle’s fitness  (iii)Initialize gbest position with the lowest fitness particle in the swarm  (iv)   Initialize ibest and lbest position with a copy of particle itself  (v)      𝑘∶=0  While (the end G of generation is not met)  {  (i)     𝑘∶=𝑘+1  (ii)  Generate next generation particle population by recurrence equations (3.3), (3.4)      and (3.5)  (iii)Evaluate swarm         {(1)Compute each particle’s fitness in the swarm          (2)Find new 𝑃𝑔 of the swarm, 𝑃𝑙 of generation population and 𝑃𝑖 of each                  particle by comparison, and update 𝑃𝑖 and 𝑃𝑔           (3)Update 𝑃𝑙 with (3.5)              Using the best particle of k generation replace the 𝑘−1 generation u%              particles which are random selected}    } Step 3: Output optimization result 𝑃𝑔; End

Algorithm 1 

Pseudo Code of LGSCPSOA.

4. Experimental Results and Discussion

To analyze the effectiveness and performance of LGSCPSOA for JSSP to minimize makespan, three representative instances taken from the internet based on practical data have been selected to experiment, and through simulation, the best effective parameters of LGSCPSOA for JSSP to minimize makespan are found out.

To get the average performance of the LGSCPSOA ten runs on each instance are performed and the solution quality is averaged, and let the best of them be the solution of this algorithm. We use the arithmetic mean, lower, and upper bound of makespan, and obtaining the best solution time four indexes to estimate LGSCPSOA. The computation comparing results of GA, OPSOA, and LGSCPSOA with different operators or parameters are as in Table 1.

Table 1 

The comparisons of GA, OPSOA and LGSCPSOA with different parameters for JSSP.

Remark 4.1. In Table 1, 𝑃 (problem) denotes the problem size, and BS (best solution) is this problem’s optimum value, and PS (population size) and GN (generation number) indicate the population size and algorithm terminate generation. In this computing experiment, we let the displaced particles number 𝑟_𝑁=PS/3;
From the Table 1 we can obtain that the LGSCPSOA is clearly better than the OPSOA and GA for JSSP. LGSCPSOA obtains smaller upper bound, arithmetic mean, and lower bound of makespan than OPSOA and GA in run ten times. The best solution found in each category of LGSCPSOA with different parameter is illustrated with bold letters. From Table 1 one can observe that LGSCPSOA with 𝑤≈0.2 and 𝛼≈0.2 has the highest performance since using these parameter has smaller upper bound, arithmetic mean and lower bound of makespan in relation to the solutions obtained by the other parameters schemes. The convergence figure and GANTT of the best solution of different size problems are shown in Figure 1.

(a)

(b)

(c)

(d)

(e)

(f)

Figure 1 

Convergence figure and GANTT of OPSO, GA, and LGSCPSOA for JSSP.

From simulation figure, we can see clearly that the convergence rate of LGSCPSOA is faster than the OPSOA and GA. And from above experimenting data, we can testify that the new LGSCPSOA is more efficacious than OPSOA and GA for JSSP to minimize makespan.

5. Conclusion and Perspectives

Although there is a huge amount of literature on OPSOA, there are not too many papers focused on solving scheduling of JSSP. In this paper, we have discussed a new approach LGSCPSOA for JSSP to minimize makespan, in which 𝑝_𝑖, 𝑝_𝑙, 𝑝_𝑔, and 𝑉_𝑖 give out the information to others, and it is a one-way information sharing mechanism. There are not many parameters needed to be tuned in LGSCPSOA. LGSCPSOA requires only primitive and simple mathematical operators, and is computationally inexpensive in terms of both memory requirements and time. Although it does not guarantee the optimality for 20×5 JSSP, such an approach provides solution with good quality in a reasonable time limit and compared with OPSOA and GA. The performance of the new approach is evaluated in comparison with GA and OPSOA for three representative instances and obtained results show that the effectiveness of the proposed approach is the best. The proposed LGSCPSOA approach in this paper can be considered as effective mechanisms for optimization technique from this point of view.

There are a number of research directions that can be considered as useful extensions of this research. Although the LGSCPSOA is tested with three representative instances, a more comprehensive computational study should be made to test the efficiency of proposed solution technique. The LGSCPSOA proposed in this paper for small size JSSP is very efficacious, but for large size problem is not approving. We just simulate the effectiveness when 𝑟_𝑁=𝑝size/3 for JSSP, and in the future can research the efficiency of different 𝑟_𝑁. Applying LGSCPSOA to other discrete combinatorial optimization problems is also possible in further research. The development of OPSOA is still ongoing, and furthermore, there are still many unknown areas in LGSCPSOA research such as the mathematical validation of particle swarm theory.

Acknowledgments

This work is supported by the Research Activation Fee of Shanghai Dian Ji University (Grant no. 09C403), Humanities and Social Sciences Youth Fund Project of Ministry of Education (Grant no. 09yjc630151), and Shanghai Universities Select and Train Outstanding Young Teachers in special funds for scientific research (Grant no. sdju200903).