TSP using Genetic Algorithms in MATLAB

Solving TSP using Genetic Algorithms Mateusz Matyjaszczyk - 140293481 Abstract In the Travelling Salesman Problem (TSP), we wish to visit n cities in the shortest possible time (or distance), without ever visiting any city twice. This problem has a time complexity of O(n!) so an exhaustive search of every solution is infeasible for large n. An alternative to this is the Simple Genetic Algorithm (SGA) which mimics the behaviour of natural selection to find the best route. This report introduces such an algorithm, and then applies it to the TSP using MATLAB. An investigation is made into the behaviour of the algorithm under various parameters.

1 1.1

Introduction Search Problems and Travelling Salesman Problem (TSP)

Suppose we have a collection of items, with each item being slightly different than the other items in the collection. We wish to find an item in this collection with specific characteristics. This is the simplest definition of a search problem. To find this item, we could start by checking each item until we find the item we are looking for. This is called an exhaustive search. Although such an approach is successful if the collection in question is very small, it quickly breaks down for large collections as the time taken to find the item grows drastically. One famous example of a search problem is the Travelling Salesman Problem (TSP). Suppose we are given a number of cities (nodes) and the distances between these cities (edges) such that every city is connected with all the other cities. We wish to compute the shortest distance in which we can travel to every city, without visiting any city twice. There are n cities we wish to visit. Thus, when we choose a starting point we have n − 1 cities to choose from for the next destination. Then, there are n − 2 edges to choose from the next city and so on. Therefore, the number of possible routes is 1

Solving TSP using Genetic Algorithms

Mateusz Matyjaszczyk (140293481)

N = (n − 1)(n − 2)... = (n − 1)!, where N is the number of possible routes. However, due to this being an undirected graph, reverse paths have exactly the same total distance. That is, the route {1, 2, 3, 4} is the same as the route {4, 3, 2, 1}. So, the number of unique routes is given by (n − 1)! . 2 Consider a small number of nodes, say n = 6. Then, there are N = 5!2 = 120 = 60 2 different routes. We could easily use exhaustive search to find the value of every route to obtain the shortest route. Next, consider a problem with n = 16 nodes. Then, = 653, 837, 184, 000 unique routes. Suppose we have a computer there are N = 15! 2 that can examine 100, 000 routes per second. To visit every route, it would take us over 75 days, even at such a high speed of calculations. The time increase is even more concerning for higher values of n. In this project, it will be investigated how search problems with such large search spaces can be tackled using Genetic Algorithms. N=

1.2

Overview of Genetic Algorithms

In the 1970s, Holland (1992) proposed an evolutionary algorithm to tackle search problems, called the Simple Genetic Algorithm (SGA). This algorithm imitates behaviour seen in nature during natural selection. In short, the algorithm has the following procedure: 1. Represent some random solutions as chromosomes. Evaluate the fitness of the chromosomes (how close the solutions are to the goal state). 2. Select fittest chromosomes, called the parent chromosomes. 3. Cross the parent chromosomes using some well defined process to obtain the children. Allow random mutations to occur. 4. Repeat the above steps until a given condition is met (e.g. a certain number of repetitions, solution good enough, etc.) Each of the above steps will now be discussed and some common techniques used in Genetic Algorithms will be shown. 2


2 2.1


Simple Genetic Algorithm (SGA) Representation

Before any computation can take place, the solutions to the search problem need to be expressed as chromosomes, that are made up of genes. In such a representation, the user should easily move between solutions (states) by only performing a small change to the genes. For example, if the solution to a given search problem is an integer, we can express it as a binary number. For example, the solution 105 could Note: In be written as: a binary 1 1 0 1 0 0 1 representaWe can easily move between solutions by flipping one bit. So, by flipping the bit tion the 0, we could go to the state: bits/genes are 1 1 0 1 0 0 0 counted from the (Michalewicz and Fogel, 2004, p.35) propose an alternative representation for the right, TSP. Suppose we number our cities 1, . . . , n. We can express a route by a permutation starting of these values. Thus, for a problem with n = 7 cities, this could be: at 0 4 7 6 1 5 2 1 Suppose we wish to find a similar solution. We could simply increment a single gene by 1. For example changing bit 0 produces the following solution: 4 7 6 1 5 2 2 However, this solution is illegal since we visit the city labeled "2" twice which violates the problem description. A alternative would be to swap two consecutive bits/genes. For example, swapping the two right-most genes produces the following solution: 4 7 6 1 5 1 2 Typically, a genetic algorithm has a large number of chromosomes. Such a collection of chromosomes is called a population while a population at a given time is called a generation. A large population is important for the later stages of the algorithm, but it also increases the number of calculations, and thus decreases the speed of the algorithm. 3


