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_basic(self):
filename = path.join("datasets", "ORLibrary", "steinc5.txt")
stpg = ReaderORLibrary().parser(filename)
vertices = list(stpg.graph.vertices)
v, u = sample(vertices, 2)
crossover = PXTree(stpg)
evaluator = EvaluateTreeGraph(stpg)
red, red_cost = shortest_path_with_origin(stpg.graph, v,
stpg.terminals)
blue, blue_cost = shortest_path_with_origin(stpg.graph, u,
stpg.terminals)
child = crossover(red, blue)
child_cost, _ = evaluator(child)
self.assertLessEqual(child_cost, red_cost)
self.assertLessEqual(child_cost, blue_cost)
_, 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'])
self.assertTrue(response['all_leaves_are_terminals'])
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_best_solution_is_steiner_tree(self):
filename = path.join('datasets', 'ORLibrary', 'steinb1.txt')
stpg = ReaderORLibrary().parser(filename)
coder = Coder(stpg)
chromosome = "00000010000000001011000110001100010100010"
subgraph = coder.binary2treegraph(chromosome)
result, _ = is_steiner_tree(subgraph, stpg)
self.assertTrue(result)
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(simulation_name, params):
datasets_folder = path.join("datasets", "ORLibrary")
filename = path.join(datasets_folder, params["dataset"])
STPG = ReaderORLibrary().parser(filename)
print("STPG information", '\n', 10 * '- ', '\n')
print("Trial: ", parameters['runtrial'])
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)
output_folder = path.join("data", simulation_name, STPG.name)
tracker = DataTracker(params['runtrial'], target=output_folder)
generator = GenerateBasedPrimRST(STPG)
evaluator = EvaluateTreeGraph(STPG)
crossover = CrossoverPrimRST(STPG)
prunner = Prunning(STPG)
mut_prim = PrimBasedMutation(STPG)
replace_random = ReplaceByRandomEdge(STPG)
population = (GPopulation(
chromosomes=[generator() for _ in range(params["population_size"])],
eval_function=evaluator,
maximize=True).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=crossover).mutate(
mutate_function=replace_random, probability=0.2).mutate(
mutate_function=mut_prim, probability=0.2).mutate(
mutate_function=prunner,
probability=0.2).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_is_steiner_tree(self):
stpg = self.stpg
chromosome = gen_random_kruskal(stpg)
tree = UGraph()
for edge in chromosome:
v, u = edge
tree.add_edge(v, u)
_, 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 __call__(self, population: Population):
best_solution = population.documented_best
if (best_solution is not None
and best_solution.cost == self.global_optimum):
if self.is_to_use_decoder_function:
steiner_tree = self.decoder(best_solution.chromosome)
else:
steiner_tree = best_solution.chromosome
result, _ = is_steiner_tree(steiner_tree, self.STPG)
if result:
raise StopEvolution("BestKnownSteinerTreeReached")
def test_if_is_it_a_tree(self):
filename = path.join('datasets', 'ORLibrary', 'steinb15.txt')
stpg = ReaderORLibrary().parser(filename)
crossover = CrossoverKruskalRST(stpg)
parent_a = gen_random_walk(stpg)
parent_b = gen_random_walk(stpg)
offspring = crossover(parent_a, parent_b)
tree = UGraph()
for edge in offspring:
u, v = edge[0], edge[1]
tree.add_edge(u, v)
_, 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 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'])
def test_exchange_edges(self):
filename = path.join('tests', 'data', 'test3.txt')
stpg = ReaderORLibrary().parser(filename)
red = UGraph()
edges = [(1, 3), (3, 8), (8, 5), (5, 6)]
for edge in edges:
red.add_edge(edge[0], edge[1])
blue = UGraph()
edges = [(1, 3), (3, 8), (3, 7), (7, 4), (4, 6)]
for edge in edges:
blue.add_edge(edge[0], edge[1])
crossover = PXTree(stpg)
child = crossover(red, blue)
_, 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'])
self.assertTrue(response['all_leaves_are_terminals'])
def test_simpliest(self):
stpg = self.stpg
mutate = MutationReplaceByRandomEdge(stpg)
after = gen_random_prim(stpg)
self.assertIsInstance(after, EdgeSet)
before = mutate(after)
self.assertIsInstance(before, EdgeSet)
tree = UGraph()
for edge in before:
v, u = edge
tree.add_edge(v, u)
_, 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'])
