Hyperheuristic Approaches

Papers such as (Remde et al., 2007) (Chakhlevitch and Cowling, 2005) generate possible LLHs by considering separately (1) selecting a task to be scheduled and (2) allocating potential resources (including time) for that task. The task selector chooses a task and the resource allocator assigns resources for each skill required by the task, so that the total number of LLHs is the number of task selectors multiplied by the number of resource allocators. In the previous section resource selectors order the resources by their competency at the skill (as more competent resources can complete the task quicker) and then pick a range of these resources (Top 5, Top 10, etc). In addition to

these approaches, here we add more low level heuristics in an attempt to yield better results, by improving the likelihood of there being at least one good LLH in every situation. Table 4.4 describes the new resource allocators. Combining each of the 9 task selector with each of the 27 resource allocators gives a total of 243 Low Level Heuristics. Note that for this problem it is usually better to choose a group of uniformly poor competence resources for a task (so that they complete at about the same time) rather than a heterogeneous set (where fast, effective, resources have to wait for slower resources to finish when they could be completing other tasks).

Table 4.4. New Resource Selectors.

Name Description

Deviation x Resources complete a skill in a time dependent upon their competence. This selector attempts to find resources that will complete the different skills of task in the same amount of time by selecting resources with competencies that deviate x={50%, 25%, 12.5%, 6.25%} from the task’s skill requirement.

x^th Quarter This picks the x={1,2,3,4} quarter of task ranked by skill. Unlike the “Top x”

task selectors, the number chosen is proportionate to the number of resources who can do the task.

x^th Eighth This picks the x={1…8} eighth of task ranked by skill.

Dynamic x This selector picks larger sets of resources for the skills requiring more effort and less to those requiring less effort. It will create x={10, 50, 100, 1000}

combinations when enumerating the resulting sets.

All Resources Considers all possible resources (and hence is very slow).

The hyperheuristic HyperRandom, selects at random a Low Level Heuristic (i.e.

a (task order, resource selector) pair) to use at each iteration and applies it if the application will result in a positive improvement. This continues until no improvement has been found for a certain number of iterations. HyperGreedy evaluates all the Low Level Heuristics at each iteration and applies the best if it makes an improvement. This continues until no improvement is found. As might be expected, HyperGreedy is very

CPU-intensive, and generates good quality results, but is inefficient. For example, over one quarter of the low level heuristics were never applied in experimental trials in the previous section and over half of them were only applied once.

Here we propose a Tabu based hyperheuristic with dynamically adapting Tabu tenures designed for very large neighbourhoods, inspired by the binary exponential back-off algorithm used in networking (Metcalfe and Boggs, 1976). We use an analogous backing off method to exponentially increase the Tabu tenure of low level heuristics which repeatedly yield no improvements, meaning the time between trials of bad heuristics gets exponentially greater. The heuristic is given in Figure 4.13. We use two methods to decide which of the low level heuristics, which were tried, to back off (those “deemed bad”):

1) “Best x”: only the best x improving low level heuristics are not backed off.

2) “Prop x”: all non improving low level heuristics and those improving low level heuristics not in the top x% of the range of the fitness are backed off.

Define:

backoff_min is the minimum backoff value (we choose 4) LLH_i is Low level heuristic i

Tabui is the Tabu value of LLHi (0≤ Tabui≤Backoffi)

backoffi is the backoff value of LLHi (Backoff_min≤ Backoffi) Eligible = {LLHi: Tabui=0}

Δ(S,LLHi) is the change in the objective function which would result from applying low level heuristic LLH_i to solution S.

apply(S,LLHi) is the new solution we get after applying low level heuristic LLHi to solution S.

Initialise:

create an initial solution S (often the solution S is the empty solution).

for all i:

Figure 4.13. The Binary Exponential Back Off (BEBO) hyperheuristic.

4.5.2. Computational Experiments

We compare several hyperheuristic methods (rVNS, HyperGreedy, HyperGreedyMore, HyperRandom, HyperRandomMore, 9 BEBO “Best x”, 7 BEBO

“Prop x”, and 15 “standard” Tabu Hyperheuristics) ten times on five different problem instances and averaged the 50 results. The five problem instances require the scheduling of 400 tasks using 100 resources over one day using five different skills. Tasks require between one and three skills and resources possess between one and five skills. The problems reflect realistic problems Trimble MRM have identified and are generated using the problem generator used in (Cowling et al., 2006). The complexity of dealing with these real-world problem instances means that these experiments require over 155 CPU days to complete, so they were run in parallel on 88 cores of 22 identical 4 core 2.0 GHz Machines. Implementation was in C# .NET under Windows.