2.2


Fitness Function

We need a way of distinguishing between how well the solutions perform, which in genetic algorithms is called the fitness of the chromosome. A fitness function is used to measure this. (Mitchell, 1996, p. 7-8) used a toy example of maximising a function to illustrate the role of a fitness function. Suppose we have a quadratic fitness function −x2 + 14x + 17, (1) for which we wish to find the maximum. We have a binary representation with 5 bits, similar to the representation seen in Section 2.1. Thus, we can evaluate the fitness using the above function for a small population of 4 chromosomes. 0 0 1 0 1 Value = 5

Fitness = 62

0 0 1 0 1 Value = 7

Fitness = 66

0 1 0 0 1 Value = 9

Fitness = 62

0 1 1 0 0 Value = 12

Fitness = 41

From this, we can see that the second chromosome is the fittest in this population since we wish to obtain the maximum. Next, consider an evaluation function for the TSP. Suppose we have the chromosome: 4 7 6 1 5 1 2 We are able to compute the distance between each consecutive city e.g. 4 and 7 then 7 and 6 and so on. Thus, the fitness of a route in TSP can be simply calculated as the sum of those distances.

2.3 2.3.1

Selection Roulette-Wheel Selection

Once we are able to assess the fitness of a given population, we can select the fittest chromosomes to which we can later apply some operators. The main intuition behind this step is that by choosing the fittest chromosomes as parents, we will also produce fit children using crossover later on. This idea is known as the Buliding Blocks Hypothesis. 4



Roulette-Wheel Selection (RWS) is one of the most basic algorithms for selection. In this method, each individual chromosome has a probability to be selected proportional its fitness. Jebardi and Madiafi (2013) state the following procedure for using RWS: • Let the chromosomes in the population be i = 1, . . . , n. Evaluate the fitness of each chromosome using the fitness function f (i). • Calculate the total fitness, denoted by S = Σni=1 f (i) • For each chromosome, work out their proportional fitness using k(i) =

f (i) S

• Choose each chromosome i with the probability k(i). Consider the example population seen in Section 2.2. Such a population had four chromosomes {i1 , ..., i4 } with the corresponding fitness {62, 66, 62, 41}. The total fitness of this population is S = 231. Thus, the probability of choosing each chromosome is k = {0.27, 0.29, 0.27, 0.18} for each respective value of i. This can then be expressed as intervals, such as 0, ..., 0.27, 0.27, ..., (0.27 + 0.29) and so on. We can then select a parent by generating a random number from the standard uniform distribution and choosing the interval into which this random number falls into. Jebardi and Madiafi (2013) suggest that this method might be unsuitable when a dominant chromosome is present in the population that is much fitter than other chromosomes. In such a case, this chromosome will always be selected and this could lead to premature convergence of the algorithm. 2.3.2

Tournament Selection

Tournament selection (TOS) is an alternative to RWS. This scheme involves choosing a number of chromosomes and then performing a "tournament". The method can be summarised using the following procedure: 1. Choose k chromosomes for the tournament. Order the chromosomes in descending order. Let n = 0. 2. Let 0.5 ≤ p ≤ 0.9. Choose the most fit chromosome with probability p(1 − p)n . 3. If no chromosome has been chosen, continue. Delete the most fit chromosome from the tournament. Increment n. 4. Run the above two steps until a chromosome has been chosen. 5



Selection pressure is the degree to which fitter chromosomes are favoured to be chosen. The more likely the fitter chromosomes are to be chosen, the higher the selection pressure. Since the convergence of the algorithm is largely dependent on selection pressure, Miller and Goldberg (1995) discuss that too little selection pressure could lead to the GA not converging, or taking unnecessarily long to converge. On the other hand, excessive selection pressure could lead to premature convergence, meaning that optimal solution is not found as the algorithm is stuck in a local optima. In addition, Miller and Goldberg (1995) suggest that for tournament selection the selection pressure can be altered by a proper choice of k (size of the tournament). Selection pressure can also be altered by the choice of p. When p is high, the fitter chromosomes are more likely to be chosen, which also increases selection pressure. Jebardi and Madiafi (2013) has shown that GAs which implement TOS have a better convergence rate than ones that use RWS. There exist many other selection schemes such as truncation selection and rank selection. The choice of the scheme is often determined by the problem to be solved and the selection pressure associated.

