**Simulated annealing**(SA) is a generic probabilistic meta-algorithm for the global optimization problem, namely locating a good approximation to the global optimum of a given function in a large search space. It is often used when the search space is discrete (e.g., all tours that visit a given set of cities). In favorable cases, simulated annealing may be more effective than exhaustive enumeration of the search space.

The name and inspiration come from annealing in metallurgy, a technique involving heating and controlled cooling of a material to increase the size of its crystals and reduce their defects. The heat causes the atoms to become unstuck from their initial positions (a local minimum of the internal energy) and wander randomly through states of higher energy; the slow cooling gives them more chances of finding configurations with lower internal energy than the initial one.

By analogy with this physical process, each step of the SA algorithm replaces the current solution by a random "nearby" solution, chosen with a probability that depends on the difference between the corresponding function values and on a global parameter

*T*(called the

*temperature*), that is gradually decreased during the process. The dependency is such that the current solution changes almost randomly when

*T*is large, but increasingly "downhill" as

*T*goes to zero. The allowance for "uphill" moves saves the method from becoming stuck at local minima—which are the bane of greedier methods.

The method was independently described by S. Kirkpatrick, C. D. Gelatt and M. P. Vecchi in 1983, and by V. Černý in 1985. The method is an adaptation of the Metropolis-Hastings algorithm, a Monte Carlo method to generate sample states of a thermodynamic system, invented by N. Metropolis et al in 1953.

**Overview**

At each step, the SA heuristic considers some neighbour

*s'*of the current state

*s*, and probabilistically decides between moving the system to state

*s'*or staying put in state

*s*. The probabilities are chosen so that the system ultimately tends to move to states of lower energy. Typically this step is repeated until the system reaches a state that is good enough for the application, or until a given computation budget has been exhausted.

**The basic iteration**

The neighbours of each state (the

*candidate moves*) are specified by the user, usually in an application-specific way. For example, in the traveling salesman problem, each state is typically defined as a particular

*tour*(a permutation of the cities to be visited); and one could define the neighbours of a tour as those tours that can be obtained from it by exchanging any pair of consecutive cities.

**The neighbours of a state**

The probability of making the transition from the current state

*s*to a candidate new state

*s*' is specified by an

*acceptance probability function*

*P*(

*e*,

*e*',

*T*), that depends on the energies

*e*=

*E*(

*s*) and

*e*' =

