ga data (2)

8/2/2019 ga data (2)

1/21

What is the Structure of a Simulated Annealing Algorithm

We will now examine the structure of the simulated annealing algorithm. There are several

distinct steps that the simulated annealing process goes through as the temperature is decreased,

and randomness is applied to the input values. Figure 9.1 shows this process as a flowchart.

Figure 9.1: Overview of the simulated annealing process

As you can see from Figure 9.1 there are two major processes that are occurring during thesimulated annealing algorithm. First, for each temperature the simulated annealing algorithm

runs through a number of cycles. This number of cycles is predetermined by the programmer. As

8/2/2019 ga data (2)

2/21

the cycle runs the inputs are randomized. In the case of the traveling salesman problem, these

inputs are the order of the cities that the traveling salesman will visit. Only randomizations whichproduce a better suited set of inputs will be kept.

Once the specified number of training cycles has been completed, the temperature can be

lowered. Once the temperature is lowered, it is determined of the temperature has reached thelowest allowed temperature. If the temperature is not lower than the lowest allowed temperature,

then the temperature is lowered and another cycle of randomizations will take place. If thetemperature is lower than the minimum temperature allowed, the simulated annealing algorithm

is complete.

At the core of the simulated annealing algorithm is the randomization of the input values. This

randomization is ultimately what causes simulated annealing to alter the input values that the

algorithm is seeking to minimize. This randomization process must often be customized for

different problems. In this chapter we will discuss randomization methods that can be used bothfor the traveling salesman problem and neural network training. In the next section we will

examine how this randomization occurs.

How are the Inputs Randomized

An important part of the simulated annealing process is how the inputs are randomized. Thisrandomization process takes the previous values of the inputs and the current temperature as

inputs. The input values are then randomized according to the temperature. A higher temperature

will result in more randomization, a lower temperature will result in less and randomization.

There is no exact method defined by the simulated annealing algorithm for how to randomize the

inputs. The exact nature by which this is done often depends on the nature of the problem being

solved. When comparing the methods used in simulated annealing for both the travelingsalesman and neural network weight optimization we can see some of these differences.

Simulated Annealing and Neural Networks

The method used to randomize the weights of a neural network is somewhat simpler than the

traveling salesman's simulated annealing algorithm. A neural network's weight matrix can bethought of as a linear array of floating point numbers. Each weight is independent of the others.

It does not matter if two weights contain the same value. The only major constraint is that there

are ranges that all weights must fall within.

Because of this the process generally used to randomize the weight matrix of a neural network isrelatively simple. Using the temperature, a random ratio is applied to all of the weights in the

matrix. This ratio is calculated using the temperature and a random number. The higher thetemperature, the more likely the ratio will cause a larger change in the weight matrix. A lower

temperature will most likely produce a smaller ratio. This is the method that is used for the

simulated annealing algorithm that will be presented in Chapter 10. In chapter 10 you will beshown an exact Java implementation of the algorithm.

8/2/2019 ga data (2)

3/21

Simulated Annealing and the Traveling Salesman Problem

The method used to randomize the path of the traveling salesman is somewhat more complex

than randomizing the weights of a neural network. This is because there are constraints that exist

on the path of the traveling salesman problem that do not exist when optimizing the weight

matrix of the neural network.

The biggest difference is that the traveling salesman cannot visit the same city more than onceduring his trip. The randomization of the path must be controlled enough that it does not cause

the traveling salesman to visit the same city more than once. By the same token, the traveling

salesman must visit each city once. No cities can be skipped. The randomization algorithm must

also be careful that it does not cause any cities to be dropped from the list.

You can think of the traveling salesman randomization as simply moving elements of a fixed

sized list. This fixed size list is the path that the traveling salesman must follow. Because thetraveling salesman can neither skip nor revisit cities, the path of the traveling salesman will

always have the same number of "stops" as there are cities.

Because of the constraints imposed by the traveling salesman problem, most randomization

methods used with the traveling salesman problem work simply by jumbling the order of the

previous path through the cities. By simply jumbling the data, and not modifying original values,we can be assured that the final result of this jumbling will neither skip, nor revisit, cities.

This is the method that is used to randomize traveling salesman's path in this chapter. Using acombination of the temperature and distance between two cities, the simulated annealing

algorithm determines if the positions of these two cities should be changed. You will see the

actual Java implementation of this method later in this chapter.

The final portion of the simulated annealing algorithm that we will explore in this section is

temperature reduction. Temperature reduction will be discussed in the next section.

Temperature Reduction

There are several different methods that can be used for temperature reduction. In this chapter we

will examine two methods. The most common is to simply reduce the temperature by a fixed

amount through each cycle. This is the method that is used in this chapter for the traveling

salesman problem example.

Another method is to specify a beginning and ending temperature. This is the method that will beused by the simulated annealing algorithm that is shown in Chapter 10. To do this we mustcalculate a ratio at each step in the simulated annealing process. This is done by using an

equation that guarantees that the step amount will cause the temperature to fall to the ending

temperature in the number of cycles requested. The following equation shows how to

logarithmically decrease the temperature between a beginning and ending temperature.

