CHAPTER 1 INTRODUCTION
1.3 Organization
The organization of the remaining chapters for this research is as follows.
Chapter 2 reviews the literatures of the background of the multidimensional 0-1 knapsack problem, shop scheduling problems and PSO. Chapter 3 infers the possibly success factors of PSO design. Chapter 4 shows a PSO for MKP, chapter 5 shows a PSO for JSSP, and chapter 6 shows a PSO for OSSP. In chapter 7 we draw our conclusion and indicate the direction for further research.
CHAPTER 2
LITERATURE REVIEW
2.1 Particle Swarm Optimization
Particle swarm optimization (PSO) was developed by Kennedy and Eberhart (1995). The original intention was to simulate the movement of organisms in a bird flock or fish school, and it has since been introduced as an optimization technique.
PSO is a population-based optimization algorithm. Each particle is an individual, and the swarm is composed of particles. The relationship between swarm and particles in PSO is similar to the relationship between population and chromosomes in genetic algorithm (GA).
In PSO, the problem solution space is formulated as a search space. Each position in the search space is a correlated solution of the problem. For example, when PSO is applied to a continuous optimization problem with d variables, the solution space can be formulated as a d dimensional search space, and the value of jth variable is formulated as the position on jth dimension. Particles cooperate to find the best position (best solution) in the search space (solution space). The particle movement is mainly affected by three factors: inertia, particle best position (pbest), and global best position (gbest). The inertia is the velocity of the particle in the latest iteration, and it can be controlled by inertia weight. The intention of the inertia is to prevent particles from moving back to their current positions. The pbest position is the best solution found by each particle itself so far, and each particle has its own pbest position. The gbest position is the best solution found by the whole swarm so far.
Each particle moves according to its velocity. The velocity is randomly generated toward pbest and gbest positions. For each particle k and dimension j, the velocity and
position of particles can be updated by the following equations:
) (
)
( 2 2
1
1 kj kj j kj
kj
kj w v c rand pbest x c rand gbest x
v ← × + × × − + × × − (2.1)
kj kj
kj x v
x ← + (2.2)
In equation (2.1) and equation (2.2), v is the velocity of particle k on kj dimension j, which value is limited to the parameter Vmax, that is, vkj ≤Vmax. The
x is the position of particle k on dimension j, which value is limited to the kj
parameter Xmax, that is, xkj ≤ Xmax. Thepbest is the pbest position of particle k kj on dimension j, and gbest is the gbest position of the swarm on dimension j. The j inertia weight w was first proposed by Shi and Eberhart (1998a, 1998b), and it is used to control exploration and exploitation. The particles maintain high velocities with a larger w, and low velocities with a smaller w. A larger w can prevent particles from becoming trapped in local optima, and a smaller w encourages particles exploiting the same search space area. The constants c1 and c2 are used to decide whether particles prefer moving toward a pbest position or gbest position. The rand1 and rand2 are random variables between 0 and 1. The process of PSO is shown as Figure 2.1.
Initialize a population of particles with random positions and velocities on d dimensions in the search space.
repeat
for each particle k do
Update the velocity of particle k, according to equation (1).
Update the position of particle k, according to equation (2).
Map the position of particle k in the solution space and evaluate its fitness value according to the desired optimization fitness function.
Update pbest and gbest position if necessary.
end for
until a criterion is not met, usually a sufficient good fitness or a maximum number of iterations.
Figure 2.1 The process of particle swarm optimization.
The original PSO is suited to a continuous solution space. Therefore, the applications of PSO for discrete optimization problems are still scarce. Table 2.1 shows the references of PSO for discrete optimization problems.
Table 2.1 References of PSO for discrete optimization problems
Problem References Binary Unconstrained Optimization Kennedy & Eberhart (1997)
A first discrete version of PSO for binary variables.
Rastegar et al. (2004)
Based on Kennedy & Eberhart (1997), hybridized with learning automata.
Constrained layout optimization Li (2004)
Represent a layout problem by continuous variables.
Multi-objective task allocation Yin et al. (2007a)
Particle represented by integer variables, which indicates the index of the allocated processor for each module.
Task assignment problem Salman et al. (2002)
The positions of tasks are represented by continuous variables.
Yin et al. (2007b)
Hybridized with a parameter-wise hill-climbing heuristic.
Traveling salesman problem Wang et al. (2003)
Applied sequential ordering representation and swap operator.
Pang et al. (2004)
Represent the particle position by a fuzzy matrix.
Zhi et al. (2004)
The particles movement is based on a one-point crossover.
Vehicle routing problem Wu et al. (2004)
Applied swap operator and 2-opt local search.
Table 2.1 (cont.)
Problem References Scheduling Problems:
– Assembly scheduling Allahverdi & Al-Anzi (2006) Hybridized with tabu search.
– Flow shop scheduling Lian et al. (2006)
Proposed three crossover operators.
Tasgetiren et al. (2007)
Real number representation and local search.
Liao et al. (2007)
Represent the operation sequence by 0-1 variables.
– Job shop scheduling Lian et al. (2006)
Proposed four crossover operators.
– Multi-objective flexible job-shop scheduling
Xia & Wu (2005)
Hybridized with simulated annealing.
– Resource constraint project scheduling
Zhang & Li (2006) Zhang & Li (2007)
Compared priority based representation and sequential ordering representation.
2.2 Multidimensional 0-1 Knapsack Problem
The multidimensional 0-1 knapsack problem (MKP) is a well-known NP-hard problem. The problem can be formulated as:
maximize
∑
Where m is the number of knapsack constraints and n is the number of items.
Each item j requires rij units of resource consumption in the ith knapsack and yields pj units of profit upon inclusion. The goal is to find a subset of items that yields maximum profit without exceeding resource capacities. The MKP can be seen as a general model for any kind of binary problems with positive coefficients, and it can be applied to many problems such as cargo loading, capital budgeting, project selection, etc. The most recent surveys on MKP can be found in (Fréville, 2004) and (Fréville and Hanafi, 2005).
The MKP is an NP-hard problem, so it cannot be exactly solved in a reasonable computation time for large instances. However, metaheuristics can obtain approximate optimal solutions in a reasonable computation time. For that reason, metaheuristics for MKP such as simulated annealing (SA) (Drexl, 1988), tabu search (TS) (Glover and Kochenberger, 1996; Hanafi and Fréville; 1998; Vasquez and Hao, 2001; Vasquez and Vimont, 2005), and genetic algorithm (GA) (Chu and Beasley, 1998) have arisen
during the last decade.
2.3 Job Shop Scheduling Problem
The job shop scheduling problem (JSSP) is one of the most difficult combinatorial optimization problems. The JSSP can be briefly stated as follows (French, 1982; Gen & Cheng, 1997). There are n jobs to be processed through m machines. We shall suppose that each job must pass through each machine once and once only. Each job should be processed through the machines in a particular order, and there are no precedence constraints among different job operations. Each machine can process only one job at a time, and it cannot be interrupted. Furthermore, the processing time is fixed and known. In this work, the problem is to find a schedule to minimize the makespan (Cmax), that is, the time required to complete all jobs. The constraints in the classical JSSP is listed as follows (Bagchi, 1999):
• No two operations of one job occur simultaneously.
• No pre-emption (i.e. process interruption) of an operation is allowed.
• No job is processed twice on the same machine.
• Each job is processed to its completion, though there may be waits and delays between the operations performed.
• Jobs may be started at any time; hence no release time exists.
• Jobs must wait for the next machine to be available.
• No machine may perform more than one operation at a time.
• Set-up times for the operations are sequence-independent and included in processing times.
• There is only one of each type of machine.
• Machines may be idle within the schedulable period.
• Machines are available at any time.
• The technological (usually related to processing) constraints are known in advance and are immutable.
Solution Space
Semi-active
Active Non-delay
Figure 2.2 The relationship of semi-active, active, and nondelay schedules.
In JSSP, there are three distinct schedules can be identified as follows:
• Semi-active schedule: in an active schedule, the processing sequence is such that no operation can be started any earlier without changing the operation sequence on a machine.
• Active schedule: in an active schedule, the processing sequence is such that no operation can be started any earlier without delaying some other operation.
• Nondelay schedule: in a nondelay schedule, no machine is kept idle at a time when it could begin processing other operations.
Figure 2.2 shows the relationship of semi-active, active, and nondelay schedules. The optimal JSSP solution should be an active schedule. To reduce the search solution space, the tabu search proposed by Sun et al. (1995) searches solutions within the set of active schedules. Gonçalves and Beirão (1999) proposed the concept of
parameterized active schedules. The main purpose of parameterized active schedules is to reduce the search area but not to exclude the optimal solution. The basic idea of parameterized active schedules is to control the search area by controlling the delay times that each operation is allowed. If all of the delay times are equal to zero, the set of parameterized active schedules is equivalent to non-delay schedules. On the contrary, if all of the delay times are equal to infinity, the set of parameterized active schedules is equivalent to the active schedules.
Garey et al. (1976) demonstrated that JSSP is NP-hard, so it cannot be exactly solved in a reasonable computation time. Many meta-heuristics have been developed in the last decade to solve JSSP, such as simulated annealing (SA) (Lourenço, 1995), tabu search (TS) (Sun et al., 1995; Nowicki & Smutnicki, 1996; Pezzella & Merelli, 2000), and genetic algorithm (GA) (Bean, 1994; Kobayashi et al., 1995; Wang &
Zheng, 2001; Gonçalves et al., 2005).
2.4 Open Shop Scheduling Problem
The open shop scheduling problem (OSSP) can be stated as follows (Gonzalez &
Sahni, 1976): there is a set of n jobs that have to be processed on a set of m machines.
Every job consists of m operations, each of which must be processed on a different machine for a given process time. The operations of each job can be processed in any order. At any time, at most one operation can be processed on each machine, and at most one operation of each job can be processed. In this research, the problem is to find a non pre-emptive schedule to minimize the makespan (Cmax), that is, the time required to complete all jobs.
The constraints in the classical OSSP are similar to the classical JSSP but there are no precedence constraints among the same job operations. The OSSP is NP-hard
for m≥3 (Gonzalez & Sahni, 1976), so it cannot be exactly solved in a reasonable computation time. Guéret and Prins (1998) proposed two fast heuristics, the results of which are better than other classical heuristics. Domdorf et al. (2001) proposed a branch-and-bound method, which is the current best method to solve OSSP exactly.
Many metaheuristic algorithms have been developed in the last decade to solve OSSP, such as simulated annealing (SA) (Liaw, 1999), tabu search (TS) (Alcaide & Sicilia, 1997; Liaw, 1999), genetic algorithm (GA) (Liaw, 2000; Prins, 2000), ant colony optimization (ACO) (Blum, 2005), and neural network (NN) (Colak & Agarwal, 2005).
CHAPTER 3
DEVELOPING A PARTICLE SWARM OPTIMIZATION FOR A DISCRETE OPTIMIZATION PROBLEM
The original PSO is suited to a continuous solution space. We have to modify the original PSO in order to better suit it to discrete optimization problems. In this chapter, we will discuss the probably success factors to develop a PSO design for a discrete optimization problem. We separated a PSO design into several parts to discuss:
particle position representation, particle velocity, particle movement, decoding operator, and other search strategies.
3.1 Particle Position Representation
PSO represents the solutions by particle positions. There are various particle position representations for a discrete optimization problem. How to represent solutions by particle positions is a research topic when we develop a PSO design.
Generally, the Lamarckian property is used to discriminate between good and bad representations. The Lamarckian property is that the offspring can inherit goodness from its parents. For example, if there are six operations to be sorted on a machine, and we implement the random key representation (Bean, 1994) to represent a sequence, there are two positions of two particle positions as follows:
position 1: [0.25, 0.27, 0.21, 0.24, 0.26, 0.23]
position 2: [0.22, 0.25, 0.23, 0.26, 0.24, 0.21]
Then the operation sequence can be generated by sort the operations according to the increasing order of their position values as follows:
permutation 1: [3 6 4 1 5 2] permutation 2: [6 1 3 5 2 4]
We can find that these two permutations are quite different even though their positions are very close to each other. This is because the location in the permutation of one operation depends on the position values of other operations. Hence, the random key representation has no Lamarckian.
If we directly implement the original PSO design (i.e. the particles search solutions in a continuous solution space) to a scheduling problem, we can implement the random key representation to represent a sequence of operations on a machine.
However, the PSO will be more efficient if the particle position representation is with higher Lamarckian.
3.2 Particle Velocity and Particle Movement
The particle velocity and particle movement are designed for the specific particle position representation. In each iteration, a particle moves toward pbest and gbest positions, that is, the next particle position is determined by current position, pbest position, and gbest position. Furthermore, particle moves according to its velocity and movement mechanisms. Each particle moves from current position (solution) to one of the neighborhood positions (solutions). Therefore, the particle movement mechanism should be designed according the neighborhood structure. The advantage of neighborhood designs can be estimated by following properties (Mattfeld, 1996):
• Correlation: the solution resulting from a move should not differ much from the starting one.
• Feasibility: the feasibility of a solution should be preserved by all moves.
• Improvement: all moves in the neighborhood should have a good chance to improve the objective of a solution.
• Size: the number of moves in the neighborhood should be reasonably small to avoid excessive computational cost of their evaluation.
• Connectivity: it should be possible to reach the optimal solution from any starting one by performing a finite number of neighborhood moves.
We believe that the PSO will be more efficient if we design the particle velocity and the particle movement mechanisms according to these properties.
3.3 Decoding Operator
Decoding operator is used to decode a particle position into a solution. The decoding operator is designed according the specific particle position representation and the characteristics of the problem. A superior decoding operator can map the positions to the solution space in a smaller region but not excluding the optimal solution. In chapter 6, we designed four decoding operators for OSSP. The results show that the decoding operator design extremely influences the solution quality.
3.4 Other Search Strategies
．Diversification Strategy
We can also consider implementing other search strategies. The purpose of most search strategies is to control the intensification and the diversification. One of the search strategies is the structure of gbest and pbest solutions. In the original PSO design, each particle has its own pbest solution and the swam has only one gbest solution. Eberhart and Shi (2001) show a “local” version of the particle swarm. In this version, particles have information only of their own and their neighbors’ bests, rather
that that of the entire group. Instead of moving toward a kind of stochastic average of pbest and gbest (the best location of the entire group), particles move toward points defined by pbest and “lbest,” which is the index of the particle with the best evaluation in the particle’s neighborhood.
In this research, we proposed a diversification strategy. In this strategy, the pbest solution of each particle is not the best solution found by the particle itself, but one of the best N solutions found by the swarm so far where N is the size of the swarm.
．Selection Strategy
Angeline (1998) proposed a selection strategy, which is performed as follows.
After all the particles move to new positions, select the s best particles. The better particle set S ={k1,k2,K,ks) replaces the positions and velocities of the other particles. The addition of this selection strategy should provide the swarm with a more exploitative search mechanism that should find better optima more consistently.
In chapter 4, we modified the method proposed by Angeline (1998) based on the concept of building blocks where a block is part of a solution, and a good solution should include some superior blocks. The concept of building blocks is that if we can precisely find out the superior blocks and accumulate the superior blocks in the population, the genetic algorithm will perform better (Goldberg, 2002).
3.5 The Process to Develop a New Particle Swarm Optimization
As mentioned above, we separated PSO into several parts. The particle position representation determines the program data structure and other parts are designed for the specific particle position representation. Therefore, the first step of developing a new PSO is to determine the particle position representation. Then design particle
representation. Finally implement some search strategies for further improving solution quality. Figure 3.1 shows the process to develop a new particle swarm optimization. All the PSOs in this research are developed by the process described as Figure 3.1.
Figure 3.1 The process to develop a new particle swarm optimization Design particle position representation
Design particle velocity and particle movement for the specific particle position representation
Design decoding operator for the specific particle position
representation
Implement other search strategies
(#optional)
CHAPTER 4
A DISCRETE BINARY PARTICLE SWARM
OPTIMIZATION FOR THE MULTIDIMENSIONAL 0-1 KNAPSACK PROBLEM
Kennedy and Eberhart (1997) proposed a discrete binary particle swarm optimization (DPSO), which was designed for discrete binary solution space. Rastegar et al. (2004) proposed another DPSO based on learning automata. In both of the DPSOs, when particle k moves, its position on the jth variable x equals 0 or 1 at kj random. The probability that x equals 1 is obtained by applying a sigmoid kj transformation to the velocity v ))kj (1/1+exp(−vkj . In the above two DPSOs, the positions and velocities of particles can be updated by the following equations:
) between 0.9975 and 0.0025.
The DPSOs proposed by Kennedy and Eberhart (1997) and Rastegar et al. (2004) are designed for discrete binary optimization problems with no constraint. However, there are resource constraints in MKP. If we want to solve MKP by DPSO, we have to modify DPSO to fit the MKP characteristics.
There are two main differences between the DPSO in this chapter and the DPSOs
in previous research: (i) particle velocity and (ii) particle movement. The particle velocity is modified based on the tabu list and the concept of building blocks, and then the particle movement is modified based on the crossover and mutation of the genetic algorithm (GA). Besides, we applied the repair operator to repair solution infeasibility, the diversification strategy to prevent particles becoming trapped in local optima, the selection strategy to exchange good blocks between particles, and the local search to further improve solution quality. The computational results show that our DPSO effectively solves MKP and better than other traditional algorithms.
4.1 Particle Position Representation
In out DPSO, the particle position is represented by binary variables. For a MKP with n items, we represent the particle k position by n binary variables, i.e.
] , , ,
[ k1 k2 kn
k x x x
x = K
Where xkj∈
{ }
0,1 denotes the value of jth variable of particle k’s solution. Each time we start a run, DPSO initializes a population of particles with random positions, and initializes the gbest solution by a surrogate duality approach (Pirkul, 1987). We determine the pseudo-utility ratio uj = pj∑
mi= yirijWhere xkj∈