travelling salesman problem
DESCRIPTION
travelling salesman problem is analysed using two algorithms , particle swarm optimization and genetic algorithmTRANSCRIPT
![Page 1: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/1.jpg)
EEL706
SOFT COMPUTING
A COMPARATIVE STUDY ON PARTICLE SWARM
OPTIMIZATION AND GENETIC ALGORITHMS FOR
TRAVELLING SALESMAN PROBLEMS
Ankit Nayan (2009EE50474)
Ashok Meghwal (2009EE50478)
Iftikar Ansari (2009EE50482)
Priyanshu Jain (2009EE50485)
![Page 2: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/2.jpg)
INTRODUCTION
This project deals with a performance evaluation of particle swarm optimization
(PSO) and genetic algorithms (GA) for travelling salesman problem (TSP). This
problem is known to be NP-hard, and consists of the solution containing N!
permutations. The objective of the project is to compare the ability to solve the
large-scale and other benchmark problems for both algorithms.
The travelling salesman problem (TSP), which is known to be NP-hard in the field
of discrete or combinatorial optimization, is concerned with finding an optimum
path of travel in pre-located cities which are characterized using the coordinates
on a map while minimizing the total cost associated with the path Also, it has
been expressed as a non-deterministic polynomial (NP-hard) problem. In this
project, a large-scale travelling salesman problem is solved by PSO and GA over
multiple runs. In addition, these algorithms are compared to determine which one
produced better results. The results show that PSO has a good convergence
property (i.e., average generation) compared to GA, but in terms of the
effectiveness of solutions, it is not as good as GA. Both algorithms for addressing
problems can obtain solutions in similar execution time.
TRAVELLING SALESMAN PROBLEM
Formally, TSP can be defined as follows A travelling salesman who is required to
visit N cities exactly one time returns to the starting node with the shortest
distance. This can be admitted as a permutation problem that aims at finding
the shortest distance (the minimum cost) on cities or the node to be visited. The
Given N cities or nodes, a cost matrix C=[Cij] is searched for a permutation :
where Cij represents the cost of the travel from city i to j, which minimizes
the distance, f( ,C).
![Page 3: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/3.jpg)
PARTICLE SWARM OPTIMIZATION
Particle swarm optimization, which is a population-based algorithm like GAs, is
an optimization technique which is based on social intelligence which exists in
biological population. Social intelligence exhibits adaptive capabilities of people
and animals by implementing an ‘‘information sharing’’ approach, furthermore
also contributes to the creation, facilitation, and maintenance of critical
behaviours.
![Page 4: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/4.jpg)
The PSO Algorithm for TSP
Wang et al. (2003) introduced the concepts of ‘Swap operator’ and ‘Swap
sequence’ redefining PSO operators for TSP problems. Here, we have
briefly explained the discrete PSO algorithm. A normal solution sequence of
TSP with n nodes is assumed as follows:
S=(bi), i =1,2,…,n
![Page 5: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/5.jpg)
![Page 6: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/6.jpg)
GENETIC ALGORITHMS
Genetic Algorithms are stochastic search techniques that are based on the ideas of
selection of the fittest, crossing, and mutation in nature. They have been used
successfully for solving a wide variety of different problems, including the TSP. A
population of chromosomes, which is represented with different codes such as
binary, real, and permutation, is changed by probabilistic application of the genetic
operators (i.e., selection, crossover, and mutation) in each generation.
![Page 7: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/7.jpg)
The fitness of chromosomes is measured by the objective function. As a class of
stochastic methods, GAs are different from random search methods. While GAs
carry out a multidirectional search by maintaining a population of potential
solution, random methods consisting of a combination of iterative search
methods and simple random search methods can find a solution for a given
problem. One of the GAs most attractive features is that GA has the ability to
explore the search space by considering the entire population of the
chromosomes.
The basic steps of the genetic algorithm are given in the following:
(1) generate the initial population (2) evaluate the fitness of each individual (3) apply selection for individuals (4) apply crossover and mutation selected individuals (5) evaluate and introduce the reproduced individuals.
In TSP, GA is implemented in the following way.
Initial Population and Encoding
The initial population is randomly generated and each chromosome in the
population represents a solution to the problem (i.e., a tour). The fitness of
the chromosome means the tour length that is coded into it and depends on
the ordering of the cities. The GA searches the space of solutions to obtain a
best approximate tour. For instance, the chromosome shown in the following
represents the ‘‘path’’ representation of a tour with eight cities.
![Page 8: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/8.jpg)
Evaluation of Fitness
The evaluation function is an important indicator and is used to decide how
‘‘good’’ a chromosome is under environmental conditions. The fitness of each individual is calculated using Equation (1).
Selection
The selection is applied to the population by using alternative technique such as a
roulette wheel tournament. In general, the selection is dependent upon the
fitness level of the individuals actually existing in the population. In this study,
tournament selection, which is based on a tournament among a few individuals
chosen at random from the population, is used. That is, an individual is chosen
for transferring into the next generation if he has better fitness value than other
individuals of the population.
Crossover and Mutation
Crossover and mutation are highly efficient evolutionary operators to successful
applications of GAs. Crossover can maintain good common genes in the parents,
and also search new possibilities of recombining non common genes to converge
to an optimal solution. The two parents are randomly recombined to create a
new offspring which will be inserted into a new population in the next generation.
Although it is said that mutation increases the diversity of the population by
exploring the entire solution space, rather than diversity it is used to rectify
infeasible chromosomes generated by a crossover operator.
In this study, cycle crossover (CX) and swap mutation (EM) were used. A schematic
illustration of how these genetic operators work is given in Figure 1. For instance,
assuming an 8-city TSP, (ACEBFDGH) corresponds to a tour starting from city A,
visiting C, E, B, F, D, G, H in that order and returning back to A. In the CX crossover,
the recombination is performed under the constraint that each gene comes from
one parent or the other. The CX crossover operator is as shown.
![Page 9: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/9.jpg)
The cycle that is defined in a manner similar to an algebraic permutation group
always starts from the first position. Symbols in the cycle ofParent1 are copied
into the same positions ofChild1, and these symbols are removed from the
Parent2. The residual symbols of the parent are copied into the Child1. By
changing the roles of parents, the same procedure is applied to generate the
second child.
The EM is shown in Figure 1(b). In the EM, the two genes selected randomly
along the chromosome are swapped. So the genes coded into phenotype are to
rearrange in a way.
Termination Criterion
The termination criterion can be selected in different ways: reaching the
predefined fitness value, the number of generations, or a non-existing difference
in the fitness value of each generation. In this article, a fixed generation number
is used as the termination criterion.
![Page 10: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/10.jpg)
EXPERIMENTAL RESULTS
Because GA and PSO are accepted as the random search algorithm, different results
may be obtained at the end of every run. Therefore, multiple independent runs
having different random seeds were performed to achieve a good solution.
RESULTS AND DISCUSSIONS
The relative error, which indicates how close the solution is to the known global solution, is considered in the performance measurement and calculated by:
Where Av is the average fitness value for the total number of runs under each
problem, Op is the best known solution so far. Table 1 shows the known solution,
average length, and relative error for the problems with synthetic data. After the
program is run 30 times, the results are noted. In Table 1, ‘‘the known solution’’
is the found best solution; ‘‘average length’’ is the average length of 30 running.
Figure 3 shows the relative errors according to average length for the problems
with synthetic data. In this test, the computational effort of PSO and the GA was
especially investigated for the same parameter settings. Also the effectiveness
in terms of the solutions found by the algorithms was evaluated with respect to
![Page 11: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/11.jpg)
known solutions for the test problems.
As can be seen in Table 1, in general, PSO converges to a solution in less
generation than that of the GA. Regarding the average generation, PSO is better
than the GA. However, in terms of the average length, the relative error, and
computational time, it can be easily argued that the GA is more successful than
the PSO. The optimum paths found by both algorithms is close to each other in
this case.
![Page 12: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/12.jpg)
CONCLUSIONS
Particle Swarm Optimization is a relatively recent heuristic search method based
on social behaviour of bird flocking or fish schooling in searching for food, which
is sometimes referred to as an evolutionary algorithm because of similarities.
Particle swarm optimization and Gas are population-based search methods, and
provide the information-sharing among their population members by moving in a
search space using a combination of deterministic and probabilistic rules. The
obtained results showed that PSO has rapidly converged to a solution but could
get stuck on local minimum. Considering the optimum path and the relative error
in terms of quality of solution, the GA has a better performance compared to
PSO. It should also be noted that today the performance improvement studies for
the PSO-based approach are conducted by scientists so that a global solution or a
near-global optimal solution are obtained in TSPs.
REFERENCES
[1] Ozcan, E. and Erenturk, M. 2004. A brief review of memetic algorithms
for solving Euclidean 2D travelling salesrep problem.Proc. of the 13th Turkish
Symposium on Artificial Intelligence and Neural Networks99–108. [2] Shi, X. H., Zhou, Y., Wang, L. M., Wang, O. X., and Liang, L. C. 2006. A discrete
particle swarm optimization algorithm for travelling salesman problem.
Computational Methods1063–1068. [3] Özsaˇ glam, M. Y. 2008. Application of particle swarm optimization algorithm
to travelling salesman problem and its performance investigation. Master thesis,
Selcuk University, Konya, Turkey. [4] Oliver, I. M., Smith, D. J., and Holland, J. R. C. 1987. A study of permutation
crossover operators on the travelling salesman problem.Proceedings of the
Second International Conference on Genetic Algorithms and their
Applications, Hillsdale, NJ, 224–230.
![Page 13: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/13.jpg)
[5] Al-Dulaimi, B. F. and Ali, H. A. 2008. Enhanced travelling salesman
problem solving by genetic algorithm technique. Proceedings of World
Academy of Science, Engineering and Technology28: 296–302. [6] Bhattacharyya, M. and Bandyopadhyay, A. K. 2009. Comparative study of
some solution methods for travelling salesman problem using genetic
algorithms. Cybernetics and Systems40: 1–24.
![Page 14: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/14.jpg)
2.JAVA PROGRAM AND RESULTS FOR TRAVELLING
SALESMAN PROBLEM USING PARTICLE SWARM
ORGANISATION ALGORITHM
![Page 15: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/15.jpg)
package tspusepso; import java.util.ArrayList;
import java.util.Random; public class Main { public static class Swarm_Ex2b {
private static final int PARTICLE_COUNT = 8; private static final int V_MAX = 4; // Maximum velocity change
allowed. private static final int MAX_EPOCHS = 1000; private static ArrayList<Particle> particles =
new ArrayList<Particle>(); private static ArrayList<cCity> map = new
ArrayList<cCity>(); private static final int CITY_COUNT = 8; private static final double TARGET =
86.63; // Number for algorithm to find. //(30, 5), (40, 10), (40, 20), (29, 25), (19, 25), (9, 19), (9, 9),
(20, 5)
private static int XLocs[] = new int[] {30,40,40,29,19,9,9,20};
private static int YLocs[] = new int[] {5,10,20,25,25,19,9,5};
private static void initializeMap()
{ for(int i = 0; i < CITY_COUNT; i++)
{ cCity city = new cCity();
city.x(XLocs[i]);
city.y(YLocs[i]);
map.add(city); } return;
}
private static void PSOAlgorithm()
{ Particle aParticle =
null; int epoch = 0; boolean done = false;
initialize();
while(!done)
{
// Two conditions can end this loop: // if the maximum number of epochs allowed has been reached,
or, // if the Target value has been found.
if(epoch < MAX_EPOCHS){
for(int i = 0; i < PARTICLE_COUNT; i++)
![Page 16: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/16.jpg)
{
aParticle = particles.get(i);
System.out.print("Route: ");
for(int j = 0; j < CITY_COUNT; j++) {
System.out.print(aParticle.data(j) + ",
"); } // j
getTotalDistance(i);
System.out.print("Distance: " + aParticle.pBest() + "\n");
if(aParticle.pBest() <=
TARGET){ done = true; }
} // i
bubbleSort(); // sort particles by their pBest scores, best to worst.
getVelocity();
updateparticles();
System.out.println("epoch number: " + epoch);
epoch++;
}else{
done = true; }
} return;
}
private static void initialize()
{ for(int i = 0; i < PARTICLE_COUNT; i++)
{ Particle newParticle = new Particle();
for(int j = 0; j < CITY_COUNT; j++) {
newParticle.data(j, j);
} // j
particles.add(newParticle);
for(int j = 0; j < 10; j++) {
randomlyArrange(particles.indexOf(newParticle)); } getTotalDistance(particles.indexOf(newParticle));
} // i return;
}
private static void randomlyArrange(final int index)
{ int cityA = new Random().nextInt(CITY_COUNT);
int cityB = 0;
![Page 17: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/17.jpg)
boolean done =
false; while(!done) {
cityB = new Random().nextInt(CITY_COUNT);
if(cityB != cityA){ done = true;
} }
int temp = particles.get(index).data(cityA);
particles.get(index).data(cityA, particles.get(index).data(cityB));
particles.get(index).data(cityB,
temp); return; } private static void getVelocity() {
double worstResults =
0; double vValue = 0.0;
// after sorting, worst will be last in list.
worstResults = particles.get(PARTICLE_COUNT - 1).pBest();
for(int i = 0; i < PARTICLE_COUNT; i++)
{ vValue = (V_MAX * particles.get(i).pBest()) / worstResults;
if(vValue > V_MAX){
particles.get(i).velocity(V_MAX); }else if(vValue < 0.0){
particles.get(i).velocity(0.0); }else{
particles.get(i).velocity(vValue); }
} return;
} private static void updateparticles() {
// Best is at index 0, so start from the second
best. for(int i = 1; i < PARTICLE_COUNT; i++)
{
// The higher the velocity score, the more changes it will need. int changes =
(int)Math.floor(Math.abs(particles.get(i).velocity()));
System.out.println("Changes for particle " + i + ": " +
changes); for(int j = 0; j < changes; j++){ if(new Random().nextBoolean()){
randomlyArrange(i); } // Push it closer to it's best
neighbor. copyFromParticle(i - 1, i); } // j
// Update pBest value.
![Page 18: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/18.jpg)
getTotalDistance(i);
} // i
return;
}
private static void printBestSolution()
{ if(particles.get(0).pBest() <=
TARGET){ // Print it. System.out.println("Target
reached."); }else{ System.out.println("Target not reached");
} System.out.print("Shortest Route: ");
for(int j = 0; j < CITY_COUNT; j++) {
System.out.print(particles.get(0).data(j) + ",
"); } // j System.out.print("Distance: " + particles.get(0).pBest() +
"\n"); return; }
private static void copyFromParticle(final int source, final
int destination) {
// push destination's data points closer to source's data
points. Particle best = particles.get(source); int targetA = new Random().nextInt(CITY_COUNT); // source's city
to target. int targetB = 0;
int indexA = 0;
int indexB = 0;
int tempIndex = 0;
// targetB will be source's neighbor immediately
succeeding targetA (circular). int i = 0; for(; i < CITY_COUNT; i++) {
if(best.data(i) == targetA){
if(i == CITY_COUNT - 1){ targetB = best.data(0); // if end of array,
take from beginning. }else{
targetB = best.data(i + 1); } break;
} }
// Move targetB next to targetA by switching
values. for(int j = 0; j < CITY_COUNT; j++) {
if(particles.get(destination).data(j) ==
targetA){ indexA = j; }
![Page 19: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/19.jpg)
if(particles.get(destination).data(j) ==
targetB){ indexB = j; }
} // get temp index succeeding indexA.
if(indexA == CITY_COUNT - 1){ tempIndex =
0; }else{ tempIndex = indexA + 1;
}
// Switch indexB value with tempIndex value.
int temp = particles.get(destination).data(tempIndex);
particles.get(destination).data(tempIndex, particles.get(destination).data(indexB));
particles.get(destination).data(indexB, temp);
return;
}
private static void getTotalDistance(final int index)
{ Particle thisParticle = null;
thisParticle = particles.get(index);
thisParticle.pBest(0.0);
for(int i = 0; i < CITY_COUNT; i++)
{ if(i == CITY_COUNT - 1){
thisParticle.pBest(thisParticle.pBest() + getDistance(thisParticle.data(CITY_COUNT - 1), thisParticle.data(0)));
// Complete trip. }else{ thisParticle.pBest(thisParticle.pBest()
+ getDistance(thisParticle.data(i), thisParticle.data(i + 1)));
} } return;
}
private static double getDistance(final int firstCity, final
int secondCity) {
cCity cityA = null;
cCity cityB = null;
double a2 = 0;
double b2 = 0; cityA = map.get(firstCity);
cityB = map.get(secondCity); a2 = Math.pow(Math.abs(cityA.x() - cityB.x()), 2); b2 = Math.pow(Math.abs(cityA.y() - cityB.y()), 2);
return Math.sqrt(a2 + b2);
}
private static void bubbleSort()
{
![Page 20: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/20.jpg)
boolean done =
false; while(!done) {
int changes = 0; int listSize = particles.size();
for(int i = 0; i < listSize - 1; i++) {
if(particles.get(i).compareTo(particles.get(i + 1)) == 1){
Particle temp = particles.get(i);
particles.set(i, particles.get(i +
1)); particles.set(i + 1, temp); changes++;
} } if(changes == 0){
done = true; }
} return;
}
private static class Particle implements Comparable<Particle>
{ private int mData[] = new int[CITY_COUNT];
private double mpBest = 0; private double mVelocity = 0.0;
public Particle()
{
this.mpBest = 0;
this.mVelocity = 0.0; }
public int compareTo(Particle that)
{ if(this.pBest() <
that.pBest()){ return -1; }else if(this.pBest() >
that.pBest()){ return 1; }else{
return 0; }
}
public int data(final int index)
{ return this.mData[index];
}
public void data(final int index, final int value)
{ this.mData[index] =
value; return; } public double pBest()
![Page 21: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/21.jpg)
{
return this.mpBest; }
public void pBest(final double value)
{ this.mpBest =
value; return; }
public double velocity()
{ return this.mVelocity;
}
public void velocity(final double velocityScore)
{ this.mVelocity =
velocityScore; return; }
} // Particle private static class cCity
{
private int mX = 0;
private int mY = 0;
public int x()
{ return mX;
}
public void x(final int xCoordinate)
{ mX = xCoordinate;
return; }
public int y()
{
return mY; }
public void y(final int yCoordinate)
{
mY = yCoordinate;
return; }
} // cCity public static void main(String[] args)
{
initializeMap(); PSOAlgorithm(); printBestSolution(); return;
}
![Page 22: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/22.jpg)
} }
RESULTS: Changes for particle 1: 2 Changes for particle 2: 2
Changes for particle 3: 3 Changes for particle 4: 3 Changes for particle 5: 3 Changes for particle 6: 3 Changes for particle 7: 4
epoch number: 1 Target reached. Shortest Route: 0, 7, 6, 5, 4, 3, 2, 1, Distance: 86.62998956150375 BUILD SUCCESSFUL (total time: 2 seconds)
![Page 23: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/23.jpg)
1.MATLAB PROGRAM AND RESULTS FOR
TRAVELLING SALESMAN PROBLEM USING GENETIC
ALGORITHM
![Page 24: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/24.jpg)
![Page 25: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/25.jpg)
![Page 26: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/26.jpg)
![Page 27: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/27.jpg)
![Page 28: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/28.jpg)
![Page 29: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/29.jpg)
![Page 30: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/30.jpg)
![Page 31: travelling salesman problem](https://reader034.vdocuments.mx/reader034/viewer/2022042603/55cf9ab1550346d033a2ee37/html5/thumbnails/31.jpg)