8/2/2019 ga data (2)

4/21

double ratio =

Math.exp(Math.log(stopTemperature/startTemperature)/(cycles-1));

The above line calculates a ratio that should be multiplied against the current temperature. Thiswill produce a change that will cause the temperature to reach the ending temperature in the

specified number of cycles. This method is used in Chapter 10 when simulated annealing is

applied to neural network training.

Introduction to Neural Networks with Java

Chapter 1: Introduction to Neural Networks Chapter 2: Understanding Neural Networks Chapter 3: Using Multilayer Neural Networks Chapter 4: How a Machine Learns Chapter 5: Understanding Back Propagation Chapter 6: Understanding the Kohonen Neural Network Chapter 7: OCR with the Kohonen Neural Network Chapter 8: Understanding Genetic Algorithms Chapter 9: Understanding Simulated Annealing

o Introductiono Simulated Annealing Backgroundo Understanding Simulated Annealingo Implementing Simulated Annealingo Summary

Chapter 10: Eluding Local Minima

Appendix A. JOONE Reference Appendix B. Mathematical Background Appendix C. Compiling Examples under Windows Appendix D. Compiling Examples under Linux/UNIX

What version of Java do you use?Choices

1.7

1.6

1.5

Older polls Results

New forum topics
http://www.heatonresearch.com/articles/series/1http://www.heatonresearch.com/articles/series/1http://www.heatonresearch.com/articles/1http://www.heatonresearch.com/articles/1http://www.heatonresearch.com/articles/2http://www.heatonresearch.com/articles/2http://www.heatonresearch.com/articles/3http://www.heatonresearch.com/articles/3http://www.heatonresearch.com/articles/4http://www.heatonresearch.com/articles/4http://www.heatonresearch.com/articles/5http://www.heatonresearch.com/articles/5http://www.heatonresearch.com/articles/6http://www.heatonresearch.com/articles/6http://www.heatonresearch.com/articles/7http://www.heatonresearch.com/articles/7http://www.heatonresearch.com/articles/8http://www.heatonresearch.com/articles/8http://www.heatonresearch.com/articles/9http://www.heatonresearch.com/articles/9http://www.heatonresearch.com/articles/9/page1.htmlhttp://www.heatonresearch.com/articles/9/page1.htmlhttp://www.heatonresearch.com/articles/9/page2.htmlhttp://www.heatonresearch.com/articles/9/page2.htmlhttp://www.heatonresearch.com/articles/9/page3.htmlhttp://www.heatonresearch.com/articles/9/page3.htmlhttp://www.heatonresearch.com/articles/9/page4.htmlhttp://www.heatonresearch.com/articles/9/page4.htmlhttp://www.heatonresearch.com/articles/9/page5.htmlhttp://www.heatonresearch.com/articles/9/page5.htmlhttp://www.heatonresearch.com/articles/10http://www.heatonresearch.com/articles/10http://www.heatonresearch.com/articles/13http://www.heatonresearch.com/articles/13http://www.heatonresearch.com/articles/14http://www.heatonresearch.com/articles/14http://www.heatonresearch.com/articles/15http://www.heatonresearch.com/articles/15http://www.heatonresearch.com/articles/16http://www.heatonresearch.com/articles/16http://www.heatonresearch.com/pollhttp://www.heatonresearch.com/pollhttp://www.heatonresearch.com/node/2559/resultshttp://www.heatonresearch.com/node/2559/resultshttp://www.heatonresearch.com/node/2559/resultshttp://www.heatonresearch.com/pollhttp://www.heatonresearch.com/articles/16http://www.heatonresearch.com/articles/15http://www.heatonresearch.com/articles/14http://www.heatonresearch.com/articles/13http://www.heatonresearch.com/articles/10http://www.heatonresearch.com/articles/9/page5.htmlhttp://www.heatonresearch.com/articles/9/page4.htmlhttp://www.heatonresearch.com/articles/9/page3.htmlhttp://www.heatonresearch.com/articles/9/page2.htmlhttp://www.heatonresearch.com/articles/9/page1.htmlhttp://www.heatonresearch.com/articles/9http://www.heatonresearch.com/articles/8http://www.heatonresearch.com/articles/7http://www.heatonresearch.com/articles/6http://www.heatonresearch.com/articles/5http://www.heatonresearch.com/articles/4http://www.heatonresearch.com/articles/3http://www.heatonresearch.com/articles/2http://www.heatonresearch.com/articles/1http://www.heatonresearch.com/articles/series/1

8/2/2019 ga data (2)

5/21

stock returns Encog Uml-ed Credit Card Data do you consider pull requests on this project? Upgrade to Drupal 7

User accounts and posts for last 24 hours Bug? Encog 3.1.0 Encog.ML.Data.Buffer.BufferedMLDataSet.EndLoad() NEAT in Unsupervised Application Implementing a Neural Network in Java: Training and Backpropagation issues use backpropagation

More

Copyright 2012 by Heaton Research, Inc.

Outline of the Algorithm

Stopping Conditions for the Algorithm

Bibliography

Outline of the Algorithm

