def test_return_an_ugraph(self):
stpg = self.stpg
initialization = GenerateBasedRandomWalk(stpg)
tree = initialization()
self.assertTrue(isinstance(tree, UGraph))
def test_evaluation_cost(self):
possibles = [f'steinb{ii}.txt' for ii in range(10, 19)]
filename = choice(possibles)
filename = path.join('datasets', 'ORLibrary', filename)
stpg = ReaderORLibrary().parser(filename)
generator = GenerateBasedRandomWalk(stpg)
mutator = PrimBasedMutation(stpg)
evaluator = EvaluateTreeGraph(stpg)
before = generator()
after = mutator(before)
eval_cost, partitions = evaluator(after)
self.assertEqual(partitions, 1)
self.assertGreater(eval_cost, 0)
subgraph = UWGraph()
vertices = set(before.vertices)
graph = stpg.graph
for v in vertices:
for u in graph.adjacent_to(v):
if u in vertices:
subgraph.add_edge(v, u, weight=graph.weight(v, u))
_, prim_cost = prim(subgraph, choice(tuple(stpg.terminals)))
self.assertEqual(prim_cost, eval_cost)
def test_if_works(self):
possibles = [f'steinb{ii}.txt' for ii in range(10, 19)]
filename = choice(possibles)
filename = path.join('datasets', 'ORLibrary', filename)
stpg = ReaderORLibrary().parser(filename)
generator = GenerateBasedRandomWalk(stpg)
mutator = PrimBasedMutation(stpg)
prunner = Prunning(stpg)
before = generator()
self.assertIsInstance(before, UGraph)
_, response = is_steiner_tree(before, stpg)
self.assertTrue(response['all_terminals_in'])
self.assertFalse(response['has_cycle'])
self.assertTrue(response['all_edges_are_reliable'])
self.assertTrue(response['graph_is_connected'])
after = mutator(before)
self.assertIsInstance(after, UGraph)
after_after = prunner(after)
_, response = is_steiner_tree(after_after, stpg)
self.assertFalse(response['has_cycle'])
self.assertTrue(response['all_leaves_are_terminals'])
self.assertTrue(response['all_terminals_in'])
self.assertTrue(response['all_edges_are_reliable'])
self.assertTrue(response['graph_is_connected'])
def test_crossover(self):
stpg = self.stpg
initializator = GenerateBasedRandomWalk(stpg)
evaluator = EvaluateTreeGraph(stpg)
crossover = CrossoverKruskalRST(stpg)
red = initializator()
blue = initializator()
red_cost, _ = evaluator(red)
blue_cost, _ = evaluator(blue)
self.assertTrue(isinstance(red, UGraph))
self.assertTrue(isinstance(blue, UGraph))
self.assertGreater(red_cost, 0)
self.assertGreater(blue_cost, 0)
child = crossover(red, blue)
cc_cost, _ = evaluator(child)
self.assertGreater(cc_cost, 0)
_, response = is_steiner_tree(child, stpg)
self.assertTrue(response['all_terminals_in'])
self.assertFalse(response['has_cycle'])
self.assertTrue(response['all_edges_are_reliable'])
self.assertTrue(response['graph_is_connected'])
def test_is_steiner_tree(self):
stpg = self.stpg
initialization = GenerateBasedRandomWalk(stpg)
tree = initialization()
_, response = is_steiner_tree(tree, stpg)
self.assertTrue(response['all_terminals_in'])
self.assertFalse(response['has_cycle'])
self.assertTrue(response['all_edges_are_reliable'])
self.assertTrue(response['graph_is_connected'])
def simulation(name, params):
filename = path.join("datasets", "ORLibrary", params["dataset"])
stpg = ReaderORLibrary().parser(filename)
print("STPG information", '\n', 10 * '- ', '\n')
print('Instance: ', stpg.name)
print('Best Known cost: ', params['global_optimum'])
print("Nro. Node:", stpg.nro_nodes)
print("Nro. Edges:", stpg.nro_edges)
print("Nro. Terminals:", stpg.nro_terminals)
print("Terminals: \n", stpg.terminals)
generator = GenerateBasedRandomWalk(stpg)
evaluator = EvaluateTreeGraph(stpg)
prunner = Prunning(stpg)
prim_mutation = PrimBasedMutation(stpg)
replace_random = ReplaceByRandomEdge(stpg)
partition_cx = PartitionCrossoverSteinerTree(stpg)
output_data_dir = path.join("data", name, stpg.name)
tracker = DataTracker(parameters['runtrial'], target=output_data_dir)
population = (GPopulation(
chromosomes=[generator() for _ in range(100)],
eval_function=evaluator,
maximize=True).mutate(
mutate_function=prunner, probability=1.0).evaluate().normalize(
norm_function=normalize).callback(update_best))
evol = (Evolution().evaluate().normalize(norm_function=normalize).callback(
update_best).callback(tracker.log_evaluation).select(
selection_func=roullete).crossover(combiner=partition_cx).mutate(
mutate_function=replace_random, probability=0.3).mutate(
mutate_function=prim_mutation, probability=0.3).mutate(
mutate_function=prunner,
probability=1.0).callback(update_generation).callback(
display, every=100))
with Stagnation(interval=params["stagnation_interval"]), \
BestKnownReached(global_optimum=params['global_optimum']):
result = population.evolve(evol, n=params["n_iterations"])
tracker.log_simulation(params, stpg, result)
best_overall = result.documented_best
test, response = is_steiner_tree(best_overall.chromosome, stpg)
tracker.log_bestIndividual(best_overall, test, response)
tracker.report()
def test_evaluation_from_differents_individuals(self):
nro_individuals = 100
stpg = self.stpg
initializator = GenerateBasedRandomWalk(stpg)
evaluator = EvaluateTreeGraph(stpg)
population = [initializator() for _ in range(nro_individuals)]
pop_cost = [ evaluator(tree)[0] for tree in population ]
p_var = pvariance(pop_cost)
self.assertEqual(len(pop_cost), nro_individuals)
self.assertNotAlmostEqual(p_var, 0.0)
def test_generate_differents_individuals(self):
nro_individuals = 100
stpg = self.stpg
initialization = GenerateBasedRandomWalk(stpg)
population = [initialization() for _ in range(nro_individuals)]
self.assertEqual(len(population), nro_individuals)
c_edges = Counter((min(v, u), max(v, u))
for tree in population
for v, u in tree.gen_undirect_edges() )
self.assertFalse(all(value == 100 for value in c_edges.values()))
def test_is_it_work(self):
possibles = [f'steinb{ii}.txt' for ii in range(10, 19)]
filename = choice(possibles)
filename = path.join('datasets', 'ORLibrary', filename)
stpg = ReaderORLibrary().parser(filename)
initializer = GenerateBasedRandomWalk(stpg)
before = initializer()
mutator = ReplaceByRandomEdge(stpg)
after = mutator(before)
self.assertIsInstance(after, UGraph)
_, response = is_steiner_tree(after, stpg)
self.assertTrue(response['all_terminals_in'])
self.assertFalse(response['has_cycle'])
self.assertTrue(response['all_edges_are_reliable'])
self.assertTrue(response['graph_is_connected'])