2.4 2.4.1

Crossover One-point Crossover (1PX)

As outlined in Section 1.2, once some parent chromosomes have been selected, a crossover operation needs to applied to produce children (or offspring) chromosomes. The most basic type of such an operation is the one-point crossover (1PX). Suppose we have two binary chromosomes. We choose a single crossover point, Note: A say between bit 1 and 2. crossover Parent 1 1 0 1 0 0 point is shown Parent 2 0 1 0 1 0 by a double Let the three bits to the left of the crossover points stay the same. The bits to line between the right of the crossover point are swapped between parents. That is, bits 0 and 1 of parent 1 become the bits 0 and 1 of parent 2 and vice versa. Thus, we create the consecutive following children: bits/genes. Child 1 1 0 1 1 0 Child 2

0 1 0 1 0

6



(Sivanandam and Deepa, 2007, p. 51) suggest that using 1PX might not be able to pass desired characteristics to the children. This can occur when the good information is stored at either end of the parent chromosomes. On the contrary, due to the simplicity of 1PX, it also reduces the run time of the GA. 2.4.2

Two-point Crossover (2PX)

To overcome the problem of desired characteristics not being passed on from the parents to the children, an alternative could be to use a two-point crossover (2PX). In such a crossover operator we define two crossover points. The children inherit the head and the tail of the chromosome from the corresponding parent (parent 1 to child 1 and parent 2 to child 2). The information between the crossover points is swapped between parents, that is child 1 obtains the information from parent 2 and vice versa. Next, illustrate this using a simple example. Suppose we have the same pair of parent chromosomes as seen in Section 2.4.1 but the crossover points are now between genes 0 and 1 and between genes 2 and 3: Parent 1 1 0

1 0

0

Parent 2 0 1

0 1

0

Perform the crossover operation by copying the parents and then swapping the bits between the two crossover points defined above. Rename the new chromosomes as children. Child 1

1 0 0 1 0

Child 2

0 1 1 0 0

Next, obtain the fitness of the children using (1). The fitness of the parent 1 and parent 2 can be shown to be −103 and 57 respectively. Similarly, the fitness of child 1 and child 2 is −55 and 41 respectively. Thus, performing the crossover operator creates children that are genetically different to their parents, although some characteristics of the parents are preserved. 2.4.3

Partially-Matched Crossover (PMX)

Next, consider an example of a chromosome representation that is a permutation. Two parents have been selected and a 2PX operator is to be applied. The crossover 7



points are between genes 0 and 1 and between genes 2 and 3. Parent 1 2 3

4 5

1

Parent 1 4 5

2 1

3

⇓ Child 1

2 3

2 1

1

Child 2

4 5

4 5

3

Performing such an operator creates children that are no longer permutations. A way of addressing this problem is to use the partially matched crossover (PMX). Here, we will consider PMX for parents with two crossover points but the technique can be applied to any number of crossover points. Consider the example above, where we obtained two children after performing 2PX operator. Note the violations of the permutations: Child 1

2 3 2 1 1 Violations: 1,2

Child 2


It is desired to keep the value of the genes between the crossover points (the swapped parts between parents) to be the same as this was the outcome of the operator that we applied. Thus, we can change bits 0,3 and 4. We adjust the children by inputting the violations of child 2 into child 1 and vice versa. So, 4 and 5 will be used to correct child 1. Moving from the left, the first violation is 1 which is located in bit 0 and 1. We cannot change bit 1 because it is between crossover points. Thus, we change bit 0 with one of the violations from child 2. It does not matter which violation we choose, but for consistance we will move from smallest to largest value in the violation list. Thus, bit 0 becomes 4. The other violation of child 1 is in bit 2 and bit 4. We cannot change bit 2 as it is between crossover points so we change bit 4 to a value from the violations list for child 2. The only value left in the list is 5 (4 was used for the first violation) so we change the value of bit 4. We apply the same method to obtain a corrected child 2. For this example, the process can be summarised as:

8

Solving TSP using Genetic Algorithms Child 1



First violation is 1 located in bit 0 and 1. Correct bit 0 (outside crossover points) Child 1