The simulated annealing algorithm performs the following steps:

1. The algorithm generates a random trial point. The algorithm chooses the distance of thetrial point from the current point by a probability distribution with a scale depending onthe current temperature. You set the trial point distance distribution as a function with the

AnnealingFcn option. Choices:

@annealingfast (default)Step length equals the current temperature, anddirection is uniformly random.

@annealingboltzStep length equals the square root of temperature, anddirection is uniformly random.

@myfunCustom annealing algorithm, myfun. For custom annealing functionsyntax, seeAlgorithm Settings.

2. The algorithm determines whether the new point is better or worse than the current point.If the new point is better than the current point, it becomes the next point. If the new

point is worse than the current point, the algorithm can still make it the next point. Thealgorithm accepts a worse point based on an acceptance function. Choose the acceptance

function with the AcceptanceFcn option. Choices:

@acceptancesa (default)Simulated annealing acceptance function. Theprobability of acceptance is
http://www.heatonresearch.com/node/2558http://www.heatonresearch.com/node/2558http://www.heatonresearch.com/node/2556http://www.heatonresearch.com/node/2556http://www.heatonresearch.com/node/2555http://www.heatonresearch.com/node/2555http://www.heatonresearch.com/node/2554http://www.heatonresearch.com/node/2554http://www.heatonresearch.com/node/2553http://www.heatonresearch.com/node/2553http://www.heatonresearch.com/node/2552http://www.heatonresearch.com/node/2552http://www.heatonresearch.com/node/2548http://www.heatonresearch.com/node/2548http://www.heatonresearch.com/node/2547http://www.heatonresearch.com/node/2547http://www.heatonresearch.com/node/2545http://www.heatonresearch.com/node/2545http://www.heatonresearch.com/node/2544http://www.heatonresearch.com/node/2544http://www.heatonresearch.com/forumhttp://www.heatonresearch.com/forumhttp://www.heatonresearch.com/copyrighthttp://www.heatonresearch.com/copyrighthttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq3a9do-1http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq3a9do-1http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqin_http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqin_http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqin_http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq3a9do-1http://www.heatonresearch.com/copyrighthttp://www.heatonresearch.com/forumhttp://www.heatonresearch.com/node/2544http://www.heatonresearch.com/node/2545http://www.heatonresearch.com/node/2547http://www.heatonresearch.com/node/2548http://www.heatonresearch.com/node/2552http://www.heatonresearch.com/node/2553http://www.heatonresearch.com/node/2554http://www.heatonresearch.com/node/2555http://www.heatonresearch.com/node/2556http://www.heatonresearch.com/node/2558

8/2/2019 ga data (2)

6/21

where

= new objective old objective.

T0 = initial temperature of component i

T= the current temperature.

Since both and Tare positive, the probability of acceptance is between 0 and

1/2. Smaller temperature leads to smaller acceptance probability. Also, larger leads to smaller acceptance probability.

@myfunCustom acceptance function, myfun. For custom acceptance functionsyntax, seeAlgorithm Settings.

3. The algorithm systematically lowers the temperature, storing the best point found so far.The TemperatureFcn option specifies the function the algorithm uses to update thetemperature. Let kdenote the annealing parameter. (The annealing parameter is the same

as the iteration number until reannealing.) Options:

@temperatureexp (default)T= T0 * 0.95^k. @temperaturefastT= T0 /k. @temperatureboltzT= T0 / log(k). @myfunCustom temperature function, myfun. For custom temperature function

syntax, seeTemperature Options.

4. simulannealbnd reanneals after it accepts ReannealInterval points. Reannealing setsthe annealing parameters to lower values than the iteration number, thus raising the

temperature in each dimension. The annealing parameters depend on the values ofestimated gradients of the objective function in each dimension. The basic formula is

where

ki = annealing parameter for component i.

T0 = initial temperature of component i.

Ti = current temperature of component i.si = gradient of objective in direction i times difference of bounds in direction i.

simulannealbnd safeguards the annealing parameter values against Inf and otherimproper values.
http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26ky_-1http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26ky_-1http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26ky_-1http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26ky_-1http://www.mathworks.in/help/toolbox/gads/bq26j8s-1.html#bq26j8s-4

8/2/2019 ga data (2)

7/21

5. The algorithm stops when the average change in the objective function is small relative tothe TolFun tolerance, or when it reaches any other stopping criterion. SeeStoppingConditions for the Algorithm.

For more information on the algorithm, see Ingber[1].

Back to Top

Stopping Conditions for the Algorithm

The simulated annealing algorithm uses the following conditions to determine when to stop:

TolFunThe algorithm runs until the average change in value of the objective functionin StallIterLim iterations is less than the value ofTolFun. The default value is 1e-6.

MaxIterThe algorithm stops when the number of iterations exceeds this maximumnumber of iterations. You can specify the maximum number of iterations as a positive

integer or Inf. The default value is Inf. MaxFunEval specifies the maximum number of evaluations of the objective function. The

algorithm stops if the number of function evaluations exceeds the value ofMaxFunEval.

The default value is 3000*numberofvariables.

