def __init__(self):
self.mock_population = []
genome_one = StorageGenome()
genome_one._id = ObjectId("000000000000000000000000")
genome_one.fitness = 0.5
genome_one.genes = [
(1, True, 0.5),
(2, True, 0.5),
(3, True, 0.5),
(4, True, 0.5)
]
genome_two = StorageGenome()
genome_two._id = ObjectId("000000000000000000000001")
genome_two.fitness = 0.7
genome_two.genes = [
(1, True, 0.5),
(3, True, 1),
(4, True, 0),
(5, True, 0.5)
]
self.mock_population.append(genome_one)
self.mock_population.append(genome_two)
def test_updateGenomeFitness(self):
genome = StorageGenome()
genome.fitness = 1.0
self.genome_repository.get_genome_by_id = lambda x: genome
self.genome_repository.update_genome = lambda x: x
self.assertEqual(2.0, self.genome_repository.update_genome_fitness(genome._id, 2.0).fitness)
def test_updateGenomesFitness(self):
genomes = []
for i in range(0, 10):
g = StorageGenome()
g.fitness = float(1 / (i + 2))
genomes.append((g, 4.7))
self.genome_repository.get_genome_by_id = lambda x: x
self.genome_repository.update_genomes = lambda x: x
for i in self.genome_repository.update_genomes_fitness(genomes):
self.assertEqual(4.7, i.fitness)
def test_getGenomesInCluster(self):
genomes = []
genomes_in_tuple = []
for g in range(1, 10):
genome = StorageGenome()
genome.fitness = float(1/g)
genomes.append(genome)
genomes_in_tuple.append((genome, genome.fitness))
self.mock_genome_repository.get_genomes_in_cluster = MagicMock(return_value=genomes)
self.assertListEqual(genomes_in_tuple, self.genome_selector.get_genomes_in_cluster(0))
def test_selectGenomesForDiscarding(self):
"""
checks if 20% of worst cluster or genomes were selected
:return:
"""
cluster = []
genome = []
for i in range(0, 4):
c = Cluster()
c.offspring = i
cluster.append(c)
for i in range(0, 10):
g = StorageGenome()
g.fitness = float(1/(i+1))
genome.append(g)
self.mock_cluster_repository.get_current_clusters = MagicMock(return_value=cluster)
self.mock_genome_repository.get_genomes_in_cluster = MagicMock(return_value=genome)
self.assertEqual(8, len(self.genome_selector.select_genomes_for_discarding()))
def test_selectGenomesForBreeding_and_selectGenomesForMutation(self):
offspring = [10, 10, 10, 10]
cluster = []
genome = []
for i in offspring:
c = Cluster()
c.offspring = i
cluster.append(c)
for i in range(0, 8):
g = StorageGenome()
g.fitness = float(1/(i+1))
genome.append(g)
g = StorageGenome()
self.mock_cluster_repository.get_current_clusters = MagicMock(return_value=cluster)
self.mock_genome_repository.get_genomes_in_cluster = MagicMock(return_value=genome)
self.assertEqual(8, len(self.genome_selector.select_genomes_for_breeding(0.2)))
self.assertEqual(type(g), type(self.genome_selector.select_genomes_for_breeding(0.2)[0][0]))
self.assertEqual(type(g), type(self.genome_selector.select_genomes_for_mutation(0.2)[0]))
self.assertEqual(8, len(self.genome_selector.select_genomes_for_mutation(0.2)))
def test_selectClusterCombination(self):
offspring = [10, 10]
cluster = []
genome = []
for i in offspring:
c = Cluster()
c.offspring = i
cluster.append(c)
for i in range(0, 8):
g = StorageGenome()
g.fitness = float(1/(i+1))
genome.append(g)
self.mock_genome_repository.get_genomes_in_cluster = MagicMock(return_value=genome)
test_comb = self.genome_selector.select_cluster_combinations(cluster[0], cluster[1], 2)
g = StorageGenome()
g_type = (g, g)
g_list = [g_type]
self.assertEqual(2, len(test_comb))
self.assertEqual(type(g_list), type(test_comb))
self.assertEqual(2, len(test_comb[0]))
self.assertEqual(type(g_type), type(test_comb[0]))
def test_breed_genomes(self):
fitter_genome = StorageGenome()
fitter_genome.fitness = 22.74
fitter_genome.genes = {
0: (True, 0.21),
1: (True, -0.56),
2: (True, 0.354),
3: (True, 0.98),
7: (True, 0.47),
8: (True, -0.13)
}
other_genome = StorageGenome()
other_genome.fitness = 19.233
other_genome.genes = {
0: (True, 0.1),
1: (True, 0.1),
2: (True, 0.1),
4: (True, 0.1),
5: (True, -0.1),
6: (True, -0.1)
}
similar_genome = StorageGenome()
similar_genome.fitness = 21.83
similar_genome.genes = {
0: (True, 0.1),
1: (True, 0.1),
2: (True, 0.1),
4: (True, 0.1),
5: (True, -0.1),
6: (True, -0.1)
}
new_genome = self.breeder.breed_genomes(
fitter_genome,
other_genome
)
new_genome_two = self.breeder.breed_genomes(
fitter_genome,
similar_genome
)
# print(new_genome.genes) # TODO: proper testing
# self.fail("Not implemented.")
self.assertListEqual(
list(new_genome.genes.keys()),
[0, 1, 2, 3, 7, 8],
"The wrong genes were inherited by breed_genomes()."
)
self.assertEqual(
new_genome.genes[3][1],
0.98,
"The differing gene with id 3 wasn't inherited correctly by breed_genomes()."
)
self.assertEqual(
new_genome.genes[7][1],
0.47,
"The differing gene with id 3 wasn't inherited correctly by breed_genomes()."
)
self.assertEqual(
new_genome.genes[8][1],
-0.13,
"The differing gene with id 3 wasn't inherited correctly by breed_genomes()."
)
in_set = [(g in new_genome_two.genes.keys()) for g in [0, 1, 2]]
self.assertTrue(
lambda : not False in in_set
)
differing_genes = [g for g in new_genome_two.genes.keys() if (g not in [0, 1, 2])]
for gene_id in differing_genes:
weight = new_genome_two.genes[gene_id][1]
parent_genome = fitter_genome \
if gene_id in fitter_genome.genes.keys() \
else similar_genome
original_weight = parent_genome.genes[gene_id][1]
self.assertEqual(
weight,
original_weight
)
