def test_set_fitness_type(self):
"""
This function tests setting a fitness type. It also tests the option
of setting a target value at the same time.
"""
self.ges.set_fitness_type(CENTER)
fitl = FitnessList(CENTER)
self.assertEqual(fitl.get_fitness_type(),
self.ges.fitness_list.get_fitness_type())
fitl = FitnessList(MIN)
self.ges.set_fitness_type(MIN)
self.assertEqual(fitl.get_fitness_type(),
self.ges.fitness_list.get_fitness_type())
fitl = FitnessList(MAX)
self.ges.set_fitness_type(MAX)
self.assertEqual(fitl.get_fitness_type(),
self.ges.fitness_list.get_fitness_type())
self.assertRaises(ValueError, self.ges.set_fitness_type, "wrong")
# Include target value
fitl = FitnessList(CENTER, 1.0)
self.ges.set_fitness_type(CENTER, 1.0)
self.assertEqual(fitl.get_fitness_type(),
self.ges.fitness_list.get_fitness_type())
self.assertEqual(1.0, self.ges.fitness_list._target_value)
self.assertRaises(ValueError, self.ges.set_fitness_type, CENTER,
"test")
def test_class_init_(self):
fitness_list = FitnessList(MAX)
# Is it a list?
self.assertEqual(True, isinstance(fitness_list, list))
# Does the fitness type get set?
self.assertEqual(MAX, fitness_list._fitness_type)
# Does the target_value get set?
self.assertEqual(0.0, fitness_list._target_value)
fitness_list = FitnessList(MAX, .5)
self.assertAlmostEqual(0.5, fitness_list._target_value)
def test_invert(self):
fitness = FitnessList(MAX)
fit = Fitness(fitness)
self.assertAlmostEqual(.25, fit._invert(4.0))
self.assertAlmostEqual(-.25, fit._invert(-4.0))
self.assertAlmostEqual(2.0, fit._invert(0.5))
def test_select(self):
# attempting to maximize remove worst 3
self.repl.set_replacement_count(3)
values = [i for i in self.repl.select()]
self.assertLessEqual(
self.repl._fitness_list[values[0]][0],
self.repl._fitness_list[values[1]][0],
)
self.assertLessEqual(
self.repl._fitness_list[values[1]][0],
self.repl._fitness_list[values[2]][0],
)
# attempting to minimize remove worst 3
self.fitness_list = FitnessList(MIN)
values = [i for i in self.repl.select()]
self.assertGreaterEqual(
self.repl._fitness_list[values[0]][0],
self.repl._fitness_list[values[1]][0],
)
self.assertGreaterEqual(
self.repl._fitness_list[values[1]][0],
self.repl._fitness_list[values[2]][0],
)
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.append([3.0, 0])
self.fitness_list.append([2.0, 1])
self.fitness_list.append([5.0, 2])
self.fitness_list.append([4.0, 3])
self.fitness_list.append([1.0, 4])
def test_classinit_(self):
"""
Does it set the fitness_list?
"""
fitness = FitnessList(MAX)
fit = Fitness(fitness)
self.assertEqual(fit._fitness_list, fitness)
def test_set_selection_list(self):
sel_type = Selection()
self.assertEqual(None, sel_type._selection_list)
sel_type.set_selection_list([1.0, 2.0, 3.0, 4.0, 5.0])
self.assertEqual(True, isinstance(sel_type._selection_list, list))
# test for fitness_list
fitl = FitnessList(MAX)
self.assertRaises(ValueError, sel_type.set_selection_list, fitl)
def test_set_fitness_list(self):
# Do MAX
fitness = FitnessList(MAX)
fit = Fitness(fitness)
fit._fitness_list = None
self.assertEqual(fit._fitness_list, None)
fit.set_fitness_list(fitness)
self.assertEqual(fit._fitness_list, fitness)
# Do CENTER selection_list converted to distance from target
fitness = FitnessList(CENTER, .15)
fitness.append([.5, 0])
fitness.append([.25, 1])
fitness.append([2.5, 2])
fit = Fitness(fitness)
fit._fitness_list = None
self.assertEqual(fit._fitness_list, None)
fit.set_fitness_list(fitness)
self.assertEqual(fit._selection_list, [.35, .1, 2.35])
def test_set_fitness_selections(self):
"""
This function tests setting a fitness selection class.
"""
self.ges.set_fitness_selections(Fitness(FitnessList('center')))
self.assertEqual(1, len(self.ges._fitness_selections))
self.ges.set_fitness_selections(Fitness(FitnessList('center')))
self.assertEqual(2, len(self.ges._fitness_selections))
self.ges._fitness_selections = []
self.ges.set_fitness_selections(Fitness(FitnessList('center')),
Fitness(FitnessList('center')))
self.assertEqual(2, len(self.ges._fitness_selections))
self.ges._fitness_selections = []
self.assertRaises(ValueError, self.ges.set_fitness_selections, "wrong")
def test_classinit_(self):
fitness_list = FitnessList(MAX)
fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
fit = FitnessTournament(fitness_list)
self.assertEqual(2, fit._tournament_size)
fit = FitnessTournament(fitness_list, tournament_size=3)
self.assertEqual(3, fit._tournament_size)
self.assertRaises(ValueError,
FitnessTournament,
fitness_list,
tournament_size=4)
def __init__(self):
"""
Because there are a number of parameters to specify, there are no
specific variables that are initialized within __init__.
There is a formidable number of default variables specified in this
function however.
"""
# Parameters for changing generations
self.stopping_criteria = {
STOPPING_MAX_GEN: None,
STOPPING_FITNESS_LANDSCAPE: None
}
self._crossover_rate = DEFAULT_CROSSOVER_RATE
self._children_per_crossover = DEFAULT_CHILDEREN_PER_CROSSOVER
self._mutation_type = DEFAULT_MUTATION_TYPE
self._mutation_rate = DEFAULT_MUTATION_RATE
self._max_fitness_rate = DEFAULT_MAX_FITNESS_RATE
# Parameters for phenotype creation
self._wrap = DEFAULT_WRAP
self._extend_genotype = DEFAULT_EXTEND_GENOTYPE
self._start_gene_length = DEFAULT_START_GENE_LENGTH
self._max_gene_length = DEFAULT_MAX_PROGRAM_LENGTH
self._max_program_length = DEFAULT_MAX_PROGRAM_LENGTH
# Parameters for overall process
self._generation = 0
self.fitness_list = FitnessList(CENTER)
self._fitness_fail = DEFAULT_FITNESS_FAIL
self._maintain_history = DEFAULT_MAINTAIN_HISTORY
self._timeouts = DEFAULT_TIMEOUTS
# Parameters used during runtime
self.current_g = None
self._fitness_selections = []
self._replacement_selections = []
self.bnf = {}
self._population_size = 0
self.population = []
self._history = []
def test_class_init__(self):
"""
This function tests the initialization of the class.
"""
ges = GrammaticalEvolution()
self.assertEqual(None, ges.stopping_criteria[STOPPING_MAX_GEN])
self.assertEqual(None,
ges.stopping_criteria[STOPPING_FITNESS_LANDSCAPE])
self.assertEqual(DEFAULT_CROSSOVER_RATE, ges._crossover_rate)
self.assertEqual(DEFAULT_CHILDEREN_PER_CROSSOVER,
ges._children_per_crossover)
self.assertEqual(DEFAULT_MUTATION_TYPE, ges._mutation_type)
self.assertEqual(DEFAULT_MUTATION_RATE, ges._mutation_rate)
self.assertEqual(DEFAULT_MAX_FITNESS_RATE, ges._max_fitness_rate)
# Parameters for phenotype creation
self.assertEqual(DEFAULT_WRAP, ges._wrap)
self.assertEqual(DEFAULT_EXTEND_GENOTYPE, ges._extend_genotype)
self.assertEqual(DEFAULT_START_GENE_LENGTH, ges._start_gene_length)
self.assertEqual(DEFAULT_MAX_PROGRAM_LENGTH, ges._max_gene_length)
self.assertEqual(DEFAULT_MAX_PROGRAM_LENGTH, ges._max_program_length)
# Parameters for overall process
self.assertEqual(0, ges._generation)
self.assertEqual(FitnessList(CENTER), ges.fitness_list)
self.assertEqual(DEFAULT_FITNESS_FAIL, ges._fitness_fail)
self.assertEqual(DEFAULT_MAINTAIN_HISTORY, ges._maintain_history)
self.assertEqual(DEFAULT_TIMEOUTS, ges._timeouts)
# Parameters used during runtime
self.assertEqual(None, ges.current_g)
self.assertEqual([], ges._fitness_selections)
self.assertEqual([], ges._replacement_selections)
self.assertEqual({}, ges.bnf)
self.assertEqual(0, ges._population_size)
self.assertEqual([], ges.population)
self.assertEqual([], ges._history)
def setUp(self):
# Check truncation
self.fitness = FitnessList(MAX)
self.fitness.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_scale_list(self):
#
# fitness type MAX, test select type MAX
#
fitness = FitnessList(MAX)
fitness.extend([[.5, 0], [.25, 1], [2.5, 2]])
fit = Fitness(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.5, fit._selection_list[0])
self.assertAlmostEqual(.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type MAX, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MAX
#
fitness.set_fitness_type(MIN)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.5, fit._selection_list[0])
self.assertAlmostEqual(.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type CENTER, test select type MAX
#
fitness.set_fitness_type(CENTER)
fitness.set_target_value(.75)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(4.0, fit._selection_list[0])
self.assertAlmostEqual(2.0, fit._selection_list[1])
self.assertAlmostEqual(0.5714285714, fit._selection_list[2])
#
# fitness type CENTER, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.25, fit._selection_list[0])
self.assertAlmostEqual(.5, fit._selection_list[1])
self.assertAlmostEqual(1.75, fit._selection_list[2])
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementTournament(self.fitness_list, tournament_size=1)
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementDeleteWorst(self.fitness_list,
replacement_count=1)
