Updated directory structure.

Author: skytreader

python/2_Stochastic_Algorithms/adaptive_random_search.py

@@ -0,0 +1,121 @@
+#! usr/bin/env python3
+
+import random
+
+"""
+2.3
+
+Adaptive Random Search was designed to address the limitations
+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 Adaptive Random Search 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.
+
+The example problem below is similar to the one solved by Random Search [2.2].
+
+@author Chad Estioco
+"""
+
+def objective_function(vector):
+	"""
+	Similar to the one in [2.2]
+	"""
+	sum = 0
+	
+	for val in vector:
+		sum += val ** 2
+	
+	return sum
+
+def rand_in_bounds(minimum, maximum):
+	return minimum + ((maximum - minimum) * random.random())
+
+def random_vector(minmax):
+	"""
+	_Essentially_ similar to the one in [2.2]
+	"""
+	i = 0
+	limit = len(minmax)
+	random_vector = [0 for i in range(limit)]
+	
+	for i in range(limit):
+		random_vector[i] = rand_in_bounds(minmax[i][0], minmax[i][1])
+	
+	return random_vector
+
+def take_step(minmax, current, step_size):
+	limit = len(current)
+	position = [0 for i in range(limit)]
+	
+	for i in range(limit):
+		minimum = max(minmax[i][0], current[i] - step_size)
+		maximum = min(minmax[i][1], current[i] + step_size)
+		position[i] = rand_in_bounds(minimum, maximum)
+	
+	return position
+
+def large_step_size(iter_count, step_size, s_factor, l_factor, iter_mult):
+	if iter_count > 0 and iter_count % iter_mult == 0:
+		return step_size * l_factor
+	else:
+		return step_size * s_factor
+
+def take_steps(bounds, current, step_size, big_stepsize):
+	step, big_step = {}, {}
+	step["vector"] = take_step(bounds, current["vector"], step_size)
+	step["cost"] = objective_function(step["vector"])
+	big_step["vector"] = take_step(bounds, current["vector"], big_stepsize)
+	big_step["cost"] = objective_function(big_step["vector"])
+	return step, big_step
+
+def search(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr):
+	step_size = (bounds[0][1] - bounds[0][0]) * init_factor
+	current, count = {}, 0
+	current["vector"] = random_vector(bounds)
+	current["cost"] = objective_function(current["vector"])
+	
+	for i in range(max_iter):
+		big_stepsize = large_step_size(i, step_size, s_factor, l_factor, iter_mult)
+		step, big_step = take_steps(bounds, current, step_size, big_stepsize)
+		
+		if step["cost"] <= current["cost"] or big_step["cost"] <= current["cost"]:
+			if big_step["cost"] <= step["cost"]:
+				step_size, current = big_stepsize, big_step
+			else:
+				current = step
+			
+			count = 0
+		else:
+			count += 1
+			
+			if count >= max_no_impr:
+				count, stepSize = 0, (step_size/s_factor)
+		
+		print("Iteration " + str(i) + ": best = " + str(current["cost"]))
+	
+	return current
+
+if __name__ == "__main__":
+	# problem configuration
+	problem_size = 2
+	bounds = [[-5, 5] for i in range(problem_size)]
+	
+	# algorithm configuration
+	max_iter = 1000
+	init_factor = 0.05
+	s_factor = 1.3
+	l_factor = 3.0
+	iter_mult = 10
+	max_no_impr = 30
+	
+	# execute the algorithm
+	best = search(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr)
+	print("Done. Best Solution: cost = " + str(best["cost"]) + ", v = " + str(best["vector"]))

python/2_Stochastic_Algorithms/random_search.py