*E*(

*s*') of the two states, and on a global time-varying parameter

*T*called the

*temperature*.

One essential requirement for the probability function

*P*is that it must be nonzero when

*e*' >

*e*, meaning that the system may move to the new state even when it is

*worse*(has a higher energy) than the current one. It is this feature that prevents the method from becoming stuck in a

*local minimum*—a state that is worse than the global minimum, yet better than any of its neighbors.

On the other hand, when

*T*goes to zero, the probability

*P*(

*e*,

*e*',

*T*) must tend to zero if

*e*' >

*e*, and to a positive value if

*e*' <

*e*. That way, for sufficiently small values of

*T*, the system will increasingly favor moves that go "downhill" (to lower energy values), and avoid those that go "uphill". In particular, when

*T*becomes 0, the procedure will reduce to the greedy algorithm—which makes the move only if it goes downhill.

In the original description of SA, the probability

*P*(

*e*,

*e*',

*T*) was defined as 1 when

*e*' <

*e*— i.e., the procedure always moved downhill when it found a way to do so, irrespective of the temperature. Many descriptions and implementations of SA still take this condition as part of the method's definition. However, this condition is not essential for the method to work, and one may argue that it is both counterproductive and contrary to its spirit.

The

*P*function is usually chosen so that the probability of accepting a move decreases when the difference

*e*' −

*e*increases—that is, small uphill moves are more likely than large ones. However, this requirement is not strictly necessary, provided that the above requirements are met.

Given these properties, the evolution of the state

*s*depends crucially on the temperature

*T*. Roughly speaking, the evolution of

*s*is sensitive to coarser energy variations when

*T*is large, and to finer variations when

*T*is small.

**Acceptance probabilities**

Another essential feature of the SA method is that the temperature is gradually reduced as the simulation proceeds. Initially,

*T*is set to a high value (or infinity), and it is decreased at each step according to some

*annealing schedule*—which may be specified by the user, but must end with

*T*= 0 towards the end of the allotted time budget. In this way, the system is expected to wander initially towards a broad region of the search space containing good solutions, ignoring small features of the energy function; then drift towards low-energy regions that become narrower and narrower; and finally move downhill according to the steepest descent heuristic.

**The annealing schedule**

It can be shown that, for any given finite problem, the probability that the simulated annealing algorithm terminates with the global optimal solution approaches 1 as the annealing schedule is extended. This theoretical result is, however, not particularly helpful, since the annealing time required to ensure a significant probability of success will usually exceed the time required for a complete search of the solution space.

**Convergence to the optimum**

The following pseudo-code implements the simulated annealing heuristic, as described above, starting from state

`s0`and continuing to a maximum of

`kmax`steps or until a state with energy

`emax`or less is found. The call

`neighbour(s)`should generate a randomly chosen neighbour of a given state s; the call

`random()`should return a random value in the range [0,1). The annealing schedule is defined by the call

`temp(r)`, which should yield the temperature to use, given the fraction

`r`of the time budget that has been expended so far.

**Pseudo-code**

As in any metaheuristic, one should keep track of the best solution seen so far, in a separate state variable. Namely:

Note that the step

`s := sn`happens only on a small fraction of the moves. Therefore, this variation on the basic method is usually worth the cost, even if state-copying is an expensive operation.

**Saving the best solution seen**

In order to apply the SA method to a specific problem, one must specify the following parameters: the state space, the energy (goal) function

`E()`, the candidate generator procedure

`neighbour()`, the acceptance probability function

`P()`, and the annealing schedule

`temp()`. These choices can have a significant impact on the method's effectiveness. Unfortunately, there are no choices of these parameters that will be good for all problems, and there is no general way to find the best choices for a given problem. Indeed, it has been observed that applying the SA method is more an art than a science. The following sections give some general guidelines.

**Selecting the parameters**

Simulated annealing may be modeled as a random walk on a

*search graph*, whose vertices are all possible states, and whose edges are the candidate moves. An essential requirement for the

`neighbour()`function is that it must provide a sufficiently short path on this graph from the initial state to any state which may be the global optimum. (In other words, the diameter of the search graph must be small.) In the traveling salesman example above, for instance, the search space for

*n*= 20 cities has

*n*! = 2432902008176640000 (2.5 quintillion) states; yet the neighbor generator function that swaps two consecutive cities can get from any state (tour) to any other state in

*n*(

*n*− 1) / 2 = 190 steps.

**Diameter of the search graph**

For each edge (

*s*,

*s*') of the search graph, one defines a

*transition probability*, which is the probability that the SA algorithm will move to state

*s*' when its current state is

*s*. This probability obviously depends on the current temperature, and is determined by the order in which the candidate moves are generated by the

`neighbour()`function, and by the acceptance probability function

`P()`. (Note that the transition probability is

**not**simply

*P*(

*e*,

*e*',

*T*), because the candidates are tested serially).

The transition probabilities and the annealing schedule determine the likelihood that the SA iteration will reach the global optimum within the allotted time. Therefore, the parameters

`neighbour()`,

`P()`, and

`temp`must be tuned together to maximize the chance of this event.

**Acceptance probabilities**

When choosing the candidate generator

`neighbour()`, one must consider that after a few iterations of the SA algorithm, the current state is expected to have much lower energy than a random state. Therefore, as a general rule, one should skew the generator towards candidate moves where the energy of the destination state

*s*' is likely to be similar to that of the current state. This heuristic (which is the main principle of the Metropolis-Hastings algorithm) tends to exclude "very good" candidate moves as well as "very bad" ones; however, the latter are much more common than the former, so the heuristic is generally quite effective.

In the traveling salesman problem above, for example, swapping two

*consecutive*cities in a low-energy tour is expected to have a modest effect on its energy (length); whereas swapping two

*arbitrary*cities is far more likely to increase its length than to decrease it. Thus, the consecutive-swap neighbor generator is expected to perform better than the arbitrary-swap one, even though the latter could provide a somewhat shorter path to the optimum (with

*n*− 1 swaps, instead of

*n*(

*n*− 1) / 2).

A more precise statement of the heuristic is that one should try first candidate states

*s*' for which

*P*(

*E*(

*s*),

*E*(

*s*'),

*T*) is large. For the "standard" acceptance function

*P*above, it means that

*E*(

*s*') −

*E*(

*s*) is on the order of

*T*or less. Thus, in the traveling salesman example above, one could use a

`neighbour()`function that swaps two random cities, where the probability of choosing a city pair vanishes as their distance increases beyond

*T*.

**Efficient candidate generation**

When choosing the candidate generator

`neighbour()`one must also try to reduce the number of "deep" local minima — states (or sets of connected states) that have much lower energy than all its neighboring states. Such "closed catchment basins" of the energy function may trap the SA algorithm with high probability (roughly proportional to the number of states in the basin) and for a very long time (roughly exponential on the energy difference between the surrounding state and the bottom of the basin).

As a rule, it is impossible to design a candidate generator that will satisfy this goal and also prioritize candidates with similar energy. On the other hand, one can often vastly improve the efficiency of SA by relatively simple changes to the generator. In the traveling salesman problem, for instance, it is not hard to exhibit two tours

*A*,

*B*, with nearly equal lengths, such that (0)

*A*is optimal, (1) every sequence of city-pair swaps that converts

*A*to

*B*goes through tours that are much longer than both, and (2)

*A*can be transformed into

*B*by flipping (reversing the order of) a set of consecutive cities. In this example,

*A*and

*B*lie in different "deep basins" if the generator performs only random pair-swaps; but they will be in the same basin if the generator performs random segment-flips.

**Barrier avoidance**

The physical analogy that is used to justify SA assumes that the cooling rate is low enough for the probability distribution of the current state to be near thermodynamic equilibrium at all times. Unfortunately, the

*relaxation time*—the time one must wait for the equilibrium to be restored after a change in temperature—strongly depends on the "topography" of the energy function and on the current temperature. In the SA algorithm, the relaxation time also depends on the candidate generator, in a very complicated way. Note that all these parameters are usually provided as black box functions to the SA algorithm.

Therefore, in practice the ideal cooling rate cannot be determined beforehand, and should be empirically adjusted for each problem. The variant of SA known as thermodynamic simulated annealing tries to avoid this problem by dispensing with the cooling schedule, and instead automatically adjusting the temperature at each step based on the energy difference between the two states, according to the laws of thermodynamics.

**Cooling schedule**

Sometimes it is better to move back to a solution that was significantly better rather than always moving from the current state. This is called

*restarting*. To do this we set

`s`

and `e`

to `sb`

and `eb`

and perhaps restart the annealing schedule. The decision to restart could be based on a fixed number of steps, or based on the current energy being too high from the best energy so far.**Related methods**

Adaptive simulated annealing

Markov chain

Combinatorial optimization

Automatic label placement

Multidisciplinary optimization

Place and route

Traveling salesman problem

Reactive search

Graph cuts in computer vision

## 2 comments:

http://pornfullmf.blogspot.com/

13

Post a Comment