TimeLimit specifies the maximum time in seconds the algorithm runs before stopping.The default value is Inf.

ObjectiveLimitThe algorithm stops when the best objective function value is lessthan or equal to the value ofObjectiveLimit. The default value is -Inf.

Understanding Simulated Annealing

Terminology

Using Simulated Annealing from the Command

Line

Simulated Annealing and Testing

James McCaffrey

In this months column I present C# code that implements a SimulatedAnnealing (SA) algorithm to solve a scheduling problem. An SA algorithm is an artificial
http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqio8http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqio8http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqio8http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#top_of_pagehttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#top_of_pagehttp://www.mathworks.in/help/toolbox/gads/bq2g25b-36.htmlhttp://msdn.microsoft.com/en-us/magazine/ee532098.aspx?sdmr=JamesMcCaffrey&sdmi=authorshttp://msdn.microsoft.com/en-us/magazine/ee532098.aspx?sdmr=JamesMcCaffrey&sdmi=authorshttp://www.mathworks.in/help/toolbox/gads/bq2g25b-36.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-8.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g25b-36.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-8.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g25b-36.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-8.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g25b-36.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-8.htmlhttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.htmlhttp://msdn.microsoft.com/en-us/magazine/ee532098.aspx?sdmr=JamesMcCaffrey&sdmi=authorshttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#top_of_pagehttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#top_of_pagehttp://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bsiqio8http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25http://www.mathworks.in/help/toolbox/gads/bq2g2yi-15.html#bq2g2yi-25

8/2/2019 ga data (2)

8/21

intelligence technique based on the behavior of cooling metal. It can be used to find solutions to

difficult or impossible combinatorial optimization problems.

The best way to see where Im headed is to take a look at Figure 1 and Figure 2. The table in

Figure 1 describes a scheduling problem: five workers and six tasks. Each entry in the table

represents how long it takes for a worker to complete a task. For example, worker w2 needs 5.5hours to complete task t3. An empty entry in a row indicates that the corresponding worker cant

perform a task. The problem is to assign each of the six tasks to one of the workers in such a waythat the total time to complete all tasks is minimized. Additionally, we assume that every time a

worker switches to a new task, theres a 3.5-hour retooling penalty.

Figure 1 Time for Worker to Complete Task

t0 t1 t2 t3 t4 t5

w07.53.52.5

w1 1.54.53.5

w2 3.55.53.5

w3 6.51.54.5

w42.5 2.52.5

8/2/2019 ga data (2)

9/21

Figure 2 SimulatedAnnealing in Action

Figure 2 shows a program that uses an SA algorithm to find a solution to the scheduling

problem. The program begins by generating a random solution. In SA terminology, a potentialsolution is called the state of the system. The initial state is [4 0 0 2 2 3], which means task 0 has

been assigned to worker 4, task 1 has been assigned to worker 0, task 2 has been assigned to

worker 0, task 3 has been assigned to worker 2, task 4 has been assigned to worker 2 and task 5has been assigned to worker 3. The total time for the initial random state is 2.5 + 3.5 + 2.5 + 5.5

+ 3.5 + 4.5 = 22 hours plus a 3.5-hour retooling penalty for worker 0 and a 3.5-hour penalty for

8/2/2019 ga data (2)

10/21

worker 2, for a total of 29 hours. In SA terminology, the quantity youre trying to minimize (or

less frequently maximize) is called the energy of the state.

The program enters a loop. In each iteration of the loop, the SA algorithm generates an adjacent

state and evaluates that adjacent state to see if its better than the current state. Behind the scenes,

the SA algorithm uses a temperature variable that slowly decreases, as Ill explain shortly. TheSA loop ends when the temperature cools sufficiently close to zero. The program concludes by

displaying the best solution found.

This example is artificially simple because with six tasks where each task can be performed by

one of three workers, there are only 36 possible combinations, which equals 729, so you couldjust evaluate every one. But suppose you had a problem with 20 tasks where each task can be

performed by one of 12 workers. There would be 1220 combinations, which equals a whopping

3,833,759,992,447,475,122,176. Even if you could evaluate 1 million possible solutions per

second, youd need about 121 million years to evaluate every possibility.

SA is a metaheuristicthat is, a general conceptual framework that can be used to create aspecific algorithm to solve a specific problem. Its best used for combinatorial optimizationproblems where theres no practical deterministic solution algorithm. First described in a 1983

paper by S. Kirkpatrick, C. Gelatt and M. Vecchi, SA is loosely based on the annealing behavior

of cooling metal. When some metals are heated to a high temperature, the atoms and moleculesbreak their bonds. When the metal is slowly cooled, the atoms and molecules reform their bonds

in such a way that the energy of the system is minimized.

This column assumes you have intermediate-level programming skills. I implement the SA

program using C#, but you shouldnt have too much trouble refactoring my code to a different

language such as Visual Basic or Python. In the sections that follow, Ill walk you through the

program that generated Figure 2. All of the code is available as a download fromarchive.msdn.microsoft.com/mag201201TestRun . I think youll find the ability to understand

and use SA an interesting and possibly useful addition to your personal skill set.

Program Structure

