def test_advance(self):
big_pop = Population(
[MockOrganism(1), MockOrganism(2),
MockOrganism(90)], 3)
big_pop.advance_generation()
self.assertLessEqual(len(big_pop), 3)
class TestPopulationBitstring(unittest.TestCase):
def setUp(self):
bit0 = Bitstring("0000")
bit1 = Bitstring("1111")
col0 = ColicinBit(bit0)
col1 = ColicinBit(bit1)
org = Organism([col0], [ImmunityBit(bit0, 2)])
self.pop = Population([org for _ in range(5)])
def test_replicate(self):
self.assertEqual(len(self.pop), 5)
self.pop.replicate()
self.assertEqual(len(self.pop), 10)
def test_remove_self_toxic(self):
self.assertEqual(len(self.pop), 5)
self.pop.remove_self_toxic()
self.assertEqual(len(self.pop), 5)
def test_cull_by_iterative_colicin(self):
self.assertEqual(len(self.pop), 5)
self.pop.cull_by_iterative_colicin()
self.assertEqual(len(self.pop), 5)
def test_advance_generation(self):
self.pop.advance_generation()
def test_sample_with_replacement(self):
self.pop.sample_with_replacement()
def test_advance(self):
big_pop = Population(
[MockOrganism(1),
MockOrganism(2),
MockOrganism(90)], 3)
big_pop.advance_generation()
self.assertLessEqual(len(big_pop), 3)
def colicin_int_demo():
org = Organism([Colicin(0)], [Immunity(0, 5)])
pop = Population(org for _ in range(5))
for gen in range(1000):
pop.advance_generation()
average_id = average_colicin_int(pop)
if gen % 100 == 0:
print("{}\t{}".format(gen, average_id))
def colicin_bitstring_demo():
mutate.mutation_rate = 0.05
bit = Bitstring("0000000000000000000")
bit2 = Bitstring("1000000000000000000")
col = ColicinBit(bit)
imm = ImmunityBit(bit2, 1)
org = Organism([col], [imm, imm])
pop = Population(org for _ in range(100))
for gen in range(101):
pop.advance_generation()
if gen % 10 == 0:
average_dist = average_colicin_bitstring_distance(pop, col)
print("{}\t{}".format(gen, average_dist))
class Lifecycle(object):
def __init__(self, id, params):
self.id = id
self.params = params
self.population = Population(self.params["population_size"])
self.best_fit = list()
self.average_fit = list()
self.iterations = 0
def start(self):
for epoch in range(0, self.params["epochs"]):
self.iterations += 1
elite = self.params["elite"]
crossover = self.params["crossover"]
mutation = self.params["mutation"]
self.population.advance_generation(elite,
crossover_rate=crossover,
n_arena=4,
mutation=mutation)
self.best_fit.append(self.population.best_fitness())
self.average_fit.append(self.population.avg_fitness())
if epoch > 50:
recent_best = self.best_fit[-50:]
if max(recent_best) - min(recent_best) < 0.02:
break
def best_fitness(self):
return self.population.best_fitness()
def generate_graph(self, show=False, location=None):
plt.plot(self.best_fit)
plt.xlabel("Epoch")
plt.ylabel("Best fitness")
plt.title(self.get_params())
if show:
plt.show()
if location is not None:
plt.savefig(location)
def get_params(self):
return_string = ("mutation: %d " % self.params['mutation'])
return_string += ("crossover: %d " % self.params['crossover'])
return_string += ("elite: %d " % self.params['elite'])
return_string += ("iter: %d" % self.iterations)
return return_string
def get_csv(self):
id = {'id': self.id}
best_fitness = {'best_fit': self.best_fitness()}
iter = {'iter': self.iterations}
return {**id, **best_fitness, **self.params, **iter}
class TestPopulation(unittest.TestCase):
def setUp(self):
self.col = Colicin(0)
self.imm = Immunity(-5, 5)
self.org = Organism([self.col], [self.imm])
self.pop = Population([self.org.duplicate() for _ in range(10)])
def test_len(self):
self.assertEqual(len(self.pop), 10)
def test_replicate(self):
self.pop.replicate()
self.assertEqual(self.pop.pop.count(self.org), 10)
self.assertEqual(len(self.pop), 20)
def test_iter(self):
for org in self.pop:
self.assertEqual(org, self.org)
else:
return
self.fail()
def test_remove_self_toxic(self):
org_toxic = Organism([Colicin(0)], [Immunity(10, 5)])
org_not_toxic = Organism([Colicin(0)], [Immunity(0, 5)])
self.pop.pop = [org_not_toxic, org_toxic]
self.assertEqual(len(self.pop), 2)
self.pop.remove_self_toxic()
self.assertEqual(len(self.pop), 1)
self.assertSequenceEqual(self.pop.pop, [org_not_toxic])
def test_cull_by_all_colicins(self):
org_winner = Organism([Colicin(5)], [Immunity(0, 5)])
self.pop.pop.append(org_winner)
self.pop.cull_by_all_colicins()
self.assertSequenceEqual(self.pop.pop, [org_winner])
def test_cull_by_all_colicins_extinction(self):
org_other = Organism([Colicin(5)], [Immunity(10, 5)])
self.pop.pop.append(org_other)
self.pop.cull_by_all_colicins()
self.assertEqual(len(self.pop), 0)
def test_cull_by_single_colicin(self):
org_other = Organism([Colicin(100)], [Immunity(100, 5)])
self.pop.pop.extend(org_other for _ in range(10))
self.pop.cull_by_single_colicin()
self.assertEqual(len(self.pop), 10)
def test_cull_by_single_colicin_extinction(self):
self.pop.cull_by_single_colicin(Colicin(5))
self.assertEqual(len(self.pop), 0)
def test_cull_by_iterative_colicin(self):
org_winner = Organism([Colicin(5)], [Immunity(0, 5)])
self.pop.pop.append(org_winner)
self.pop.cull_by_iterative_colicin()
self.assertSequenceEqual(self.pop.pop, [org_winner])
def test_cull_by_iterative_colicin_extinction(self):
org_other = Organism([Colicin(5)], [Immunity(10, 5)])
self.pop.pop.extend(org_other for _ in range(10))
self.pop.cull_by_iterative_colicin()
self.assertEqual(len(self.pop), 10)
def test_colicins_produced(self):
colicins = set(self.pop.colicins_produced())
self.assertSetEqual({self.col}, colicins)
other_colicin = Colicin(5)
self.pop.pop.append(Organism([other_colicin], [Immunity(0, 5)]))
colicins = set(self.pop.colicins_produced())
self.assertSetEqual({self.col, other_colicin}, colicins)
def test_sample_with_replacement(self):
self.pop.pop.extend(self.org for _ in range(20))
self.assertEqual(len(self.pop), 30)
self.pop.sample_with_replacement()
self.assertEqual(len(self.pop), 10)
self.pop.pop = self.pop.pop[::2]
self.assertEqual(len(self.pop), 5)
self.pop.sample_with_replacement()
self.assertEqual(len(self.pop), 10)
self.assertEqual(self.pop.carrying_capacity, 10)
def test_advance_generation(self):
self.pop.advance_generation()
self.assertEqual(len(self.pop), 10)