2 3 2 1 4

Second violation is 2 located in bit 2 and 4. Correct bit 4 (outside crossover points) Child 1

5 3 2 1 4

This is now a correct permutation. Perform a similar correction for child 2. We go from Child 2

4 5 4 5 3

to Child 2

2 1 4 5 3

which is a correct permutation. Thus the corrected children are: Child 1

5 3 2 1 4

Child 2

2 1 4 5 3

Various other crossover operators exist for permutations, with the most notable ones being cycle crossover (CX) and order crossover (OX). Kumar and Kumar (2012) have shown that for TSP the PMX performs better than the other two crossover operators mentioned.

9


2.5


Mutation

Suppose we have a population of chromosomes: 1 0

1 0 1

1 0

0 1 0

0 0

1 1 1

1 0

1 1 0

Consider bit 3. The only value this gene contains in the whole population is 0. Thus, even if we perform a crossover operator, we might never be able to obtain 1 as the value of this gene. Thus, we need a way of the chromosomes obtaining new information that is not present in the original population. To achieve this, in his original proposal of a genetic algorithm, Holland (1992) proposed a mutation operator. This operator allows each gene to be altered with some small probability 0 ≤ m ≤ 1. For a binary representation, this can be done by generating a random number u from the standard normal distribution and then flipping the bit if u < m. To illustrate this, consider the example below with m = 0.2. Chromosome

1 0 1 0 1

Generate 5 random numbers for i = 1, ..5 u = 0.76, 0.17, 0.74, 0.39, 0.66 Swap each bit if ui < m Updated Chromosome 1 1 1 0 1 Thus, by performing the mutation operator we obtained a chromosome with information that was not available in the original population as bit 3 was flipped. (Sivanandam and Deepa, 2007, p. 56) suggested an alternative mutation operator where the mutation operator is only applied if the mutation would improve the fitness of the chromosome. However, such an operator would increase the running time of the algorithm. 10



For a permutation representation, we cannot apply the above mutation operator as it would create illegal chromosomes. Thus, an alternative would to swap two consecutive genes with probability p. This way, we will always mutate so that the chromosomes are legal solutions (permutations).

3 3.1

Applying SGA to TSP Introduction

TSPLIB is an online library of sample TSP problems. Two of such problems will be selected and then the later proposed genetic algorithm will be applied in MATLAB. The two problems chosen are ulysses16 (n = 16) and ulysses22 (n = 22).

3.2

Representation and Evaluation Function

In section 2.1 we have suggested that a permutation is an appropriate representation for the TSP. In the description of this problem, it states that we also always wish to start and finish in the same city. Thus, for ulysses16 we would always start and finish at node numbered one. Between these two genes, we would have a permutation from 2 to 16. Thus, an example of a chromosome for the problem ulysses16 would be: 1 14 13 12 7 6 15 5 11 9 10 16 3 2 4 8 1 TSPLIB also provides a distance matrix between these cities. We can calculate the score of this chromosome by obtaining the distance between consecutive cities and then summing those distances. For example, considering the example above, the distance can be calculated as follows: Count Current Node 1 1 2 14 .. .. . . 16 8

Next Node Distance 14 479 13 52 .. .. . . 1 60 Total 6859

This is also the optimal route, as defined by the problem description on TSPLIB. The matrix of distances is saved in a .csv file in the directory of the program. This 11



allows the user to choose the distance matrix for which to calculate the route. Thus, for the above route we can use the command: solution=[1,14,13,12,7,6,15,5,11,9,10,16,3,2,4,8,1]; getScore(solution,’ulysses16dist.csv’) ans = 6859 Here, solution is a vector containing the chromosome and ulysses16dist.csv is the name of the file where the matrix of distances is located. This function returns the score, which agrees with the score provided by TSPLIB for this route.

3.3

Initial population

Once we are able to represent routes and score them, we can generate a population of chromosomes. This will be used in the alogirithm to obtain an initial population that we will then apply the genetic alogrithm to. Thus, if we wish to obtain 5 routes and their scores from the ulysses16 problem, we can use the code: [population,scores]=initialPopulation(5,16,’ulysses16dist.csv’) population = 1 9 1 12 1 8 1 4 1 12 scores = 14079

5 4 15 10 10

12 13 10 13 2 13075

7 7 3 6 13

8 15 14 14 8 10968

