def test_permutate_method_with_multiple_results(self):
permutator = FastColorPermutator()
aspiration_criteria = AspirationCriteria(None, None)
aspiration_criteria.is_permutation_allowed = Mock(return_value=True)
n1 = Node(color=3, node_id=3)
n2 = Node(color=3, node_id=5)
n3 = Node(color=3, node_id=7)
n4 = Node(color=3, node_id=9)
n5 = Node(color=3, node_id=10)
n1.add_edges([n2])
n2.add_edges([n1, n3])
n3.add_edges([n2, n4])
n4.add_edges([n3, n5])
n5.add_edges([n4])
permutations, best_score = permutator.permutate(
n1, [3, 4], aspiration_criteria)
self.assertEqual(-1, best_score)
self.assertEqual(3, len(permutations))
self.assertEqual(n2, permutations[0][0])
self.assertEqual(4, permutations[0][1])
self.assertEqual(n3, permutations[1][0])
self.assertEqual(4, permutations[1][1])
self.assertEqual(n4, permutations[2][0])
self.assertEqual(4, permutations[2][1])
def test_is_in_short_term_memory_method(self):
self.memory.clear_memory()
n1 = Node(1, 18)
n2 = Node(2, 33)
n3 = Node(3, 52)
n4 = Node(4, 89)
self.memory.add_to_memory(n1, 2)
n1_2_in_memory_first = self.memory.is_in_short_term_memory(n1, 2)
self.memory.add_to_memory(n2, 3)
n1_2_in_memory_second = self.memory.is_in_short_term_memory(n1, 2)
n2_3_in_memory_first = self.memory.is_in_short_term_memory(n2, 3)
self.memory.add_to_memory(n3, 4)
n1_2_in_memory_third = self.memory.is_in_short_term_memory(n1, 2)
n2_3_in_memory_second = self.memory.is_in_short_term_memory(n2, 3)
n3_4_in_memory_first = self.memory.is_in_short_term_memory(n3, 4)
self.memory.add_to_memory(n4, 1)
n1_2_in_memory_fourth = self.memory.is_in_short_term_memory(n1, 2)
n2_3_in_memory_third = self.memory.is_in_short_term_memory(n2, 3)
n3_4_in_memory_second = self.memory.is_in_short_term_memory(n3, 4)
n4_1_in_memory_first = self.memory.is_in_short_term_memory(n4, 1)
self.assertTrue(n1_2_in_memory_first)
self.assertTrue(n1_2_in_memory_second)
self.assertTrue(n2_3_in_memory_first)
self.assertTrue(n1_2_in_memory_third)
self.assertTrue(n2_3_in_memory_second)
self.assertTrue(n3_4_in_memory_first)
self.assertFalse(n1_2_in_memory_fourth)
self.assertTrue(n2_3_in_memory_third)
self.assertTrue(n3_4_in_memory_second)
self.assertTrue(n4_1_in_memory_first)
def test_clone_method(self):
n1 = Node(1, 123)
n2 = Node(2, 456)
n3 = Node(3, 789)
n4 = Node(4, 333)
n1.add_edges([n2, n3, n4])
n2.add_edges([n1, n4])
n3.add_edges([n1, n4])
n4.add_edges([n1, n2, n3])
cloned_n3 = GraphCloner.clone(n3)
cloned_n1 = cloned_n3.get_node_of_id(123)
cloned_n2 = cloned_n3.get_node_of_id(456)
cloned_n3 = cloned_n3.get_node_of_id(789)
cloned_n4 = cloned_n3.get_node_of_id(333)
self.assertNotEqual(n3, cloned_n3)
self.assertEqual(789, cloned_n3.node_id)
self.assertEqual(3, cloned_n3.color)
self.assertEqual(2, len(cloned_n3.edges))
self.assertNotEqual(n4, cloned_n4)
self.assertEqual(333, cloned_n4.node_id)
self.assertEqual(4, cloned_n4.color)
self.assertEqual(3, len(cloned_n4.edges))
self.assertNotEqual(n1, cloned_n1)
self.assertEqual(123, cloned_n1.node_id)
self.assertEqual(1, cloned_n1.color)
self.assertEqual(3, len(cloned_n1.edges))
self.assertNotEqual(n2, cloned_n2)
self.assertEqual(789, cloned_n3.node_id)
self.assertEqual(2, cloned_n2.color)
self.assertEqual(2, len(cloned_n2.edges))
def test_search_method_with_easy_substitutions(self):
search_performer = GraphColoringSearchPerformer(
StopCriteria(10, 10), 3)
n1 = Node('red')
n2 = Node('red')
n3 = Node('red')
n4 = Node('red')
n5 = Node('red')
n1.add_edges([n2, n3])
n2.add_edges([n1, n4])
n3.add_edges([n1, n4])
n4.add_edges([n2, n3, n5])
n5.add_edges([n4])
search_result = search_performer.search(n1, ['red', 'green'])
n1_in_search_result = search_result.get_node_of_id(n1.node_id)
n2_in_search_result = search_result.get_node_of_id(n2.node_id)
n3_in_search_result = search_result.get_node_of_id(n3.node_id)
n4_in_search_result = search_result.get_node_of_id(n4.node_id)
n5_in_search_result = search_result.get_node_of_id(n5.node_id)
self.assertIsNotNone(n1_in_search_result)
self.assertIsNotNone(n2_in_search_result)
self.assertIsNotNone(n3_in_search_result)
self.assertIsNotNone(n4_in_search_result)
self.assertIsNotNone(n5_in_search_result)
self.assertEqual('green', n1_in_search_result.color)
self.assertEqual('red', n2_in_search_result.color)
self.assertEqual('red', n3_in_search_result.color)
self.assertEqual('green', n4_in_search_result.color)
self.assertEqual('red', n5_in_search_result.color)
def greedy_search(self, fc_feats, att_feats, vocab, max_seq_length):
fc_feats, att_feats, p_att_feats = self._prepare_feature(
fc_feats, att_feats)
states_r, probs_r = self.from_scratch(fc_feats, att_feats)
logprob, word_idx_r = probs_r.max(dim=1)
lex_r = vocab.idx2word[word_idx_r.item()]
word_idx_r = torch.LongTensor([word_idx_r])
node_r = TensorNode(Node(lex_r, 1, ""))
node_r.word_idx = word_idx_r
node_r.h = states_r
node_r.logprob = logprob.item()
tree = Tree()
tree.root = node_r
tree.nodes.update({node_r.idx - 1: node_r})
queue = Queue()
queue.put(tree.root)
# print(tree.root.lex)
while not queue.empty() and len(tree.nodes) <= max_seq_length:
node = queue.get()
if node.lex == '<EOB>':
continue
idx = len(tree.nodes) + 1
lc = TensorNode(Node("", idx, ""))
lc.parent = node
self.complete_node(lc, vocab, att_feats, p_att_feats)
node.lc = lc
lc.depth = node.depth + 1
mc = TensorNode(Node("", idx + 1, ""))
mc.parent = node
mc.left_brother = lc
self.complete_node(mc, vocab, att_feats, p_att_feats)
node.mc = mc
mc.depth = node.depth + 1
lc.right_brother = mc
rc = TensorNode(Node("", idx + 2, ""))
rc.parent = node
rc.left_brother = mc
self.complete_node(rc, vocab, att_feats, p_att_feats)
node.rc = rc
rc.depth = node.depth + 1
mc.right_brother = rc
tree.nodes.update({lc.idx - 1: lc})
tree.nodes.update({mc.idx - 1: mc})
tree.nodes.update({rc.idx - 1: rc})
queue.put(lc)
queue.put(mc)
queue.put(rc)
return tree
def test_permutate_method(self):
n1 = Node(1, node_id=1)
n2 = Node(2, node_id=2)
n3 = Node(3, node_id=3)
n1.add_edges([n2])
n2.add_edges([n3])
n3.add_edges([n1])
permutations = self.color_permutator.permutate(n1, [1, 2, 3])
self.assertEqual(6, len(permutations))
self.assertEqual(2, permutations[0].get_node_of_id(1).color)
self.assertEqual(1, permutations[0].get_node_of_id(1).previous_color)
self.assertEqual(2, permutations[0].get_node_of_id(2).color)
self.assertEqual(2, permutations[0].get_node_of_id(2).previous_color)
self.assertEqual(3, permutations[0].get_node_of_id(3).color)
self.assertEqual(3, permutations[0].get_node_of_id(3).previous_color)
self.assertEqual(3, permutations[1].get_node_of_id(1).color)
self.assertEqual(1, permutations[1].get_node_of_id(1).previous_color)
self.assertEqual(2, permutations[1].get_node_of_id(2).color)
self.assertEqual(2, permutations[1].get_node_of_id(2).previous_color)
self.assertEqual(3, permutations[1].get_node_of_id(3).color)
self.assertEqual(3, permutations[1].get_node_of_id(3).previous_color)
self.assertEqual(1, permutations[2].get_node_of_id(1).color)
self.assertEqual(1, permutations[2].get_node_of_id(1).previous_color)
self.assertEqual(1, permutations[2].get_node_of_id(2).color)
self.assertEqual(2, permutations[2].get_node_of_id(2).previous_color)
self.assertEqual(3, permutations[2].get_node_of_id(3).color)
self.assertEqual(3, permutations[2].get_node_of_id(3).previous_color)
self.assertEqual(1, permutations[3].get_node_of_id(1).color)
self.assertEqual(1, permutations[3].get_node_of_id(1).previous_color)
self.assertEqual(3, permutations[3].get_node_of_id(2).color)
self.assertEqual(2, permutations[3].get_node_of_id(2).previous_color)
self.assertEqual(3, permutations[3].get_node_of_id(3).color)
self.assertEqual(3, permutations[3].get_node_of_id(3).previous_color)
self.assertEqual(1, permutations[4].get_node_of_id(1).color)
self.assertEqual(1, permutations[4].get_node_of_id(1).previous_color)
self.assertEqual(2, permutations[4].get_node_of_id(2).color)
self.assertEqual(2, permutations[4].get_node_of_id(2).previous_color)
self.assertEqual(1, permutations[4].get_node_of_id(3).color)
self.assertEqual(3, permutations[4].get_node_of_id(3).previous_color)
self.assertEqual(1, permutations[5].get_node_of_id(1).color)
self.assertEqual(1, permutations[5].get_node_of_id(1).previous_color)
self.assertEqual(2, permutations[5].get_node_of_id(2).color)
self.assertEqual(2, permutations[5].get_node_of_id(2).previous_color)
self.assertEqual(2, permutations[5].get_node_of_id(3).color)
self.assertEqual(3, permutations[5].get_node_of_id(3).previous_color)
def test_color_classes_method(self):
n1 = Node(color='#')
n2 = Node(color='*')
n3 = Node(color='#')
n4 = Node(color='$')
n1.add_edges([n2, n3, n4])
n2.add_edges([n1, n3, n4])
n3.add_edges([n1, n2, n4])
n4.add_edges([n1, n2, n3])
color_classes = n1.get_colors_count()
self.assertEqual(3, color_classes)
def test_node_count_method(self):
n1 = Node('a')
n2 = Node('b')
n3 = Node('c')
n4 = Node('d')
n5 = Node('e')
n1.add_edges([n2, n5])
n2.add_edges([n3])
n3.add_edges([n4])
node_count = n1.node_count()
self.assertEqual(node_count, 5)
def process_core(self, part, node_map, all_nodes, edges, d):
from_nodes = []
to_node = None
for source in d['sources']:
self.upsert_node(
node_map, source) # first, check and upsert if not in node_map
from_nodes.append(node_map[source])
if source.startswith('MODULE_'):
self.connect_module_params(node_map, all_nodes,
edges, node_map[source],
d.get('params', []))
if '.' in source:
main_node_name = source.split('.')[0]
if main_node_name in node_map:
edges.append(
Edge(node_map[main_node_name], node_map[source]))
if len(from_nodes) == 0:
from_nodes.append(node_map['last_node'])
if d['assign_var']:
attr = {}
node_name = d['assign_var']
if node_name in node_map:
attr = node_map[node_name].attr
# for those like PROCESS ... USING
if 'using' in d:
attr['using'] = d['using']
new_node = Node(node_name, attr=attr)
node_map[node_name] = new_node # update
to_node = new_node
else:
if not node_map['last_node']:
new_node = Node("SCOPE_IMPLICIT")
to_node = new_node
else:
to_node = node_map['last_node']
for from_node in from_nodes:
edges.append(Edge(from_node, to_node))
all_nodes.append(from_node)
all_nodes.append(to_node)
node_map['last_node'] = to_node
def test_evaluate_method(self):
r1 = Node('red')
r2 = Node('red')
r3 = Node('red')
b1 = Node('blue')
b2 = Node('blue')
g1 = Node('green')
g2 = Node('green')
g3 = Node('green')
r1.add_edges([g1, r2, b2])
r2.add_edges([r1, r3, b2])
r3.add_edges([r2, b1, g2])
b1.add_edges([r3])
b2.add_edges([r1, r2, g1, g3])
g1.add_edges([r1, b2])
g2.add_edges([r3, g3])
g3.add_edges([g2, b2])
evaluated_cost_r1 = CostEvaluator.evaluate(r1,
['red', 'blue', 'green'])
evaluated_cost_g3 = CostEvaluator.evaluate(g3,
['blue', 'red', 'green'])
self.assertEqual(evaluated_cost_r1, evaluated_cost_g3)
self.assertEqual(-4, evaluated_cost_r1)
def test_is_graph_connected_method_positive(self):
n1 = Node()
n2 = Node()
n3 = Node()
n1.add_edges([n2, n3])
n2.add_edges([n1])
n3.add_edges([n1])
n1_graph_connected = ConnectionValidator.is_graph_connected(n1, 3)
n2_graph_connected = ConnectionValidator.is_graph_connected(n2, 3)
n3_graph_connected = ConnectionValidator.is_graph_connected(n3, 3)
self.assertTrue(n1_graph_connected)
self.assertTrue(n2_graph_connected)
self.assertTrue(n3_graph_connected)
def test_evaluate_method_second(self):
n1 = Node('red')
n2 = Node('green')
n3 = Node('green')
n4 = Node('red')
n5 = Node('red')
n1.add_edges([n2, n3])
n2.add_edges([n1, n4])
n3.add_edges([n1, n4])
n4.add_edges([n2, n3, n5])
n5.add_edges([n4])
evaluated_cost = CostEvaluator.evaluate(n1, ['red', 'green'])
self.assertEqual(-7, evaluated_cost)
def expand_node(self, nodeframes):
real_children = set()
for child in self.children:
real_children.add(nodeframes[child].expand_node(nodeframes))
return Node(self.name, self.type, real_children, self.neighbors,
self.checks, self.fixes, self.states, self.args,
self.grouping)
def collate_fn(batch):
if len(batch[0]) == 3:
fc_feat, att_feat, trees = zip(*batch)
fc_feat, att_feat = torch.from_numpy(np.stack(
fc_feat, axis=0)), torch.from_numpy(np.stack(att_feat, axis=0))
feats = (fc_feat, att_feat)
elif len(batch[0]) == 2:
fc_feat, trees = zip(*batch)
fc_feat = torch.from_numpy(np.stack(fc_feat, axis=0))
feats = (fc_feat, )
else:
raise ValueError
root_lex = [tree.root.lex for tree in trees]
root_lex = '(' + ' '.join(root_lex) + ')'
root_node = TensorNode(Node(root_lex, 1, ""))
root_node.word_idx = torch.from_numpy(
np.stack([tree.root.word_idx for tree in trees], axis=0))
batch_tree = Tree()
batch_tree.root = root_node
batch_tree.nodes.update({0: root_node})
batch_tree_pad([n.root for n in trees], root_node, batch_tree)
batch_tree.update()
return feats + (batch_tree, )
def test_set_color_method(self):
n1 = Node(color='#')
n1.set_color('?')
self.assertEqual('?', n1.color)
self.assertEqual('#', n1.previous_color)
def getSuccessors(
self: JPS,
state: Node,
goal: Node,
grid: Map,
k: int,
) -> list:
disallowed = self.getDisallowedDirections(state)
successors = [
self.getJumpPoint(state.i, state.j, delta[0], delta[1], goal, grid)
for delta in grid.getAllowedMovements(state.i, state.j)
if delta not in disallowed
]
nodes = [
Node(
i = successor[0],
j = successor[1],
h = self.h_func(successor[0], successor[1], goal.i, goal.j),
parent = state,
k = k,
)
for successor in successors
if successor is not None
]
return nodes
def test_add_edges(self, w_graph):
n6 = Node(6)
w_graph.add_node(n6)
w_graph.add_edge(5, 6)
n5 = w_graph.get_by_idx(5)
assert n6 in w_graph[n5]
assert n5 not in w_graph[n6]
def upsert_node(self, node_map, node_name):
if node_name not in node_map:
self.logger.info(
'cannot find node [{}]! Probably source node.'.format(
node_name))
node_map[node_name] = Node(node_name)
def __init__(self,
num_nodes=10,
directed=False,
weighted=False,
num_cycles=0):
'''
:param num_nodes: the number of nodes to include in the graph
:param directed: True if the graph is directed, False otherwise
:param weighted: True if the graph is weighted, False otherwise
:param cycles: True if the graph has cycles, False otherwise
every node will have between 1 and 3 other edges
'''
if num_nodes <= 0:
raise ValueError("must enter a number of nodes >= 1")
self._directed = directed
self._weighted = weighted
self._num_cycles = num_cycles
self._graph = []
available = []
# default node domain is integers from 0...num_nodes
node_domain = [x for x in range(num_nodes)]
for x in sample(node_domain, num_nodes):
available.append(Node(x))
self._generate_graph(available)
if num_cycles > 0:
self._set_cycles(num_cycles)
def test_get_node_of_id_method(self):
n1 = Node(node_id=8)
n2 = Node(node_id=9)
n3 = Node(node_id=12)
n4 = Node(node_id=1)
n5 = Node(node_id=88)
n1.add_edges([n5, n3])
n2.add_edges([n4])
n3.add_edges([n2, n1])
n4.add_edges([n1, n5])
self.assertEqual(n1, n1.get_node_of_id(8))
self.assertEqual(n2, n1.get_node_of_id(9))
self.assertEqual(n3, n1.get_node_of_id(12))
self.assertEqual(n4, n1.get_node_of_id(1))
self.assertEqual(n5, n1.get_node_of_id(88))
def push(self, value):
'''
push method to add element to stack
'''
node = Node(value)
node.next = self.top
self.top = node
def setNodesFromValuesAndConnections(
self, values: list[T],
connectionsPointers: list[list[int]]) -> None:
"""Give a Tree object some nodes.
Args:
values (List[T]): the value of each node.
connectionsPointers (List[List[int]]): the connections that each node has.
Setting a graph's nodes from provided data and connections:
>>> maze = Graph[None]()
>>> maze.setNodesFromValuesAndConnections([
... None,
... None,
... None,
... None,
... None,
... ], [
... [1, 4],
... [0, 4],
... [4, 3],
... [2, 4],
... [0, 1, 2, 3]
... ])
>>> maze
['None -> [1, 4]', 'None -> [0, 4]', 'None -> [4, 3]', 'None -> [2, 4]', 'None -> [0, 1, 2, 3]']
"""
for index, thisValue in enumerate(values):
# make new `Node` with this value's data and left and right pointers
thisNode: Node[T] = Node(data=thisValue,
connections=connectionsPointers[index])
self.__nodes.append(thisNode) # append new node to `self.nodes`
def __a_star(v, u, queue):
""" Runs the A* algorithm
:param v: the current node
:param u: the parent node
:param queue: the current run's priority queue
"""
queue.put(Node(v, parent=u, heuristics=True))
def __uniform_cost(v, u, queue):
"""" Runs the uniform cost algorithm
:param v: the current node
:param u: the parent node
:param queue: the current run's priority queue
"""
queue.put(Node(v, parent=u, heuristics=False))
def create_node(idx, lex, word_idx, h, depth):
node = TensorNode(Node(lex, idx, ""))
node.label = lex + '-' + str(idx)
node.word_idx = word_idx.clone()
node.h = (h[0].clone(), h[1].clone())
node.depth = depth
return node
def clone_nodes(root_node):
cloned_nodes = {}
for node in root_node.iterator():
cloned_node = Node(node.color, node.node_id)
cloned_nodes[node] = cloned_node
return cloned_nodes
def read_input_graph_and_color_set(self, file_name):
self.reset_input()
with open(file_name, 'r') as graph_file:
for line in graph_file:
if len(line) > 0:
first_character = line.strip()[0]
if first_character == 'p':
match_result = re.match('p edge (\d+) (\d+)',
line.strip())
if match_result is not None:
nodes = int(match_result.groups()[0])
self.color_set = range(0, nodes)
else:
raise IOError('Invalid input format!')
elif first_character == 'e':
match_result = re.match('e (\d+) (\d+)', line.strip())
if match_result is not None:
first_edge_id, second_edge_id = match_result.groups(
)[0], match_result.groups()[1]
if first_edge_id not in self.id_to_note_mapping:
self.id_to_note_mapping[first_edge_id] = Node(
color=random.choice(self.color_set),
node_id=first_edge_id)
if second_edge_id not in self.id_to_note_mapping:
self.id_to_note_mapping[second_edge_id] = Node(
color=random.choice(self.color_set),
node_id=second_edge_id)
else:
raise IOError('Invalid input format!')
self.edge_ids.append([first_edge_id, second_edge_id])
if len(self.id_to_note_mapping) == 0:
raise Exception('Invalid input format!')
for edge in self.edge_ids:
self.id_to_note_mapping[edge[0]].add_edges(
[self.id_to_note_mapping[edge[1]]])
return self.id_to_note_mapping.items()[0][1], self.color_set
def find_latest_node(self, target_name, nodes):
for node in nodes[::-1]:
if node.name == target_name:
return node
self.logger.warning(
'cannot find node [{}]! Probably source node.'.format(target_name))
return Node(target_name)
def test_permutate_method_with_single_result(self):
permutator = FastColorPermutator()
aspiration_criteria = AspirationCriteria(None, None)
aspiration_criteria.is_permutation_allowed = Mock(return_value=True)
n1 = Node(color=0, node_id=10)
n2 = Node(color=0, node_id=20)
n3 = Node(color=0, node_id=30)
n1.add_edges([n2])
n2.add_edges([n1, n3])
n3.add_edges([n2])
permutations, best_score = permutator.permutate(
n1, [0, 7], aspiration_criteria)
self.assertEqual(-5, best_score)
self.assertEqual(1, len(permutations))
self.assertEqual(n2, permutations[0][0])
self.assertEqual(7, permutations[0][1])
def test_get_best_score_for_iteration_method_with_long_term_memory_usage(
self):
search_performer = GraphColoringSearchPerformer(
StopCriteria(10, 10), 2)
n1 = Node(1, 2)
n2 = Node(1, 5)
n3 = Node(1, 8)
search_performer.memory.add_to_memory(n1, 2)
search_performer.memory.add_to_memory(n2, 3)
search_performer.memory.add_to_memory(n3, 4)
search_performer.memory.add_to_memory(n1, 5)
search_performer.memory.add_to_memory(n3, 6)
search_performer.memory.add_to_memory(n1, 7)
best_score_for_iteration = search_performer.get_best_permutation_for_iteration(
[(n1, 3), (n2, 3), (n3, 3)])
self.assertEqual(3, best_score_for_iteration[1])
self.assertEqual(n2, best_score_for_iteration[0])