rVNS is best rVNS method taken from the previous section. HyperRandom and HyperRandomMore are the random hyperheuristics from the previous section with the latter including the additional low level heuristics introduced in this section.

HyperGreedy and HyperGreedyMore are the greedy hyperheuristics from the previous section with the latter including the additional low level heuristics introduced in this paper. HyperGreedyMore will be the benchmark for all the tests as this is the most CPU-intensive approach and produces the best result.

The BEBO hyperheuristics are described in the above section. We try both of the proposed back-off methods with various sets of parameters. We also compare with a

“standard” Tabu hyperheuristic, setting the Tabu tenure to t=5, 7, 10, 25, 50 each time a low level heuristic is tried and fails to give an improvement. We also investigate different methods of deciding which LLHs to make Tabu. TabuBest y t=x signifies that all but the top y improving low level heuristics will not be made Tabu with tenure x at

each iteration. This is similar to the method used in (Burke, Kendall and Soubeiga, 2003) however we experiment with larger Tabu tenures as we use more low level heuristics. We also investigated making all non improving low level heuristics Tabu however the results for these were very poor in terms of CPU time (as nearly all of the low level heuristics make a positive improvement early in the search even if this improvement is very small) and these results are not reported below. In addition to these fixed tenures, we try random tenures as used in (Kendall and Hussin, 2005): rTabu Best y t=x is similar to Tabu Best y t=x, but with a random tenure between 0 and x each time a low level heuristic is made Tabu.

The results are presented in Table 4.5. We see that the availability of additional LLHs significantly improves the performance of HyperGreedyMore relative to HyperGreedy and HyperRandomMore relative to HyperRandom. The best BEBO method in terms of fitness is BEBO Best 20, which is also one of the slowest since it maintains a relatively large set of Eligible low level heuristics. Even so, the worst performing hyperheuristic BEBO Best 1 got an average fitness of 97.64% of the average fitness of HyperGreedyMore in only 18.52% of the CPU time. Unsurprisingly, the size of the set of heuristics considered bad appears to determine the trade-off between solution quality and time reduction, although the reduction in solution quality is modest given the large reduction in CPU time. In all cases, random Tabu tenures improved Tabu search, further supporting previous work (Rolland, Schilling and Current, 1996).

The fastest “standard” Tabu hyperheuristic rTabu was not as quick as the fastest BEBO method and also resulted in poorer quality solutions. The best rTabu hyperheuristic (in terms of solution quality) took much more CPU time than BEBO methods which gave similar quality.

To see how the time reduction scales with the number of low level heuristics, HyperGreedy and Best 10 experiments were repeated 10 times with randomly chosen subsets of low level heuristics. The results, shown in Figure 4.14, compare BEBO Best 10 with HyperGreedy with different numbers of low level heuristics. We can see that fitness of the two approaches remains very close (none of the results for BEBO Best 10 dropped below 99.3% of the HyperGreedy fitness). As the number of low level heuristics decreases, the time savings for BEBO Best 10 reduce. When 80 or 90% of heuristics have been removed, results are erratic (since the small set of low level heuristics is not guaranteed to be rich enough to yield good results). In this case BEBO Best 10 deals better with the erratic nature and produces better fitness that HyperGreedy on average.

Table 4.5. Fitness and Time of individual instances for new hyperheuristic (average of 50 runs).

HyperRandomMore 20553.8 176.3 82.51% 2.26%

HyperGreedyMore 24911.3 7807.2 100.00% 100.00%

BEBO Best 1 24324.6 1446.1 97.64% 18.52%

Figure 4.14. Graph showing the relative performance of BEBO Best 10 to HyperGreedyMore with different neighborhood sizes.

Figure 4.15. Graph showing the relative performance of each hyperheuristic without resetting compared to the performance of using the same hyperheuristic with resetting.

When the search finds no positive moves in the Eligible set of low level heuristics the Tabu tenures of the low level heuristics are reset and all low level heuristics are tried again. This is potentially a waste of time, if after resetting and trying

0%

20%

40%

60%

80%

100%

120%

10% 20% 30% 40% 50% 60% 70% 80% 90%

Relative Performance of BEBO Best 10

Proportion of Low Level Heuristics Removed

% Time

% Fitness

all the low level heuristics again no improvement is found. To see the impact this has on fitness and CPU time, the methods were tried with and without the reset. Figure 4.15 shows the relative performance of each hyperheuristic without resetting compared to the performance of using the same hyperheuristic with resetting in terms of time and fitness. Here 100% would denote that not resetting was equally as good as resetting – since all values are below 100%, and some are well below 100% these results indicate that resetting is essential, and its effects on the time used are modest.

Figure 4.16. Graph showing the fitness against CPU time of the BEBO Best 20 and HyperGreedyMore heuristics.