11 9 5 8 6

13 5 6 15 9 13273

3 3 7 11 15

6 14 11 7 5

... ... ... ... ...

12882

Thus, this function correctly generates legal chromosomes of the problem requested. The scores are also obtained.

3.4

Selection

In Section 2.3 we proposed two selection schemes: Roulette-Wheel Selection (RWS) and Tournament Selection (TOS). Out of these two, Jebardi and Madiafi (2013) have 12



shown that the TOS has a better convergence rate. Thus, for this particular genetic algorithm we will use a TOS scheme. The pseudocode outlined in 2.3.2 has been written as a function. To illustrate the workings of this function, consider the ulysses16 problem with a population size of 10 chromosomes. We wish to perform the selection amongst k = 5 (size of tournament) randomly chosen chromosomes from the population. Select chromosomes using the function defined in 2.3.2 with p = 0.5. Run the following code, using an initial population as generated before. A=initialPopulation(10,16,’ulysses16dist.csv’) tournament_Selection(A,0.5,5) A = 1 1 1 1 1 1 1 1 1 1

9 3 5 4 3 14 6 3 9 9

8 5 12 2 2 15 14 14 2 7

7 7 7 6 10 7 15 11 13 8

13 6 14 10 8 11 7 8 15 15

6 13 2 7 11 5 4 6 4 12

15 12 3 9 9 8 9 13 12 5

12 15 6 8 6 10 2 4 8 3

14... 11... 10... 14... 14... 3... 13... 5... 6... 2...

1 1

9 6

8 14

7 15

13 7

6 4

15 9

12 2

14... 13...

ans =

Hence, the function works correctly by choosing some chromosomes from a given population.

3.5

Crossover

Once some chromosomes have been selected as parents, they will need to be crossed over to obtain children chromosomes. In section 2.4 some common crossover operators have been defined. In section 2.4.3 it was mentioned that Partially Matched 13



Crossover (PMX) is a suitable choice for a permutation representation and that Kumar and Kumar (2012) have shown this operator to have better convergence rates than other common operators for permutation representations. Thus, this genetic algorithm will use a PMX operator. To perform PMX, we will need to define the crossover points. Since we want our genetic algorithm to apply to problems with different number of nodes, it is unsuitable to keep the crossover points constant. For example, crossover points of 5 and 12 might be suitable for ulysses16 since majority of the information within chromosomes will be swapped between the parents. However, such crossover points will be unsuitable for larger problems such as berlin52 with n = 52 nodes since the genes in the interval (12, 52) after this crossover point will not be altered. Thus, we will define the crossover points to be 0.3 and 0.7 of the number of nodes (rounded to the nearest whole number). Run the following code to check the crossover function. A=initialPopulation(10,16,’ulysses16dist.csv’); selected=tournament_Selection(A,0.5,5) children=crossover2PMX(selected) selected = 1 1

13 5

10 10

4 9

14 4

6 8

11 3

15 13

8 6

9 12

7... 14...

children = 1 1

15 5

10 10

4 9

14 4

9 8

3 11

13 15

6 3

12 6

7... 14...

We can see that the parents are significantly different than the children with the information between the crossover points being swapped between the parents to create child chromosomes.Thus, the crossover operator works correctly.

3.6

Mutation

In Section 2.5 it was mentioned that we can perform mutation in a permutation representation by swapping two consecutive bits with a probability m. Such a function 14



was written and it will now be tested using a random population of two chromosomes. Let m = 0.1. A=initialPopulation(2,16,’ulysses16dist.csv’) mutate(A,0.1,2,16) A = 1 5 2 3 12 8 9 7 6 4 15 10 11 14 13 1 1 14 9 11 8 2 5 10 7 (4 12) 15 6 13 3 1 ans= 1 5 2 3 12 8 9 7 6 4 15 10 11 14 13 1 1 14 9 11 8 2 5 10 7 (12 4) 15 6 13 3 1

Here, we can see that in the bottom chromosomes 4 and 12 have swapped positions (shown in brackets). Thus, this function works correctly.

3.7

Termination criteria

