Adaptive Random Search, ARS, Adaptive Step Size Random Search, ASSRS, Variable Step-Size Random Search.
2.3.1
Taxonomy
The Adaptive Random Search algorithm belongs to the general set of approaches known as Stochastic Optimization and Global Optimization. It is a direct search method in that it does not require derivatives to navigate the search space. Adaptive Random Search is an extension of the Random Search (Section2.2) and Localized Random Search algorithms.
2.3.2
Strategy
The Adaptive Random Search algorithm was designed to address the lim- itations of the fixed step size in the Localized Random Search algorithm. The strategy for Adaptive Random Search is to continually approximate the optimal step size required to reach the global optimum in the search space. This is achieved by trialling and adopting smaller or larger step sizes only if they result in an improvement in the search performance.
The Strategy of the Adaptive Step Size Random Search algorithm (the specific technique reviewed) is to trial a larger step in each iteration and adopt the larger step if it results in an improved result. Very large step sizes are trialled in the same manner although with a much lower frequency. This strategy of preferring large moves is intended to allow the technique to escape local optima. Smaller step sizes are adopted if no improvement is made for an extended period.
2.3.3
Procedure
Algorithm 2.3.1 provides a pseudocode listing of the Adaptive Random Search Algorithm for minimizing a cost function based on the specification for ‘Adaptive Step-Size Random Search’ by Schummer and Steiglitz [6].
2.3.4
Heuristics
Adaptive Random Search was designed for continuous function opti- mization problem domains.
Candidates with equal cost should be considered improvements to allow the algorithm to make progress across plateaus in the response surface.
Adaptive Random Search may adapt the search direction in addition to the step size.
2.3. Adaptive Random Search 35
Algorithm 2.3.1: Pseudocode for Adaptive Random Search. Input: Itermax, P roblemsize, SearchSpace, StepSizeinit
f actor, StepSizesmall
f actor, StepSize large
f actor, StepSizeiterf actor, N oChangemax
Output: S
N oChangecount ← 0; 1
StepSizei ← InitializeStepSize(SearchSpace, StepSizeinit f actor); 2
S ← RandomSolution(P roblemsize, SearchSpace); 3 fori = 0 to Itermax do 4 S1 ← TakeStep(SearchSpace, S, StepSizei); 5 StepSizelargei ← 0; 6 if i modStepSizeiter f actor then 7
StepSizelargei ← StepSizei × StepSizelargef actor; 8
else 9
StepSizelargei ← StepSizei × StepSizesmallf actor; 10
end 11
S2 ← TakeStep(SearchSpace, S, StepSizelargei ); 12
if Cost(S1)≤Cost(S) —— Cost(S2)≤Cost(S) then 13
if Cost(S2)<Cost(S1) then 14
S ← S2; 15
StepSizei ← StepSizelargei ; 16 else 17 S ← S1; 18 end 19 N oChangecount ← 0; 20 else 21 N oChangecount ← N oChangecount + 1; 22
if N oChangecount > N oChangemax then 23 N oChangecount ← 0; 24 StepSizei ← StepSizei StepSizesmall f actor; 25 end 26 end 27 end 28 returnS; 29
The step size may be adapted for all parameters, or for each parameter individually.
2.3.5
Code Listing
Listing2.2provides an example of the Adaptive Random Search Algorithm implemented in the Ruby Programming Language, based on the specification for ‘Adaptive Step-Size Random Search’ by Schummer and Steiglitz [6]. In the example, the algorithm runs for a fixed number of iterations and returns the best candidate solution discovered. The example problem is an instance of a continuous function optimization that seeks min f (x) where f =!ni=1x2i, −5.0 < xi < 5.0 and n = 2. The optimal solution for this basin function is (v0, . . . , vn−1) = 0.0.
1 objective_function(vector)
2 vector.inject(0) {|sum, x| sum + (x ** 2.0)} 3
4
5 rand_in_bounds(min, max) 6 min + ((max-min) * rand()) 7 8 9 random_vector(minmax) 10 Array.new(minmax.size) |i| 11 rand_in_bounds(minmax[i][0], minmax[i][1]) 12 13 14
15 take_step(minmax, current, step_size) 16 position = Array.new(current.size) 17 position.size.times |i|
18 min = [minmax[i][0], current[i]-step_size].max 19 max = [minmax[i][1], current[i]+step_size].min 20 position[i] = rand_in_bounds(min, max)
21
22 position
23 24
25 large_step_size(iter, step_size, s_factor, l_factor, iter_mult) 26 step_size * l_factor iter>0 iter.modulo(iter_mult) == 0 27 step_size * s_factor
28 29
30 take_steps(bounds, current, step_size, big_stepsize) 31 step, big_step = {}, {}
32 step[:vector] = take_step(bounds, current[:vector], step_size) 33 step[:cost] = objective_function(step[:vector]) 34 big_step[:vector] = take_step(bounds,current[:vector],big_stepsize) 35 big_step[:cost] = objective_function(big_step[:vector]) 36 step, big_step 37 38
39 search(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult,
2.3. Adaptive Random Search 37
40 step_size = (bounds[0][1]-bounds[0][0]) * init_factor 41 current, count = {}, 0
42 current[:vector] = random_vector(bounds)
43 current[:cost] = objective_function(current[:vector]) 44 max_iter.times |iter|
45 big_stepsize = large_step_size(iter, step_size, s_factor, l_factor,
iter_mult)
46 step, big_step = take_steps(bounds, current, step_size, big_stepsize) 47 step[:cost] <= current[:cost] big_step[:cost] <= current[:cost] 48 big_step[:cost] <= step[:cost]
49 step_size, current = big_stepsize, big_step 50 51 current = step 52 53 count = 0 54 55 count += 1
56 count, stepSize = 0, (step_size/s_factor) count >= max_no_impr 57
58 puts " > iteration #{(iter+1)}, best=#{current[:cost]}" 59 60 current 61 62 63 == 0 64 # problem configuration 65 problem_size = 2
66 bounds = Array.new(problem_size) {|i| [-5, +5]} 67 # algorithm configuration 68 max_iter = 1000 69 init_factor = 0.05 70 s_factor = 1.3 71 l_factor = 3.0 72 iter_mult = 10 73 max_no_impr = 30 74 # execute the algorithm
75 best = search(max_iter, bounds, init_factor, s_factor, l_factor,
iter_mult, max_no_impr)
76 puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].inspect}" 77
Listing 2.2: Adaptive Random Search in Ruby
2.3.6
References
Primary Sources
Many works in the 1960s and 1970s experimented with variable step sizes for Random Search methods. Schummer and Steiglitz are commonly credited the adaptive step size procedure, which they called ‘Adaptive Step-Size Random Search’ [6]. Their approach only modifies the step size based on an approximation of the optimal step size required to reach the global optima. Kregting and White review adaptive random search methods and propose
an approach called ‘Adaptive Directional Random Search’ that modifies both the algorithms step size and direction in response to the cost function [2].
Learn More
White reviews extensions to Rastrigin’s ‘Creeping Random Search’ [4] (fixed step size) that use probabilistic step sizes drawn stochastically from uniform and probabilistic distributions [7]. White also reviews works that propose dynamic control strategies for the step size, such as Karnopp [1] who proposes increases and decreases to the step size based on performance over very small numbers of trials. Schrack and Choit review random search methods that modify their step size in order to approximate optimal moves while searching, including the property of reversal [5]. Masri et al. describe an adaptive random search strategy that alternates between periods of fixed and variable step sizes [3].
2.3.7
Bibliography
[1] D. C. Karnopp. Random search techniques for optimization problems. Automatica, 1(2–3):111–121, 1963.
[2] J. Kregting and R. C. White. Adaptive random search. Technical Report TH-Report 71-E-24, Eindhoven University of Technology, Eindhoven, Netherlands, 1971.
[3] S. F. Masri, G. A. Bekey, and F. B. Safford. Global optimization algorithm using adaptive random search. Applied Mathematics and Computation, 7(4):353–376, 1980.
[4] L. A. Rastrigin. The convergence of the random search method in the extremal control of a many parameter system. Automation and Remote Control, 24:1337–1342, 1963.
[5] G. Schrack and M. Choit. Optimized relative step size random searches. Mathematical Programming, 10(1):230–244, 1976.
[6] M. Schumer and K. Steiglitz. Adaptive step size random search. IEEE Transactions on Automatic Control, 13(3):270–276, 1968.
[7] R. C. White. A survey of random methods for parameter optimization. Simulation, 17(1):197–205, 1971.