Figure 4.16 shows the difference in the evolution of fitness through time for BEBO Best 20 and HyperGreedy More. The curve for BEBO Best 20 stays well ahead of the corresponding curve for HyperGreedy More, until very late in the search process. There is good evidence here of the efficiency savings resulting from exponential back-off, which waste far less function calls to poor LLHs.

Figure 4.17. Graph showing the Tabu Tenure and Backoff of a two different low level heuristics over the iterations of the search.

Figure 4.17 shows how the BEBO Tabu tenures change over the search for two typical low level heuristics with very different properties. The plot shows Backoff_i and Tabui at each iteration of a BEBO Best 20 run for LLH0 and LLH23. LLH0 is used towards the end of the search and as we can see, BEBO is very efficient only trying the low level heuristic about 7 times in the first 150 iterations. Later in the search LLH0

maintains a low back-off value, and produces useful solution improvements. LLH23

performs well at the beginning of the search but after about 96 iteration it no longer serves a useful purpose. Hence Figure 4.17 clearly shows the back off value and the Tabu tenure increasing so that little time is wasted with the low level heuristic later in

the search. These behaviours are typical of the BEBO approach, as is the (less interesting, and very common) behaviour where a consistently poor heuristic is called only rarely right throughout the search.

4.5.3. Analysis

This section investigates the use of Binary Exponential Back-Off (as used in computer and telecommunications networks) to set the Tabu tenure for low level heuristics in a hyperheuristic framework. The approach has been empirically tested on a complex, real-world workforce scheduling problem. The results have shown the potential of the new method to generate good solutions much more quickly than exhaustive (greedy) approaches and standard Tabu approaches. In particular, the benefits of the approach increase with increasing neighbourhood size (i.e. with an increased number of low level heuristics). Binary Exponential Back-Off is able to produce results very close to a highly CPU intensive greedy heuristic which investigates a much larger set of low level heuristics at each iteration, in terms of fitness, and is able to do so in a fraction of the CPU time. BEBO performs much better than “standard” fixed and random Tabu tenure hyperheuristics. Different method for deciding which heuristics to back off were tested, since adjusting the number of low level heuristics backed off determines the trade-off between CPU time used and solution quality. We have shown that modifying the number of low level heuristics backed off may be used to adjust the search and trade off time available against solution quality.

In principle our exponential back-off methods could be used in any Tabu implementation with large neighbourhoods, which provides a promising possible direction for further research.

4.6. Summary

In this chapter, first search based heuristic were used to improve schedules produced by a genetic algorithm. The results showed that solutions generated by the simple construction heuristic in the genetic algorithm were poor and could easily be improved with local search. Various methods were used and the results compared showing local search as a promising technique for the problem.

Then, a hyperheuristic framework was investigated and low level heuristics were created using exact/heuristic hybrids. These low level heuristics worked on a specific part of the problem and solved it exactly. The heuristic part picked a task to be inserted next and the potential resources to do the task. The exact part then enumerated every possible insert using that task and a subset of the potential resources to find the best insertion.

Experimentation was done using over 100 of these low level heuristics. Results showed that using them in a greedy search, though time consuming, produced better results than a reduced Variable Neighbourhood Search method. The reduced Variable Neighbourhood search was the best of many hand crafted heuristics created using selected low level heuristics as neighbourhood functions.

Analysis of the low level heuristic usage in the greed hyperheuristic showed that about a quarter of the low level heuristics were never used and 50% were used less that 1% of the time. This suggests that the greedy hyper heuristic could be sped up by not wasting time trying these poorly performing low level heuristics (if they could be identified).

Binary Exponential Back-off was used as a method to control Tabu tenures in a Tabu hyperheuristic based on the greedy hyperheuristic. The aim was to exponentially decrease the time you spend trying bad heuristics without penalising them if they do

start performing well. Many variations were tried and the results compared to the unmodified greedy hyperheuristic and standard Tabu based hyperheuristics. The results showed that using binary exponential back-off gave the ability to trade of solution quality for CPU time, depending on the parameters used. Even so, the loss in solution quality was extremely small compared to the savings in CPU time. Selected parameters produced results of 97.64% fitness using 18.52% of the CPU time and 100.33% fitness in 40.36% of the CPU time when compared to the greedy hyperheuristic.

Analysis of the back-off of some of the low level heuristics showed that the back-off was working as intended and that low level heuristics which performed well were not backed off and these that performed repeatedly poor were backed of exponentially until they started performing well. These results show Binary Exponential Back-Off to be a very useful method for decreasing CPU time in hyperheuristics and potentially other search based heuristics with large neighbourhoods.

Chapter 5