I implemented the SA demo program as a single C# console application. The overall structure ofthe program is shown in Figure 3.

Figure 3 SimulatedAnnealing Program Structure

1. using System;2. namespace SimulatedAnnealing3. {4. class SimulatedAnnealingProgram5. {6. static Random random;7. static void Main(string[] args)8. {9. try10. {
http://archive.msdn.microsoft.com/mag201201TestRunhttp://archive.msdn.microsoft.com/mag201201TestRunhttp://archive.msdn.microsoft.com/mag201201TestRun

8/2/2019 ga data (2)

11/21

11. // Set up problem data.12. // Create random state.13. // Set up SA variables for temperature and cooling rate.14. while (iteration < maxIteration && currTemp > 0.0001)15. {16. // Create adjacent state.17. // Compute energy of adjacent state.18. // Check if adjacent state is new best.19. // If adjacent state better, accept state with varying proba

bility.

20. // Decrease temperature and increase iteration counter.21. }22. // Display best state found.23. }24. catch (Exception ex)25. {26. Console.WriteLine(ex.Message);27. Console.ReadLine();28. }29. } // Main30. static double[][] MakeProblemData(int numWorkers, int numTasks) {... }31. static int[] RandomState(double[][] problemData) { ... }32. static int[] AdjacentState(int[] currState,33. double[][] problemData) { ... }34. static double Energy(int[] state, double[][] problemData) { ... }35. static double AcceptanceProb(double energy, double adjEnergy,36. double currTemp) { ... }37. static void Display(double[][] matrix) { ... }38. static void Display(int[] vector) { ... }39. static void Interpret(int[] state, double[][] problemData) { ... }40. } // Program41. } // ns

I used Visual Studio to create a console application program named SimulatedAnnealing. In the

Solution Explorer window, I renamed the default Program.cs file to

SimulatedAnnealingProgram.cs, which automatically renamed the single class in the project. I

deleted all the template-generated using statements except for the System namespaceSA is

quite simple and typically doesnt need much library support. I declared a class-scope Random

object named random. SA algorithms are probabilistic, as youll see shortly.

The heart of the SA algorithm processing is a while loop. The loop is controlled by a loopcounter variable named iteration and by a variable that represents the temperature of the

system. In practice, the temperature variable almost always reaches near-zero and terminates the

loop before the loop counter reaches its maximum value and terminates the loop.

SA algorithms must have three problem-specific methods as suggested in Figure3. The SAalgorithm must have a method that generates an initial (usually random) state/solution. The SA

algorithm must have a method that generates an adjacent state relative to a given state. And the

SA algorithm must have a method that computes the energy/cost of a statethe value youretrying to minimize or maximize. In Figure 3 these are methods RandomState, AdjacentState and

Energy, respectively. Method AcceptanceProb generates a value used to determine if the current

8/2/2019 ga data (2)

12/21

state of the system transitions to the adjacent state even when the adjacent state is worse than the

current state. Method MakeProblemData is a helper and creates a data structure matrix thatcorresponds with Figure 1. The overloaded Display methods and the Interpret method are just

helpers to display information.

Program Initialization

The Main method begins like so:

1. try2. {3. Console.WriteLine("\nBegin Simulated Annealing demo\n");4. Console.WriteLine("Worker 0 can do Task 0 (7.5) Task 1 (3.5) Task 2 (

2.5)");

5. Console.WriteLine("Worker 1 can do Task 1 (1.5) Task 2 (4.5) Task 3 (3.5)");




9. ...I wrap all SA code in a single, high-level try-catch block and display the dummy problem that I

intend to set up. Here, Im using an artificially simple examplebut one thats representative ofthe kinds of combinatorial problems that are suited for a solution by SA algorithms. Next comes:

1. random = new Random(0);2. int numWorkers = 5;3. int numTasks = 6;4. double[][] problemData = MakeProblemData(numWorkers, numTasks);

I initialize the Random object using an arbitrary seed value of 0. Then I call helper method

MakeProblemData to construct the data structure shown in Figure 1. Ill present

MakeProblemData and the other helper methods after I finish presenting all the code in the Mainmethod. Next comes:

1. int[] state = RandomState(problemData);2. double energy = Energy(state, problemData);3. int[] bestState = state;4. double bestEnergy = energy;5. int[] adjState;6. double adjEnergy;

I call helper method RandomState to generate a random state/solution for the problem. State is

represented as an int array where the array index represents a task and the value in the array atthe index represents the worker assigned to the task. Helper method Energy computes the total

time required by its state parameter, taking into account the 3.5-hour penalty for retooling every

time a worker does an additional task. Ill track the best state found and its corresponding energy,

8/2/2019 ga data (2)

13/21

so I declare variables bestState and bestEngery. Variables adjState and adjEnergy are used to

hold a state thats adjacent to the current state, and the corresponding energy. Next comes:

1. int iteration = 0;2. int maxIteration = 1000000;3. double currTemp = 10000.0;4. double alpha = 0.995;

The primary SA processing loop terminates on one of two conditions: when a counter exceeds amaximum value or when the temperature variable decreases to a value close to zero. I name the

loop counter iteration, but I couldve called it counter or time or tick or something

similar. I name the temperature variable currTemp rather than temp so theres less chancesomeone reviewing the code might interpret it as a temporary variable. Variable alpha represents

the cooling rate, or a factor that determines how the temperature variable decreases, or cools,

each time through the processing loop. Next comes:

1. Console.WriteLine("\nInitial state:");2. Display(state);3. Console.WriteLine("Initial energy: " + energy.ToString("F2"));4. Console.WriteLine("\nEntering main Simulated Annealing loop");5. Console.WriteLine("Initial temperature = " + currTemp.ToString("F1") +

"\n");

Before entering the main processing loop, I display some informational messages about the

initial state, energy and temperature. You might want to display additional information such as

the cooling rate. Heres the loop:

1. while (iteration < maxIteration && currTemp > 0.0001)2. {3. adjState = AdjacentState(state, problemData);4. adjEnergy = Energy(adjState, problemData);5. if (adjEnergy < bestEnergy)6. {7. bestState = adjState;8. bestEnergy = adjEnergy;9. Console.WriteLine("New best state found:");10. Display(bestState);11. Console.WriteLine("Energy = " + bestEnergy.ToString("F2") + "\n");12. }13. ...

Notice the loop control exits when the temperature variable drops below 0.0001 rather than whenit hits 0.0. You might want to parameterize that minimum temperature value. After creating an

adjacent state and computing its energy, I check to see if that adjacent state is a new global best

solution, and if so I save that information. I can copy the best state by reference because method

AdjacentState allocates a new array, but I couldve made an explicit copy. Whenever a newglobal best state is found, I display it and its energy. The main processing loop ends like this:

1. double p = random.NextDouble();2. if (AcceptanceProb(energy, adjEnergy, currTemp) > p)3. {

8/2/2019 ga data (2)

14/21

4. state = adjState;5. energy = adjEnergy;6. }7. currTemp = currTemp * alpha;8. ++iteration;9. } // While

The loop finishes up by first generating a random value p greater than or equal to 0.0 and strictly

less than 1.0 and comparing that value against the return from helper method AcceptanceProb. Ifthe acceptance probability exceeds the random value, the current state transitions to the adjacent

state. Next, the current temperature is decreased slightly by multiplying by the cooling factor,

and the loop counter variable is incremented. Next comes:

1. Console.Write("Temperature has cooled to (almost) zero ");2. Console.WriteLine("at iteration " + iteration);3. Console.WriteLine("Simulated Annealing loop complete");4. Console.WriteLine("\nBest state found:");5. Display(bestState);6. Console.WriteLine("Best energy = " + bestEnergy.ToString("F2") + "\n");7. Interpret(bestState, problemData);8. Console.WriteLine("\nEnd Simulated Annealing demo\n");9. Console.ReadLine();

After the main SA processing loop completes, I display the best state (solution) found and its

corresponding energy (hours). The Main method ends like this:

1. ...2. } // Try3. catch (Exception ex)4. {5. Console.WriteLine(ex.Message);6. Console.ReadLine();7. }8. } // Main

The method wraps up by handling any exceptions simply by displaying the exceptions message.

The Helper Methods

The code for helper method MakeProblemData is:

1. static double[][] MakeProblemData(int numWorkers, int numTasks)2. {3. double[][] result = new double[numWorkers][];4. for (int w = 0; w < result.Length; ++w)5. result[w] = new double[numTasks];6. result[0][0] = 7.5; result[0][1] = 3.5; result[0][2] = 2.5;7. result[1][1] = 1.5; result[1][2] = 4.5; result[1][3] = 3.5;8. result[2][2] = 3.5; result[2][3] = 5.5; result[2][4] = 3.5;9. result[3][3] = 6.5; result[3][4] = 1.5; result[3][5] = 4.5;10. result[4][0] = 2.5; result[4][4] = 2.5; result[4][5] = 2.5;11. return result;

8/2/2019 ga data (2)

15/21

12. }I decided to use type double[][]that is, an array of arraysto hold my scheduling problemdefinition. The C# language, unlike many C-family languages, does support a built-in two-

dimensional array, so I couldve used type double[,] but an array of arrays is easier to refactor if

you want to recode my example to a language that doesnt support two-dimensional arrays. Inthis example I arbitrarily put the worker index first and the task index second (so result[1][3] is

the time required by worker 1 to perform task 3), but I couldve reversed the order. Notice that

C# automatically initializes type double array cells to 0.0, so I dont have to explicitly do so. I

couldve used some other value, such as -1.0 to indicate that a worker cant perform a particulartask.

Helper method RandomState is:

1. static int[] RandomState(double[][] problemData)2. {3. int numWorkers = problemData.Length;4. int numTasks = problemData[0].Length;5. int[] state = new int[numTasks];6. for (int t = 0; t < numTasks; ++t) {7. int w = random.Next(0, numWorkers);8. while (problemData[w][t] == 0.0) {9. ++w; if (w > numWorkers - 1) w = 0;10. }11. state[t] = w;12. }13. return state;14. }

Recall that a state represents a solution and that a state is an int array where the index is the task

and the value is the worker. For each cell in state, I generate a random worker w. But that workermight not be able to perform the task, so I check to see if the corresponding value in the problem

data matrix is 0.0 (meaning the worker cant do the task), and if so I try the next worker, beingcareful to wrap back to worker 0 if I exceed the index of the last worker.

Helper method AdjacentState is:

1. static int[] AdjacentState(int[] currState, double[][] problemData)2. {3. int numWorkers = problemData.Length;4. int numTasks = problemData[0].Length;5. int[] state = new int[numTasks];6. int task = random.Next(0, numTasks);7. int worker = random.Next(0, numWorkers);8. while (problemData[worker][task] == 0.0) {9. ++worker; if (worker > numWorkers - 1) worker = 0;10. }11. currState.CopyTo(state, 0);12. state[task] = worker;13. return state;14. }

8/2/2019 ga data (2)

16/21

Method AdjacentState starts with a given state, then selects a random task and then selects a

random worker who can do that task. Note that this is a pretty crude approach; it doesnt check tosee if the randomly generated new worker is the same as the current worker, so the return state

might be the same as the current state. Depending on the nature of the problem being targeted by

an SA algorithm, you might want to insert code logic that ensures an adjacent state is different

from the current state.

The Energy method is shown in Figure 4.

Figure 4 The Energy Method

1. static double Energy(int[] state, double[][] problemData)2. {3. double result = 0.0;4. for (int t = 0; t < state.Length; ++t) {5. int worker = state[t];6. double time = problemData[worker][t];7. result += time;8. }9. int numWorkers = problemData.Length;10. int[] numJobs = new int[numWorkers];11. for (int t = 0; t < state.Length; ++t) {12. int worker = state[t];13. ++numJobs[worker];14. if (numJobs[worker] > 1) result += 3.50;15. }16. return result;17. }

The Energy method first walks through each task in the state array, grabs the assigned worker

value, looks up the time required in the problem data matrix, and accumulates the result. Next,

the method counts the number of times a worker does more than one task and adds a 3.5-hourretooling penalty for every additional task. In this example, computing the energy of a state is

quick; however, in most realistic SA algorithms, the Energy method dominates the running time,

so youll want to make sure the method is as efficient as possible.

Helper method AcceptanceProb is:

1. static double AcceptanceProb(double energy, double adjEnergy,2. double currTemp)3. {4. if (adjEnergy < energy)5.

return 1.0;6. else

7. return Math.Exp((energy - adjEnergy) / currTemp);8. }

If the energy of the adjacent state is less than (or more than, in the case of a maximization

problem) the energy of the current state, the method returns 1.0, so the current state will always

transition to the new, better adjacent state. But if the energy of the adjacent state is the same as or

worse than the current state, the method returns a value less than 1.0, which depends on the

8/2/2019 ga data (2)

17/21

current temperature. For high values of temperature early in the algorithm, the return value is

close to 1.0, so the current state will often transition to the new, worse adjacent state. But as thetemperature cools, the return value from AcceptanceProb becomes smaller and smaller, so

theres less chance of transitioning to a worse state.

The idea here is that you sometimesespecially early in the algorithmwant to go to a worsestate so you dont converge on a non-optimal local solution. By sometimes going to a worse

state, you can escape non-optimal dead-end states. Notice that because the function performs

arithmetic division by the value of the current temperature, the temperature cant be allowed toreach 0. The acceptance function used here is the most common function and is based on some

underlying math assumptions, but theres no reason you cant use other acceptance functions.

The Display and Interpret Helper methods are extremely simple, as shown in Figure 5.

Figure 5 The Display and Interpret Helper Methods

1. static void Display(double[][] matrix)2. {3. for (int i = 0; i < matrix.Length; ++i) {4. for (int j = 0; j < matrix[i].Length; ++j)5. Console.Write(matrix[i][j].ToString("F2") + " ");6. Console.WriteLine("");7. }8. }9. static void Display(int[] vector)10. {11. for (int i = 0; i < vector.Length; ++i)12. Console.Write(vector[i] + " ");13. Console.WriteLine("");14. }15. static void Interpret(int[] state, double[][] problemData)16. {17. for (int t = 0; t < state.Length; ++t) { // task18. int w = state[t]; // worker19. Console.Write("Task [" + t + "] assigned to worker ");20. Console.WriteLine(w + ", " + problemData[w][t].ToString("F2"));21. }22. }

Some Weaknesses

SA algorithms are simple to implement and can be powerful tools, but they do have weaknesses.

Because these algorithms are most often used in situations where theres no good deterministicsolving algorithm, in general you wont know when, or even if, you hit an optimal solution. For

example, in Figure 1, the best solution found had an energy of 20.5 hours, but by running the

algorithm a bit longer you can find a state that has energy of 19.5 hours. So, when using SAs,you must be willing to accept a good but not necessarily optimal solution. A related weakness

with SA algorithms and other algorithms based on the behavior of natural systems is that they

require the specification of free parameters such as the initial temperature and the cooling rate.

8/2/2019 ga data (2)

18/21

The effectiveness and performance of these algorithms, including SAs, are often quite sensitive

to the values you select for the free parameters.

SA algorithms are closely related to Simulated Bee Colony (SBC) algorithms, which I described

in the April 2011 issue (msdn.microsoft.com/magazine/gg983491). Both techniques are well

suited for solving combinatorial, non-numeric optimization problems. In general, SAs are fasterthan SBCs, but SBCs tend to produce better solutions at the expense of performance.

The use of artificial intelligence techniques in software testing is an area thats almost entirely

unexplored. One example where SAs might be used in software testing is as algorithm

validation. Suppose you have some combinatorial problem that can in fact be solved using adeterministic algorithm. One example is the graph shortest-path problem, which can be solved by

several efficient but relatively complicated algorithms such as Dijkstras algorithm. If youve

coded a shortest-path algorithm, you could test it by quickly coding up a simple SA algorithm

and comparing results. If the SA result is better than the deterministic algorithm, you know youhave a bug in your deterministic algorithm.

You are here

HomeIntroduction to Neural Networks for Java, Second EditionChapter 7: Understanding Simulated

Annealing

Understanding Simulated Annealing

published byjeffheatonon Sun, 09/14/2008 - 19:31

The previous sections discussed the background of the simulated annealing algorithm and

presented various applications for which it is used. In this section, you will be shown how to

implement the simulated annealing algorithm. We will first examine the algorithm and then wewill develop a simulated annealing algorithm class that can be used to solve the traveling

salesman problem, which was introduced in chapter 6.

The Structure of a Simulated Annealing Algorithm

There are several distinct steps that the simulated annealing process must go through as the

temperature is reduced and randomness is applied to the input values. Figure 7.1 presents aflowchart of this process.

Figure 7.1: Overview of the simulated annealing process.
http://msdn.microsoft.com/magazine/gg983491http://msdn.microsoft.com/magazine/gg983491http://msdn.microsoft.com/magazine/gg983491http://www.heatonresearch.com/http://www.heatonresearch.com/http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/users/jeffheatonhttp://www.heatonresearch.com/users/jeffheatonhttp://www.heatonresearch.com/users/jeffheatonhttp://www.heatonresearch.com/users/jeffheatonhttp://www.heatonresearch.com/users/jeffheatonhttp://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2/chapter-7http://www.heatonresearch.com/online/introduction-neural-networks-java-edition-2http://www.heatonresearch.com/http://msdn.microsoft.com/magazine/gg983491

8/2/2019 ga data (2)

19/21

8/2/2019 ga data (2)

20/21

As you can see in Figure 7.1, there are two major processes that take place in the simulated

annealing algorithm. First, for each temperature, the simulated annealing algorithm runs througha number of cycles. The number of cycles is predetermined by the programmer. As a cycle runs,

the inputs are randomized. In the case of the traveling salesman problem, these inputs are the

order of the cities that the traveling salesman will visit. Only randomizations which produce a

better-suited set of inputs will be retained.

Once the specified number of training cycles have been completed, the temperature can belowered. Once the temperature is lowered, it is determined whether or not the temperature has

reached the lowest temperature allowed. If the temperature is not lower than the lowest

temperature allowed, then the temperature is lowered and another cycle of randomizations willtake place. If the temperature is lower than the lowest temperature allowed, the simulated

annealing algorithm terminates.

At the core of the simulated annealing algorithm is the randomization of the input values. Thisrandomization is ultimately what causes simulated annealing to alter the input values that the

algorithm is seeking to minimize. The randomization process must often be customized fordifferent problems. In this chapter we will discuss randomization methods that can be used forboth the traveling salesman problem and neural network training. In the next section, we will

examine how this randomization occurs.

How Are the Inputs Randomized?

An important part of the simulated annealing process is how the inputs are randomized. Therandomization process takes the previous input values and the current temperature as inputs. The

input values are then randomized according to the temperature. A higher temperature will result

in more randomization; a lower temperature will result in less randomization.

There is no specific method defined by the simulated annealing algorithm for how to

randomize the inputs. The exact nature by which this is done often depends upon the nature of

the problem being solved. When comparing the methods used in the simulated annealingexamples for the neural network weight optimization and the traveling salesman problem, we can

see some of the differences.

Simulated Annealing and Neural Networks

The method used to randomize the weights of a neural network is somewhat simpler than the

traveling salesmans simulated annealing algorithm, which we will discuss next. A neural

networks weight matrix can be thought of as a linear array of floating point numbers. Eachweight is independent of the others. It does not matter if two weights contain the same value. The

only major constraint is that there are ranges that all weights must fall within.

Thus, the process generally used to randomize the weight matrix of a neural network is

relatively simple. Using the temperature, a random ratio is applied to all of the weights in thematrix. This ratio is calculated using the temperature and a random number. The higher the

temperature, the more likely it is that the ratio will cause a larger change in the weight matrix. A

8/2/2019 ga data (2)

21/21

lower temperature will most likely produce a smaller change. This is the method that is used for

the simulated annealing algorithm that will be presented later in this chapter.

ga data (2)

Documents

Transcript of ga data (2)