Before running a genetic algorithm, we need to define a termination criteria. This will allow the genetic algorithm to terminate when a desired solution is found. One option is to consider the function to look for a certain solution. Thus, the program will run until a chromosome with a specific score is reached. If we are looking for the best solution to the ulysses22 problem, we will terminate the algorithm when the best score in the population is 6859. This approach is valid when we are looking for a specific solution that is ’good enough’ e.g. we want a solution that is lower than 7500 but we are not interested in the optimal one. However, if we wish to find an optimal route, we would usually not know the score of the optimum solution so we cannot use this approach in such a case. This approach can also result in the algorithm getting stuck in a local minimum. If we wish to run the ulysses16 problem until we find a solution lower than 8500 we run the following code: main(50,30,0.1,9500,0.5,’ulysses16’) Second consideration could be to terminate the algorithm after a solution has not improved for a certain q number of generations. For example, we are running an algorithm with q = 50. In iteration 70 we improved our solution. We keep running the solution and find that the solution in iteration 120 has the same score as in 15



iteration 70 so we terminate the algorithm. Such an approach could lead to premature termination if the algorithm cannot escape a local optima. This termination criteria can be run using the command with q = 50: main2(30,20,0.1,50,0.5,’ulysses16’) The final option for a termination criteria is a combination of the two criteria above. We would run the algorithm while these criteria are satisfied: the score of the best chromosome is greater than some threshold and the solution has improved in the last q iterations. If the second condition is broken, the algorithm would restart. This would be repeated until we find the solution lower than the score we are looking for. Suppose we wish to find a solution with a score less than 8500 for the ulysses16 problem. We also let q = 50, that is we restart the program if no improvement has been made in 50 steps. main3(30,20,0.1,50,0.5,’ulysses16’,8500)

3.8

Visualising the performance of the algorithm

In order to help determine how well a given run of the algorithm performs, some characteristics of each generation need to be captured. One such characteristic is the fitness score of the fittest chromosome, which is the distance of the best solution found so far. The change of this over time can tell how fast the algorithm converges and whether it is getting stuck in a local optima. This allows us to determine the behaviour of the algorithm under certain parameters which in turn allows us to choose appropriate choices of the parameters in order to find the optimum solution. Another characteristic of the generation we may be interested in is the average fitness score of all chromosomes in the population. This can tell us how diverse our population is. The more diverse a population is, the smaller the selection pressure and this results in the algorithm being less likely to get stuck in a local optima. Given some termination criteria, we want to compare the fitness of the initial population with the fitness of the final population. To do this, we may take the best solution in each of these generations and plot it. TSPLIB provides the positions of the nodes in the problem which can then be plotted as points in the right order to visualise a path. When calling a problem, say ulysses16 the program will read the positions from the file ulysses16pos.csv, provided such a file is located in the same directory. We will show the workings of such a function by generating two random chromosomes from the ulysses16 problem and plotting the solutions. Note that here the two solutions are randomly generated using the initial population function seen 16



earlier on, but in the main program these will be the best solutions in the first and final generations. A=initialPopulation(2,16,’ulysses16dist.csv’) drawRoute(A(1,:),A(2,:),’ulysses16dist.csv’,’ulysses16pos.csv’) The output of this command can be seen in Figure 1. Figure 1: An example of visualising two random solutions.

4 4.1

Results Investigating the effect of the size of the population

It will now be investigated how the size of the population effects the convergence of the algorithm. To investigate this, the program obtains the value of the fittest 17



chromosome of each consecutive generation and upon terminating plots these values against the number of the generation. In addition, the average fitness of each generation is also shown as this can be used to comment on the diversity of the population. The algorithm was run with three different sizes of the population: 10, 25 and 40. The program uses the second termination criteria (see Section 3.7) so it assumes that the program is stuck in a local optima when an improved solution has not been found in the last 150 generations. The other parameters have been kept constant. The results of such a test are shown in Figure 2. Firstly, consider the number of generations performed by each execution. The number of generations increases as the population size increases: we have 191 generations for population size of 10, 339 generations for a population size of 25 and finally 751 generations for a populations of size 40. (Holland, 1992) states that the genetic algorithm aims to avoid getting stuck in a local optima by keeping a large population of solutions. The results obtained here correspond to this, as the number of iterations before the run is stuck in a local optima increases as the population size increases. Also, compare the values of the minimum and the average. The difference between these two values tells us how varied our population is. The closer the two are, the more uniform the population is. Similar populations are undesired as this increases the chance of the algorithm getting stuck in a local optima. In Figure 2 we can clearly see that the population is much more diverse for larger population sizes, due to the bigger difference between the minimum and the average. It is worth noting that the best solution found is closer to the optimal solution for higher population sizes. However, increasing the population size also causes the running time of the algorithm to increase. In Figure 2 the running time of each run of the algorithm has been noted. Since the runs have a different number of generations, we need to work out the time taken to obtain each generation. Thus, we divide the running time by the number of generations for each run. We obtain values of 0.055, 0.075 and 0.095 for the population sizes of 15, 25 and 40 respectively. Thus, the running time per generation increases with the population size. To conclude, we have shown how the population size can affect the convergence of the genetic algorithm. Thus, it is important to keep the population diverse by having a large population size at each generation. However, we have also shown that increasing the population size increases the running time. Therefore, due to this trade-off, the population size should be large enough to avoid local optima but not overly large so that the computation time becomes infeasible. 18


