def __init__(self, params_ngb, selection, recombination,
mutation, statistics_recorder):
self.params_ngb = params_ngb
self.select_from = selection
self.recombine = recombination
self.mutate = mutation
self.fitness_table = SortedFitnessTable()
self.events = Events()
if statistics_recorder is not None:
self.events.on_change += statistics_recorder.record
def test_recorder_records_four_iterations(self):
table = SortedFitnessTable()
r = StatisticsRecorder(record_after_iterations=3)
events = Events()
events.on_change += r.record
it_total = 10 # 0, 3, 6, 9 should be recorded
expected_records = 4
for it in range(it_total):
events.on_change(it, table)
self.assertEquals(expected_records, len(r.records))
def optimization_start(self, fitness_object):
self.fitness_table.clear()
self.table_random_initialization(fitness_object)
self.fit_calls_remain = self.params_ngb.max_fitness_calls - self.params_ngb.initial_table_size
self.events.on_change(iteration=0, fitness_table=self.fitness_table)
threads = []
for i in range(multiprocessing.cpu_count()):
p = threading.Thread(target=self.optimization_routine, args=(fitness_object, ))
threads.append(p)
for p in threads:
p.start()
for p in threads:
p.join()
return SortedFitnessTable.from_table(self.fitness_table)
def optimization_start(self, fitness_object):
self.fitness_table.clear()
self.table_random_initialization(fitness_object)
fitness_calls_remain = self.params_ngb.max_fitness_calls - self.params_ngb.initial_table_size
self.events.on_change(iteration=0, fitness_table=self.fitness_table)
for i in range(1, fitness_calls_remain + 1):
parents_indices = self.select_from(len(self.fitness_table))
recombined = self.recombine([self.fitness_table[x] for x in parents_indices])
mutated = self.mutate(recombined)
mapped_params = self.map_parameters(mutated.params) # map the params from range (0.0, 1.0) to search_space
mutated.fitness = fitness_object.compute(mapped_params)
self.fitness_table.add_individual(mutated)
if len(self.fitness_table) > self.params_ngb.table_size:
self.fitness_table.remove_last()
self.events.on_change(iteration=i, fitness_table=self.fitness_table)
return SortedFitnessTable.from_table(self.fitness_table)
class OptimizerNGB:
"""Non-Generation-Based(NGB) optimization engine"""
def __init__(self, params_ngb, selection, recombination,
mutation, statistics_recorder):
self.params_ngb = params_ngb
self.select_from = selection
self.recombine = recombination
self.mutate = mutation
self.fitness_table = SortedFitnessTable()
self.events = Events()
if statistics_recorder is not None:
self.events.on_change += statistics_recorder.record
def table_random_initialization(self, fitness_object):
n_params = self.params_ngb.num_params
initial_sigma = self.params_ngb.initial_sigma
sigma_dim = n_params if self.params_ngb.is_sigma_array else 1
for i in range(0, self.params_ngb.initial_table_size):
rnd_individ = Individual(None, np.random.uniform(0.0, 1.0, n_params),
initial_sigma * np.ones(sigma_dim))
mapped_params = self.map_parameters(rnd_individ.params) # map params from (0.0, 1.0) -> search_space
rnd_individ.fitness = fitness_object.compute(mapped_params)
self.fitness_table.add_individual(rnd_individ)
def map_parameters(self, params):
min_values = self.params_ngb.search_spaces[:, 0]
max_values = self.params_ngb.search_spaces[:, 1]
return (max_values - min_values) * params + min_values
def optimization_start(self, fitness_object):
self.fitness_table.clear()
self.table_random_initialization(fitness_object)
fitness_calls_remain = self.params_ngb.max_fitness_calls - self.params_ngb.initial_table_size
self.events.on_change(iteration=0, fitness_table=self.fitness_table)
for i in range(1, fitness_calls_remain + 1):
parents_indices = self.select_from(len(self.fitness_table))
recombined = self.recombine([self.fitness_table[x] for x in parents_indices])
mutated = self.mutate(recombined)
mapped_params = self.map_parameters(mutated.params) # map the params from range (0.0, 1.0) to search_space
mutated.fitness = fitness_object.compute(mapped_params)
self.fitness_table.add_individual(mutated)
if len(self.fitness_table) > self.params_ngb.table_size:
self.fitness_table.remove_last()
self.events.on_change(iteration=i, fitness_table=self.fitness_table)
return SortedFitnessTable.from_table(self.fitness_table)
def print_fitness_table(self):
for i in range(0, len(self.fitness_table)):
print("{0:.3e}, {1}, {2}".format(self.fitness_table[i].fitness,
self.fitness_table[i].params,
self.fitness_table[i].sigma))
print("-------------------------------------------------------------")
class OptimizerParallelNGB:
"""Non-Generation-Based(NGB) optimization engine"""
def __init__(self, params_ngb, selection, recombination,
mutation, statistics_recorder):
self.params_ngb = params_ngb
self.select_from = selection
self.recombine = recombination
self.mutate = mutation
self.fitness_table = SortedFitnessTable()
self.fit_calls_remain = 0
self.lock = threading.Lock()
self.events = Events()
if statistics_recorder is not None:
self.events.on_change += statistics_recorder.record
def table_random_initialization(self, fitness_object):
n_params = self.params_ngb.num_params
initial_sigma = self.params_ngb.initial_sigma
sigma_dim = n_params if self.params_ngb.is_sigma_array else 1
for i in range(0, self.params_ngb.initial_table_size):
rnd_individ = Individual(None, np.random.uniform(0.0, 1.0, n_params),
initial_sigma * np.ones(sigma_dim))
mapped_params = self.map_parameters(rnd_individ.params) # map params from (0.0, 1.0) -> search_space
rnd_individ.fitness = fitness_object.compute(mapped_params)
self.fitness_table.add_individual(rnd_individ)
def map_parameters(self, params):
min_values = self.params_ngb.search_spaces[:, 0]
max_values = self.params_ngb.search_spaces[:, 1]
return (max_values - min_values) * params + min_values
def optimization_routine(self, fitness_object):
while self.fit_calls_remain > 0:
with self.lock:
parents_indices = self.select_from(len(self.fitness_table))
recombined = self.recombine([self.fitness_table[x] for x in parents_indices])
mutated = self.mutate(recombined)
mapped_params = self.map_parameters(mutated.params) # map the params from range (0.0, 1.0) to search_space
mutated.fitness = fitness_object.compute(mapped_params)
with self.lock:
if self.fit_calls_remain > 0:
self.fitness_table.add_individual(mutated)
if len(self.fitness_table) > self.params_ngb.table_size:
self.fitness_table.remove_last()
self.events.on_change(iteration=self.params_ngb.max_fitness_calls - self.fit_calls_remain,
fitness_table=self.fitness_table)
self.fit_calls_remain -= 1
def optimization_start(self, fitness_object):
self.fitness_table.clear()
self.table_random_initialization(fitness_object)
self.fit_calls_remain = self.params_ngb.max_fitness_calls - self.params_ngb.initial_table_size
self.events.on_change(iteration=0, fitness_table=self.fitness_table)
threads = []
for i in range(multiprocessing.cpu_count()):
p = threading.Thread(target=self.optimization_routine, args=(fitness_object, ))
threads.append(p)
for p in threads:
p.start()
for p in threads:
p.join()
return SortedFitnessTable.from_table(self.fitness_table)
def record(self, iteration, fitness_table):
if (iteration % self.record_after_iterations) == 0:
t = SortedFitnessTable.from_table(fitness_table)
self.records.append(t)
def setUp(self):
self.table = SortedFitnessTable()
class SortedFitnessTableTest(unittest.TestCase):
def setUp(self):
self.table = SortedFitnessTable()
def test_add_remove_individual_increases_size(self):
size_initial = len(self.table)
self.table.add_individual(Individual(5.0, [1.0], [0.1]))
assert size_initial == 0
assert len(self.table) == 1
def test_inserted_elements_are_sorted(self):
# insert four individuals
self.table.add_individual(Individual(15.0, [2.0], [0.2]))
self.table.add_individual(Individual(-15.0, [3.0], [0.3]))
self.table.add_individual(Individual(-30.0, [4.0], [0.4]))
self.table.add_individual(Individual(15.0, [5.0], [0.5]))
self.assertEqual(4, len(self.table))
for i in range(1, len(self.table)):
self.assertTrue(self.table[i].fitness <= self.table[i-1].fitness)
def test_clear_sets_tablesize_to_zero(self):
# insert two individuals
self.table.add_individual(Individual(15.0, [2.0], [0.2]))
self.table.add_individual(Individual(-15.0, [3.0], [0.3]))
self.assertEquals(2, len(self.table))
self.table.clear()
self.assertEquals(0, len(self.table))
def test_remove_last_decrease_table_size_by_one(self):
# insert two individuals
self.table.add_individual(Individual(15.0, [2.0], [0.2]))
self.table.add_individual(Individual(-15.0, [3.0], [0.3]))
self.assertEquals(2, len(self.table))
self.table.remove_last()
self.assertEquals(1, len(self.table))
def test_remove_last_does_nothing_if_table_size_is_zero(self):
self.assertEquals(0, len(self.table))
self.table.remove_last()
self.assertEquals(0, len(self.table))