In this post, I will be focusing in local search, which is a very popular technique in searching for an optimal solution based on a series of greedy local moves. The general setting of local search is as follows ...

```
1. Define an objective function
2. Pick an initial starting point
3. Repeat
3.1 Find a neighborhood
3.2 Locate a subset of neighbors that is a candidate move
3.3 Select a candidate from the candidate set
3.4 Move to the candidate
```

One requirement is that the optimal solution need to be reachable by a sequence of moves. Usually this requires a proof that any arbitrary state is reachable by any arbitrary state through a sequence of moves.

Notice that there are many possible strategies for each steps in 3.1, 3.2, 3.3. For example, one strategy can examine all members within the neighborhood, pick the best one (in terms of the objective function) and move to that. Another strategy can randomly pick a member within the neighborhood, and move to the member if it is better than the current state.

Regardless of the strategies, the general theme is to move towards the members which is improving the objective function, hence the greedy nature of this algorithm.

One downside of this algorithm is that it is possible to be trapped in a local optimum, whose is the best candidate within its neighborhood, but not the best candidate from a global sense.

In the following, we'll explore a couple meta-heuristic techniques that can mitigate the local optimum trap.

### Multiple rounds

We basically conduct k rounds of local search, each round getting a local optimum and then pick the best one out of these k local optimum.### Simulated Anealing

This strategy involves a dynamic combination of exploitation (better neighbor) and exploration (random walk to worse neighbor). The algorithm works in the following way ...```
1. Pick an initial starting point
2. Repeat until terminate condition
2.1 Within neighborhood, pick a random member
2.2 If neighbor is better than me
move to the neighbor
else
With chance exp(-(myObj - neighborObj)/Temp)
move to the worse neighbor
2.3 Temp = alpha * Temp
```

### Tabu Search

This strategy maintains a list of previously visited states (called Tabu list) and make sure these states will not be re-visited in subsequent exploration. The search will keep exploring the best move but skipping the previously visited nodes. This way the algorithm will explore the path that hasn't be visited before. The search also remember the best state obtained so far.```
1. Initialization
1.1 Pick an initial starting point S
1.2 Initial an empty Tabu list
1.3 Set the best state to S
1.4 Put S into the Tabu list
2. Repeat until terminate condition
2.1 Find a neighborhood
2.2 Locate a smaller subset that is a candidate move
2.3 Remove elements that is already in Tabu list
2.4 Select the best candidate and move there
2.5 Add the new state to the Tabu list
2.6 If the new state is better that best state
2.6.1 Set the best state to this state
2.7 If the Tabu list is too large
2.7.1 Trim Tabu list by removing old items
```

## No comments:

Post a Comment