4.2


Investigating the effect of mutation

We have applied a mutation operator to help keep genetic diversity in each generation. It will now be investigated how different mutation rates can affect the convergence of our algorithm. Results of such an experiment are shown in Figure 3. When m = 0, there is no mutation present. Thus, if some information is not present in the initial generation, we will not be able to reach solutions with those characteristics. Thus, an algorithm which does not use the mutation operator is much more likely to get stuck in a local optima, where every solution eventually becomes the same. This is the case in the graph for m = 0 in Figure 3 as the average and minimum solutions are identical for generations > 25 which indicates that all the chromosomes in the population are exactly the same. Note that the last generation the minimum solution has improved in is generation 9. As we increase the mutation rate, we also increase the difference between the average and the minimum solution. Thus, mutation helps us to maintain a diverse population. In turn, this allows the algorithm to not converge prematurely. The number of generations of each run is also noted. We can see that as we increase m we also increase the number of generations. This corresponds with what we found above, that the higher mutation rates decrease the chance of getting stuck in a local optima. The minimum solutions also seem to be lower for the higher mutation rates. However, very high mutation rates are also undesirable. In such cases, the genetic algorithm behaves more like a random walk as good characteristics are less likely to be preserved which could lead to the algorithm taking unnecessarily long to converge.

5

Optimal solution found

For the ulysses16 an optimal solution was found and it can be seen in Figure 4. The command used to obtain this result is main3(30,20,0.1,150,0.5,’ulysses16’,6859). As was found in Section 4.1, higher population sizes tend to keep the population more diverse which is a desired characteristic. However, an overly large population size can result in low running speed of the algorithm. Thus, a population size of 30 was chosen, which allowed for a diverse population while keeping the computation reasonably fast. We have also chosen the mutation parameter m = 0.1. This was investigated in Section 4.2 and it was found that mutation can help in keeping the population 19



diverse. When m is too large, the algorithm behaves more like a random walk, meaning that the algorithm runs unnecessarily long. A value was chosen between these two extremes. We are also required to specify two parameters for tournament selection. We need to choose k (the size of the tournament) and p (probability of selecting each chromosome). It is desired to keep k large as this allows for a larger variety of chromosomes to be selected. Recall that 0.5 ≤ p ≤ 0.9. A small p leads to less fit chromosomes being more likely to be chosen while a large p means that the fittest parents are almost always chosen. Thus, a small p was chosen so that the algorithm is more likely to choose less fit parents which in turn could mean that the algorithm is less likely to get stuck in a local optima. Finally the other two parameters is the solution to be found (in this case this is 6859) and q (the number of generations after which we restart the algorithm if a solution was not found). Finding the optimal solution using this command can take some time and varies with each execution due to the aspects of randomness in selection and mutation. Next, the algorithm was applied to ulysses22 problem. The following function was used to find a solution with a score of 7200 or less. main3(20,20,0.1,150,0.5,’ulysses22’,7200). The results can also be seen in Figure 5. The algorithm has been unable to find the optimal solution of 7013 due to being stuck in a local optima. However, the solution found with a score of 7153 is still a very good solution. When considering the graphed version of this solution (shown in the bottom figure) it can be seen that this is close to what one would imagine the optimal solution to be. The only difference between this solution and the optimal one probably is a few swaps in the very ’congested’ area in the middle. The solution found is superior to the best chromosome in the initial population. Finally, this example shows how genetic algorithms can be applied in practice. When usually faced with a large TSP problem, we will not know the optimal solution. Thus, we would not be able to tell if the found solution is the optimal one. We could instead search for a solution that is below a certain threshold (7200 here). Once such a solution has been found, we would decrease the threshold and look for a solution below this new threshold. We could continue this until the algorithm is not finding an optimal solution in some time.

