This paper presents an Ant Colony Optimisation (ACO) model for the Multiple Knapsack Problem (MKP). The ACO algorithms, as well as other evolutionary metaphors, are being applied successfully to diverse heavily constrained problems: Travelling Salesman Problem, Quadratic Assignment Problem and Bin Packing Problem. An Ant System, the first ACO algorithm that we presented in this paper, is also considered a class of multiagent distributed algorithm for combinatorial optimisation. The principle of an ACO Algorithm is adapted to the MKP. We present some results regardin its perfomance against known optimun for different instances of MKP. The obtained results show the potential power of this particular evolutionary approach for optimisation problems.Facultad de Informátic

Cena, Marcelo Guillermo

Crespo, María Liz

Kavka, Carlos

Leguizamón, Mario Guillermo

Journal of Computer Science and Technology

English

El Servicio de Difusión de la Creación Intelectual

1The Ant Colony Metaphor for Multiple Knapsack Problem
Cena, M.; Crespo M.L.; Kavka, C; •
                                        
•
Members of the UNSL 338403 project (
2The Zero/One Multiple Knapsack Problem and Zero/One Knapsack Problem have been intensively
studied using different traditional methods, such as Branch-and-Bound and Dynamic Programming [11,12].
Also, modern heuristic techniques [9,10,13] like Genetic Algorithms (GA) and Simulated Annealing (SA)
have shown to be able to produce high-quality solutions for these types of highly constrained NP-complete
problems.
In this paper we propose to solve MKP by using the Ant Colony Metaphor [4,5], an approach
based on the result of low-level interaction among many co-operating simple agents that are not aware of
their co-operative behaviour. Each simple agent is called ’ant’ and the Ant System (a distributed
algorithm) is a set of ants co-operating in a common problem solving activity.
Previous works in this area have inspired our work [2,3,5,6]. Different versions of ACO
algorithms have been used in order to solve Travelling Salesman Problem (TSP), Bin packing and
continuous space optimisation problems. Problems like TSP and Bin Packing can be represented as a
sequence on  items (  to be visited or   to be packed), where the actual order of the
sequence determines a particular solution to the problem. Thus in general, the search space consists of
all  permutations.
Bin Packing and TSP are properly suitable to be solved by using an Ant System [2]. In this
paper, we adapt the original Ant System [4] so it can be used to solve non-ordering problems like the
MKP. We also present experimental results that show that the adapted Ant System can solve MKP in an
efficient way. In this adapted Ant System, the ants (agents) are not concerned with discovering the best
ordering (or tours), they just look for a subset of  items, such that the total profit is maximised and all
constrains are satisfied.
The adapted Ant System uses Ant-cycle [5], a particular instance of the algorithms belonging to
Ant system class (other instances proposed in [5] are Ant-density and Ant-quantity).  In the Ant-cycle
algorithm every ant changes the system-shared memory using a quantity (called ) that is
proportional to its global behaviour.  On the other hand, Ant-density and Ant-quantity algorithms use
strictly local information.
The primary purpose of our study is to evaluate the Ant System performance in relation with
the known results for different instances of MKP. The MKP instances considered are taken from [1].
We also present some results regarding its performance when varying the values of the
parameters that control the probabilities for item selection.
The remainder of the paper is organised in the following way. In the next sections the MKP
formulation and  the classical and adapted model of an Ant Colony System are given. Next, the experiments
performed, the results obtained and the statistical analysis are shown. Finally, the conclusions are exposed.
MKP can be formulated [1,9,11] as:
=1 (2.1)
=
=
1
1,..., (2.2)
={ , } , . . . ,0 1 1 (2.3)
Each of the  constrains described in equation (2.2) is called a knapsack constrain, so the MKP is also called
the .
Let  and , with  for all . A  MKP assumes that 
and <
= 1 for all , since any violation of these conditions will result in some 
being fixed to zero and/or some constrains being eliminated. Note that the 
 
 matrix and  vector are
both non-negative which distinguishes this problem from general 0-1 linear integer programming problem.
3Many practical problems can be formulated as a MKP, for example, the capital budgeting problem
where project  has profit   and consumes   units of resource . The goal is to find a subset of the projects
such that the total profit is maximised and all resource constrains are satisfied.
In this section, we describe our Ant System applied to the Travelling Salesman Problem.
Given a set of  cities, the Travelling Salesman Problem [11,12] is to find a closed path that
visits every city exactly once (tour) with minimal total length. i.e.
( ,..., ) ( , ) ( , )1 1 1
1
1
= ++
=
where  is the distance between city  and city .
Let   be the number of ants in city  at time  and let =
=
( )
1
, the total number of
ants.
Let  be the   on  at time , given by
The amount is such  is the ( ).
=1
 where is the quantity per unit of length of trial substance
(pheromone in real ants) laid on by the  ant between time  and  and is given by the
following formula:
( )+ =
if k th ant uses edge i j  in its tour
0
where  is a constant and  is the tour length of the k-th ant.
The intensity of trial at time 0, , is set to a randomly chosen value.
During the next  tour the probability to visit city  when being at city i is
( , )
[ ( )] [ ]
[ ( )] [ ]
=
0
The set  represents the cities still not visited for that particular tour and  is a local heuristic.
For the TSP the parameter , called  is  [5].
The parameters  and  allow a user control on the relative importance of trail versus visibility. Hence,
the transition probability is a trade-off between visibility, which says that close cities should be chosen
with high probability, and trail intensity, that says that if on  there is a lot of traffic then is it highly
profitable.
4A data structure, called , is associated to each ant in order to avoid that ants visit a city more
than once, i.e. the list maintain a set of visited cities up to time   by the k-th ant. Therefore the
 set can be defined as follow: . When a tour is completed the  is
emptied and every ant is free again to choose an alternative way.
By using the above definitions, we describe the Ant-cycle algorithm:
1 Initialise:
 Set t:=0 {t is the time counter}
 For every edge (i,j) set an initial value ij(t)
 For every edge (i,j) set 
 ij(t,t+n):=0
 Place bi(t) ants on every node i {bi(t) is the number of ants on node i at time t}
 Set s:=1 {s is the tabu list index}
 For i:=1 to n do
 For k:= 1 to bi(t) do
 k(s):=i {starting town is the first element of the tabu 
  list of the k-th ant}
 
2 Repeat until tabu list is full {this step will be repeated (n-1) times}
 Set s:=s+1
 For i:=1 to n do {for every town}
    For k:=1 to bi(t) do {for every k-th ant on town i still not moved}
 Choose the town j to moved to, with
 probability Pij(t,k) given by equation (3.3)
 Move the k-th ant to j {this instruction creates the new values
 bj(t+1)}
 Insert node j in k(s)
 
3. For k:= 1 to n do
    Compute Lk {it results from the tabu list}
 For s:= 1 to n-1 do {scan the tabu list of the k-th ant}
    Set (h,l):=(tabuk(s), tabuk(s+1)) {(h,l) is the edge connecting town s y s+1 in
 the tabu list of ant k}
    hl (t+n):=  hl (t+n) + Q/Lk
 
4 For every edge (i,j) compute 
 ij(t+n) according to equation (3.1)
 Set t:=t+n
 For every edge (i,j) set 
 ij(t+n):=0
 
5 Memorise the shortest tour found so far
if (NC < NCMAX) or (not all the ants choose the same tour)
{NC is the number of algorithms cycles; in NC
 cycles are tested NC * Na solutions}
then
Empty all tabu list
Goto step 1.2
Else
Print shortest tour and Stop
5In order to solve MKP, it is necessary to adapt the Ant System in some way. The purpose of the
ants in MKP is not to get a tour with minimum cost like in TSP; but they look for a subset of  items or
projects (see MKP formulation) such that the total profit is maximised and all resource constrains are
satisfied.
Let   be the number of ants incorporating in the solution the item  at time  and let
=
=1
; the total number of ants.
Since in MKP there are not  the  and  are computed in a slightly different
way.
Let  be the   on item at time , given by
max
As in  is such  is the  and is the maximum number of items
qualified to be added to some solution by some ant.
=1
 where is the quantity per unit of length of trial
substance (pheromone in real ants) laid on item by the  ant between time  and  and is given
by the following formula:
( )+ =
0
where  is a constant and  is the profit  obtained by the k-th ant.
The intensity of trial at time 0, , is set to a randomly chosen value.
During the next (t+ ) item incorporation the probability to select the item  by the ant  in order  to
complete the is :
( , )
[ ( )] [ ( , )]
[ ( )] [ ( , )]
=
0
where  is a set of items still not considered by the  ant and the  satisfies all
constraints if some of them are added. The parameter , called , is a local heuristic. We
chose  as follows:
6( , )
( )
; ( )
( )
= =
=1
( )
( ( ))
; ( )= =
Where  is the remaining amount to reach the boundary of the constraint ,     and
 is the  of item  on constraint  when item  is added to . Consequently
the   turns larger as  ( )  ( turns smaller.
The parameters  and , as for TSP, allow a user control on relative importance of  versus the
heuristic . Hence, the transition probability is a trade-off between ,
which says that more profitable items that uses less resources should be chosen with high probability,
and trail intensity, that says that if item  is part of a lot of solutions, then is it highly desirable.
A data structure, called , is also associated to each ant in order to avoid that ants choice a item
more than once, i.e. the list maintain the set of added items up to time   by the  ant. This list
also maintains (k)  in order to reduce the required computational time.
The   set can be defined as follows: 
. When all ants add to the solutions as many items as they can, an item  is
selected from the . Then the  is emptied and the  ant is free again to choose
starting with the item hk as its initial solution.
The outline of the adapted Ant-cycle algorithm follows:
1 Initialise:
 Set t:=0 {t is the time counter}
 For every item (i) set an initial value i(t)
 For every item (i) set 
 i (t,t+Nmax):=0
 bi ants choose the item i {bi is the number of ants choosing item i
 at time 0}
 Set s:=1 {s is the tabu list index}
 For i:=1 to n do
      For k:= 1 to bi do
 k(s):=i {initial item of the tabu list of the k-th ant}
 
 
2 For k:=1 to Na do
    s:=2
    Repeat until some constraint is no satisfied by  k-th ant
    Choose the item i, with probability Pi(t,k) given by equation (4.3)
    k(s):=i
    s:=s+1
 
 
73 For k:= 1 to Na do
    Compute Lk {it results from the tabu list}
 For s:= 1 to Number of items in k do {scan the tabu list of the k-th ant}
    h = k(s)
    h (t,t+ Nmax ):= h (t, t+ Nmax) + Lk/Q
 
4 For every item (i) compute 
 i(t+ Nmax ) according to equation (4.1)
 Set t:=t+ Nmax
 For every item (i) set 
 i (t,t+Nmax):=0
 
5 Memorise the best solution found so far
if (NC < NCMAX) or (not all the ants find the same solution)
{NC is the number of algorithms cycles; in NC
 cycles are tested NC.Na solutions}
then
    hk=item randomly select from k (k=1..Na)
    Empty all tabu list
    k(1)=hk (k=1..Na)
    Goto step 2
else
Print best solution and Stop
Several parameters were considered for the experiments. Next each one and its values for different
running are presented below.
=1
The above values were selected regarding the results achieved in previous works [2,3,4,5,6]. The five
combinations of values corresponding to  and  parameters have influence on the probability values
 as follows:
a) (  
b) (  
c) (  
d) (  
e) (  
 
 shows for each test case the following data:
8The shadow cells in Table I indicate suboptimal results which are just 4 out of 19 instances of the MKP
considered. For example, the best value obtained for the  instance #8 is the same that was reported by
Khuri et al. [9] where a GA was used. On the other hand, for test case #19, the value corresponding to
"known Optimum" column is the best value reported by Paul Chu et al. [13] again, by using a GA. An
improvement  on the results showed in Table I and additional experiments on hard and bigger instances
of MKP, also taken from [1,13] are reported in [14].
It is important to remark that for some instances, the Ant System was able to find the best solution (or
suboptimal) when the first cycle was completed, meaning that the greedy heuristic was sufficient,
excluding any co-operation. However, the best results in general were obtained by using (  
(  combinations, i.e. the significance of the heuristic influence was at least as important as the
trail influence. Table II shows the relative importance of the trail and heuristic effect on the final result,
for instances #8, #9, #10 and #15 (from Table I).
By the (   combination, the Ant System achieved the worst results, because it explores the
solution search space by using only co-operation which alone is not a very effective strategy. On the
other hand, by (  combination, the Ant System showed for all instances a stable behaviour,
1095445 1093831 1073356 1095382 1095382 1095232
624319 611140 559648 624116 624319 620872
141278 141098 135717 141278 140778 140618
130623 130623 118379 130233 130623 127523
9however the achieved results were not the best ones. In Figure 1 the best results found in each cycle by
using two different seeds for instance #11 are plotted. It can be seen that the Ant System stuck
prematurely in a local optimum due to the considerable pressure on the trail 
118000
120000
122000
124000
126000
128000
130000
132000
0. 2. 4. 6. 8. 10
.
12
.
14
.
16
.
18
.
Seed 1 Seed 2
Figure 2 shows the changes on the amount of trail on each item for instance #9, along the running of the
Ant System. It can be seen that as the running proceeds, the amount of trail  turns larger on those items
which are part of the solution. On the other hand, the amount of trail is not necessarily zero or near zero
for that items which are not part of the solution. At the bottom of the Figure 2, it is possible to note the
correspondence between the best solution in relation to the amount of trial after 20 cycles.
110111010000111111111111110011110110010011001000000000000000000000000000000000000000000000000000000000000
Figure 3, for the same instance, shows other perspective of the amount of the trial on each item by
plotting that amount for the first (randomly chosen) and the last cycle (when the Ant System converged
to the solution).
10
0
20
40
60
80
100
120
140
160
180
200
Cycle 20
Cycle 1
Finally, it is worth to note that the variation on the (  parameter)  did not
influence strongly  the Ant System performance.
We have shown an alternative approach to solve the Multiple Knapsack Problem. The original
conception applied to Travelling Salesman Problem, Bin Packing and continuous space optimisation
problems, was adapted to obtain an Ant System able to obtain goods solutions for MKP.
Although in some cases the greedy heuristic (local search) was enough, the best performance of the Ant
System was achieved when the trial and heuristic guide the search in conjunction. However, the weight
of the heuristic owned a primary role when the probabilities of the item selection were calculated.
Current research on Ant Systems involves an extensive study regarding the effect on the
performance of the Ant System according different values of its main parameters in order to test harder
instances of MKP [14]. Also, a study considering alternative heuristics, in order to decrease the
computational time of the Ant System, is reported in [15].
The authors wish to acknowledge Prof. 
11
   [6] Dorigo, M.; COMPLETAR!! (1996). "A study of some properties of ANT-Q" - Published in
Proceedings of PPSN IV. Springer-Verlag.
   [5] Fogel, D. COMPLETAR!!  (1995). "Evolutionary Computation, Toward a New Philosophy of
Machine Learning" - IEEE Press.
   [9] Khuri, S; 


The ant colony metaphor for multiple knapsack problem

http://sedici.unlp.edu.ar/bitstream/handle/10915/9392/Documento_completo.pdf?sequence=1

The ant colony metaphor for multiple knapsack problem

Abstract

Similar works

Full text

Available Versions

El Servicio de Difusión de la Creación Intelectual