@@ -0,0 +1,63 @@
+#! usr/bin/env python3
+
+import random
+
+"""
+2.2
+
+Random Search samples solutions from across the entire search space
+using a uniform probability distribution. Each future sample is
+independent of the samples that come before it.
+
+The example problem (solved by the code below) is an instance of a
+continuous function optimization that seeks min f(x) where
+f = \sum_{i=1}^{n} x_i^2, -5 <= x_i <= 5 and n = 2.
+
+@author Chad Estioco
+"""
+
+def objective_function(vector):
+	sum = 0
+	
+	for val in vector:
+		sum += val ** 2
+	
+	return sum
+
+def random_vector(minmax):
+	i = 0
+	limit = len(minmax)
+	random_vector = [0 for i in range(limit)]
+	
+	for i in range(limit):
+		spam = minmax[i][0]
+		random_vector[i] = spam + ((minmax[i][1] - spam) * random.random())
+	
+	return random_vector
+
+def search(search_space, max_iter):
+	best = None
+	
+	for i in range(max_iter):
+		candidate = {}
+		candidate['vector'] = random_vector(search_space)
+		candidate['cost'] = objective_function(candidate['vector'])
+		
+		if best is None or candidate['cost'] < best['cost']:
+			best = candidate
+		
+		print("Iteration " + str(i) + ": best = " + str(best['cost']))
+	
+	return best
+
+if __name__ == "__main__":
+	# problem configuration
+	problem_size = 2
+	search_space = [[-5, 5] for i in range(problem_size)]
+	
+	# algorithm configuration
+	max_iter = 100
+	
+	# execute the algorithm
+	best = search(search_space ,max_iter)
+	print("Done. Best Solution: cost = " + str(best['cost']) + ", v = " + str(best['vector']))

python/2_Stochastic_Algorithms/stochastic_hill_climbing.py

@@ -0,0 +1,92 @@
+#! usr/bin/env python3
+
+import random
+
+"""
+2.4
+
+Stochastic Hill Climbing iterates the process of randomly
+selecting a neighbor for a candidate solution and only accept
+it if it results in an improvement. The strategy was proposed to
+address the limitations of deterministic hill climbing techniques
+that were likely to get stuck in local optima due to their greedy
+acceptance of neighboring moves.
+
+This code implements the Random Mutation Hill Climbing algorithm,
+a specific instance of Stochastic Hill Climbing. It is applied to
+a binary string optimization problem called "One Max": prepare a
+string of all '1' bits where the cost function only reports the
+number of bits in a given string.
+
+Implementation notes:
+The reference implementation uses a list of (one-character) strings.
+I opted to use a String object directly.
+
+@author Chad Estioco
+"""
+
+def onemax(vector):
+	limit = len(vector)
+	one_count = 0
+	
+	for i in range(limit):
+		if vector[i] == "1":
+			one_count += 1
+	
+	return one_count
+
+def random_bitstring(num_bits):
+	def generator():
+		bit = None
+		
+		if random.random() < 0.5:
+			bit = "1"
+		else:
+			bit = "0"
+		
+		return bit
+	
+	return "".join(generator() for i in range(num_bits))
+
+def random_neighbor(bitstring):
+	mutant = bitstring
+	limit = len(bitstring)
+	pos = random.randint(0, limit - 1)
+	
+	if mutant[pos] == "1":
+		mutant = "".join((mutant[0:pos], "0" ,mutant[pos + 1:limit]))
+	else:
+		mutant = "".join((mutant[0:pos], "1" ,mutant[pos + 1:limit]))
+	
+	return mutant
+
+def search(max_iterations, num_bits):
+	candidate = {}
+	candidate["vector"] = random_bitstring(num_bits)
+	candidate["cost"] = onemax(candidate["vector"])
+	
+	for i in range(max_iterations):
+		neighbor = {}
+		neighbor["vector"] = random_neighbor(candidate["vector"])
+		neighbor["cost"] = onemax(neighbor["vector"])
+		
+		if neighbor["cost"] >= candidate["cost"]:
+			candidate = neighbor
+		
+		print("Iteration " + str(i) + ": best = " + str(candidate["cost"]))
+		
+		if candidate["cost"] == num_bits:
+			break
+	
+	return candidate
+
+if __name__ == "__main__":
+	# problem configuration
+	num_bits = 64
+	
+	# algorithm configuration
+	max_iterations = 1000
+	
+	# execute the algoirthm
+	best = search(max_iterations, num_bits)
+	print("Done. Best Solution: cost = " + str(best["cost"]) + ", v = " + str(best["vector"]))