20


6


Conclusion

In this project, we have outlined the workings of the Simple Genetic Algorithm. We have introduced a number of selection schemes (Rolette Wheel Selection, Tournament Selection) and crossover operators (One-Point Crossover, Two-Point Crossover, Partially Matched Crossover) as well as the general approach to solving search problems (Fitness function, representation etc.). These tools can be applied to solve a range of search problems. However, many other operators exist for the genetic algorithm which may be suited better for different problems. Michalewicz and Fogel (2004) mentions that there are as many genetic algorithms as there are problems that they are built to solve. With the knowledge of the workings of the Genetic Algorithm, we have applied this to the Travelling Salesman Problem. We considered two problems: ulysses16 with 16 nodes and ulysses22 with 22 nodes. We defined a permutation representation and then applied the knowledge of genetic algorithms to choose suitable operators for this algorithm. We have chosen the algorithm to have a tournament selection scheme and a partially matched crossover. These choices have been based on research that has shown these to be the most suitable choices of operators for TSP. We introduced a mutation operator that swaps two consecutive genes with some probability. To help visualise the workings of the algorithm, we graph some characteristics of the population over the running of the algorithm. We also visualise the initial and optimal solutions as graphs to show the difference between the starting solution and the optimal one found. Finally, we defined three different termination criteria for the algorithm. We then investigated the effect of the size of the population and the mutation probability. We found that higher population sizes help to maintain diversity of the population. However, there is a trade-off as the running time of the algorithm is extended. It was also shown that mutation has a similar trade-off where some mutation can help to keep a diverse population but a very high mutation rate could lead to the algorithm taking unnecessarily long to converge. Using these results we run the algorithm to find the best solution for the ulysses16 problem. We knew the optimal solution so the algorithm was allowed to run until we found this specific solution. Such an approach is not useful in practice as we usually are not aware of the optimal solution. Thus, an approach where we look for a solution below a certain threshold was suggested. The best solution found for this problem was 7153, whilst it can be shown that the optimal solution for this problem is 7013. This project can easily be extended to look at problems with a larger number 21



of nodes. There are many different selection schemes and crossover operators which have not been covered which can also be investigated. Finally, there are other metaheuristic algorithms such as simulated annealing or tabu search that can be applied to solve this problem.

References J.H. Holland. Adaptation In Natural And Artificial Systems: An Introductory Analysis With Applications To Biology, Control, And Artificial Intelligence, 2nd Edition. A Bradford Book, 1992. K. Jebardi and M. Madiafi. Selection methods for genetic algorithms. Int.J.Emerg.Sci., 3:333–344, 2013. Bidhan K. Kumar, N. and R. Kumar. A comparative analysis of pmx, cx and ox crossover operators for solving travelling salesman problem. IJLRST, 1:98–101, 2012. Z. Michalewicz and D.B. Fogel. How to Solve It: Modern Heuristics, 2nd Edition. Springer, 2004. B.L. Miller and D.E. Goldberg. Genetic algorithms, tournament selection, and the effects of noise. Comp. Sys., 9:193–212, 1995. M. Mitchell. An Introduction To Genetic Algorithms. A Bradford Book, 1996. S. N. Sivanandam and S. N. Deepa. Introduction to Genetic Algorithms. Springer, 2007.

22



Figure 2: The graphs for average and minimum path for different settings of the size of the population. The other parameters have been kept at constant, meaningful rates. The runtime of each execution is also shown.

(a) Population size = 10 RUNTIME: 10.42 seconds

(b) Population size = 25 RUNTIME: 25.47 seconds

(c) Population size = 40 RUNTIME: 71.37 seconds

23



Figure 3: The graphs for average and minimum path for different settings of the mutation rate. The other parameters have been kept at a constant, meaningful rates.

(a) Mutation rate m = 0

(b) Mutation rate m = 0.01

(c) Mutation rate m = 0.05

(d) Mutation rate m = 0.10

24



Figure 4: The optimal solution found for the ulysses16 problem

(a) Behaviour of the algorithm over time

(b) Optimal route

25



Figure 5: The best solution found for the ulysses22 problem

(a) Behaviour of the algorithm over time

(b) Optimal route

26

TSP using Genetic Algorithms in MATLAB

Recommend Documents