def convert_bpmn_to_process_hgraph(bpmn_file_name):
'''
Convert a bpmn model into a hypergraph
UNTESTED AND TO BE COMPLETED: DO NOT USE
:param bpmn_file_name: file containing the BPMN xml
'''
hyperg = DirectedHypergraph()
#namespace
ns = {'bpmn': 'http://www.omg.org/spec/BPMN/20100524/MODEL'}
#parse bpmn file
tree = ET.parse(bpmn_file_name)
bpmndiagram = tree.getroot()
#parse process
processes = bpmndiagram.findall("./bpmn:process", ns)
for process in processes:
#pick start event
starts = bpmndiagram.findall("./bpmn:process/bpmn:startEvent", ns)
for start in starts:
hyperg.add_node(start.attrib['id'],
name=start.attrib['name'],
cost=0.1,
qual=0.1,
avail=0.1,
time=0.1)
#logger.info(get_tag(start))
visited = []
hyperg = inspect_task(start, hyperg, bpmndiagram, [])
print_hg_std_out_only(hyperg)
return hyperg
def test_get_hyperedge_attributes():
node_a = 'A'
node_b = 'B'
node_c = 'C'
node_d = 'D'
tail = set([node_a, node_b])
head = set([node_c, node_d])
frozen_tail = frozenset(tail)
frozen_head = frozenset(head)
attrib = {'weight': 6, 'color': 'black'}
H = DirectedHypergraph()
H.add_node(node_a, label=1337)
hyperedge_name = H.add_hyperedge(tail, head, attrib, weight=5)
assert H.get_hyperedge_attributes(hyperedge_name) == \
{'tail': tail, 'head': head, 'weight': 5, 'color': 'black'}
# Test getting non-existent hyperedge's attributes
try:
H.get_hyperedge_attributes("e10")
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def reset_pheromone(hg):
'''
Reset the pheromone level to a default (0.5)
:param hg:
'''
hg_copy = DirectedHypergraph()
for edge in hg.get_hyperedge_id_set():
#hg_copy = hg.copy()
PHERO_DEFAULT = 0.5
head_edge = hg.get_hyperedge_head(edge)
#head_edge = ast.literal_eval(head_edge)
#print(head_edge)
for head_node in head_edge:
#print(head_node)
attrs = hg.get_node_attributes(head_node)
hg_copy.add_node(head_node, attrs)
tail_edge = hg.get_hyperedge_tail(edge)
#tail_edge = ast.literal_eval(tail_edge)
for tail_node in tail_edge:
attrs = hg.get_node_attributes(tail_node)
hg_copy.add_node(tail_node, attrs)
hg_copy.add_hyperedge(tail_edge,
head_edge,
phero=PHERO_DEFAULT,
id=edge,
name=edge)
return hg_copy
def test_get_hyperedge_attributes():
node_a = 'A'
node_b = 'B'
node_c = 'C'
node_d = 'D'
tail = set([node_a, node_b])
head = set([node_c, node_d])
frozen_tail = frozenset(tail)
frozen_head = frozenset(head)
attrib = {'weight': 6, 'color': 'black'}
H = DirectedHypergraph()
H.add_node(node_a, label=1337)
hyperedge_name = H.add_hyperedge(tail, head, attrib, weight=5)
assert H.get_hyperedge_attributes(hyperedge_name) == \
{'tail': tail, 'head': head, 'weight': 5, 'color': 'black'}
# Test getting non-existent hyperedge's attributes
try:
H.get_hyperedge_attributes("e10")
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def from_networkx_digraph(nx_digraph):
"""Returns a DirectedHypergraph object that is the graph equivalent of the
given NetworkX DiGraph object.
:param nx_digraph: the NetworkX directed graph object to transform.
:returns: DirectedHypergraph -- hypergraph object equivalent to the
NetworkX directed graph.
:raises: TypeError -- Transformation only applicable to directed
NetworkX graphs
"""
import networkx as nx
if not isinstance(nx_digraph, nx.DiGraph):
raise TypeError("Transformation only applicable to directed \
NetworkX graphs")
G = DirectedHypergraph()
for node in nx_digraph.nodes_iter():
G.add_node(node, copy.copy(nx_digraph.node[node]))
for edge in nx_digraph.edges_iter():
tail_node = edge[0]
head_node = edge[1]
G.add_hyperedge(tail_node,
head_node,
copy.copy(nx_digraph[tail_node][head_node]))
return G
def random_generate_hg(level_size, block_size_min, block_size_max):
'''
Generate a random hypergraph
:param level_size: number of rewriting levels (at each level an 'and' or 'xor' block is randomly chosen for rewriting)
:param block_size: min size of a block (number of branches)
:param block_size: max size of a block (number of branches)
'''
hg = DirectedHypergraph()
# create source and sink nodes
source_attrs = generate_random_node_attributes()
source_attrs['source'] = True
sink_attrs = generate_random_node_attributes()
sink_attrs['sink'] = True
source = 'source'
hg.add_node(source, source_attrs)
sink = 'sink'
hg.add_node(sink, sink_attrs)
edge_attrs = {'phero' : 0.5}
source_list = []
sink_list = []
source_list.append(source)
sink_list.append(sink)
hg.add_hyperedge(source_list, sink_list, edge_attrs)
node_start_list = source_list
node_end_list = sink_list
# add 1 node
node_middle = generate_random_node_list(hg, 1)
hg.add_hyperedge(source_list, node_middle, edge_attrs)
hg.add_hyperedge(node_middle, sink_list, edge_attrs)
hg.remove_hyperedge(hg.get_hyperedge_id(source_list, sink_list))
#print_hg_std_out_only(hg)
# add one xor block
#hg = rewrite_xor_block(hg, node_middle[0], 2)[0]
#hg = rewrite_and_block(hg, node_middle[0], 4)[0]
#print_hg_std_out_only(hg)
# generation of test hypergraph
current_node = node_middle[0]
SIZE = level_size
for i in range(0, SIZE, 1):
size = randint(block_size_min, block_size_max) # pick size randomly
if uniform(0,1) > 0.5: # make an and block
out = rewrite_and_block(hg, current_node, size)
hg, current_node = out[0], out[1]
else: # make a xor block
out = rewrite_xor_block(hg, current_node, size)
hg, current_node = out[0], out[1]
#print_hg_std_out_only(hg)
return hg
def from_networkx_digraph(nx_digraph):
"""Returns a DirectedHypergraph object that is the graph equivalent of the
given NetworkX DiGraph object.
:param nx_digraph: the NetworkX directed graph object to transform.
:returns: DirectedHypergraph -- hypergraph object equivalent to the
NetworkX directed graph.
:raises: TypeError -- Transformation only applicable to directed
NetworkX graphs
"""
import networkx as nx
if not isinstance(nx_digraph, nx.DiGraph):
raise TypeError("Transformation only applicable to directed \
NetworkX graphs")
G = DirectedHypergraph()
for node in nx_digraph.nodes():
G.add_node(node, **copy.copy(nx_digraph.nodes[node]))
for edge in nx_digraph.edges():
tail_node = edge[0]
head_node = edge[1]
G.add_hyperedge(tail_node, head_node,
copy.copy(nx_digraph[tail_node][head_node]))
return G
def test_returns_hyperpath_containing_source_if_source_equals_destination(
self):
s = '1'
T = {s: None}
H = DirectedHypergraph()
H.add_node(s)
path = directed_paths.get_hyperpath_from_predecessors(H, T, s, s)
self.assertTrue(path.has_node(s))
def test_returns_hyperpath_containing_source_if_source_equals_destination(
self):
s = '1'
T = {s: None}
H = DirectedHypergraph()
H.add_node(s)
path = directed_paths.get_hyperpath_from_predecessors(H, T, s, s)
self.assertTrue(path.has_node(s))
def test_returns_hyperpath_with_single_node_if_source_equals_destination(
self):
s = '1'
T = {s: None}
H = DirectedHypergraph()
H.add_node(s)
path = directed_paths.get_hyperpath_from_predecessors(H, T, s, s)
self.assertEqual(len(path.get_node_set()), 1)
self.assertEqual(len(path.get_hyperedge_id_set()), 0)
def test_returns_hyperpath_with_single_node_if_source_equals_destination(
self):
s = '1'
T = {s: None}
H = DirectedHypergraph()
H.add_node(s)
path = directed_paths.get_hyperpath_from_predecessors(H, T, s, s)
self.assertEqual(len(path.get_node_set()), 1)
self.assertEqual(len(path.get_hyperedge_id_set()), 0)
def test_returns_disconnected_nodes_on_graph_with_two_nodes(self):
H = DirectedHypergraph()
s, t = 's', 't'
H.add_node(s)
H.add_node(t)
e1 = H.add_hyperedge({s}, {t})
predecessor = {s: None, t: e1}
ordering = [s, t]
branch = ksh._branching_step(H, predecessor, ordering)[0]
self.assertEqual(branch.get_hyperedge_id_set(), set([]))
self.assertEqual(branch.get_node_set(), {'s', 't'})
def test_returns_disconnected_nodes_on_graph_with_two_nodes(self):
H = DirectedHypergraph()
s, t = 's', 't'
H.add_node(s)
H.add_node(t)
e1 = H.add_hyperedge({s}, {t})
predecessor = {s: None, t: e1}
ordering = [s, t]
branch = ksh._branching_step(H, predecessor, ordering)[0]
self.assertEqual(branch.get_hyperedge_id_set(), set([]))
self.assertEqual(branch.get_node_set(), {'s', 't'})
def test_returns_empty_list_if_no_s_t_path(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'1', '2'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(output, [])
def test_returns_empty_list_if_no_s_t_path(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'1', '2'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(output, [])
def test_add_hyperedge():
node_a = 'A'
node_b = 'B'
node_c = 'C'
node_d = 'D'
tail = set([node_a, node_b])
head = set([node_c, node_d])
frozen_tail = frozenset(tail)
frozen_head = frozenset(head)
attrib = {'weight': 6, 'color': 'black'}
H = DirectedHypergraph()
H.add_node(node_a, label=1337)
hyperedge_name = H.add_hyperedge(tail, head, attrib, weight=5)
assert hyperedge_name == 'e1'
# Test that all hyperedge attributes are correct
assert H._hyperedge_attributes[hyperedge_name]['tail'] == tail
assert H._hyperedge_attributes[hyperedge_name]['head'] == head
assert H._hyperedge_attributes[hyperedge_name]['weight'] == 5
assert H._hyperedge_attributes[hyperedge_name]['color'] == 'black'
# Test that successor list contains the correct info
assert frozen_head in H._successors[frozen_tail]
assert hyperedge_name in H._successors[frozen_tail][frozen_head]
# Test that the precessor list contains the correct info
assert frozen_tail in H._predecessors[frozen_head]
assert hyperedge_name in H._predecessors[frozen_head][frozen_tail]
# Test that forward-stars and backward-stars contain the correct info
for node in frozen_tail:
assert hyperedge_name in H._forward_star[node]
for node in frozen_head:
assert hyperedge_name in H._backward_star[node]
# Test that adding same hyperedge will only update attributes
new_attrib = {'weight': 10}
H.add_hyperedge(tail, head, new_attrib)
assert H._hyperedge_attributes[hyperedge_name]['weight'] == 10
assert H._hyperedge_attributes[hyperedge_name]['color'] == 'black'
try:
H.add_hyperedge(set(), set())
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def trim(H, F, e, source, taildistancelist):
'''
Takes the edge list F, which is a super path from the source vertex to e and repeatedly removes an edge and checks reachability for each edge in F
Returns the trimmed edge list and prints that the sink is not reachable from the source if the original edge set is not a superpath
'''
sortededges = []
if e[0] != 'e':
reachingset = [e]
else:
reachingset = H.get_hyperedge_tail(e)
for f in F:
sortededges.append((taildistancelist[f], f))
sortededges.sort()
justedges = [s[1] for s in sortededges]
H2 = DirectedHypergraph()
H2.add_node(source)
H2edgeids = {}
for f in justedges:
newf = H2.add_hyperedge(H.get_hyperedge_tail(f),
H.get_hyperedge_head(f))
H2edgeids[f] = newf
nodeset, _, __, ___ = b_visit(H2, source)
isereached = True
for v in reachingset:
if v not in nodeset:
isereached = False
if isereached == False:
print('invalid edge set given to trim. Sink not reachable from source')
print(nodeset)
F2 = []
tailedges = []
for f in justedges:
H2.remove_hyperedge(H2edgeids[f])
nodeset, _, __, ___ = b_visit(H2, source)
isereached = True
for v in reachingset:
if v not in nodeset:
isereached = False
if isereached == False:
#This means we cannot remove f
newf = H2.add_hyperedge(H.get_hyperedge_tail(f),
H.get_hyperedge_head(f))
H2edgeids[f] = newf
F2.append(f)
if e[0] == 'e':
for v in H.get_hyperedge_tail(e):
if v in H.get_hyperedge_head(f):
tailedges.append(f)
if e[0] == 'e':
F2.append(e)
return F2, tailedges
def test_add_hyperedge():
node_a = 'A'
node_b = 'B'
node_c = 'C'
node_d = 'D'
tail = set([node_a, node_b])
head = set([node_c, node_d])
frozen_tail = frozenset(tail)
frozen_head = frozenset(head)
attrib = {'weight': 6, 'color': 'black'}
H = DirectedHypergraph()
H.add_node(node_a, label=1337)
hyperedge_name = H.add_hyperedge(tail, head, attrib, weight=5)
assert hyperedge_name == 'e1'
# Test that all hyperedge attributes are correct
assert H._hyperedge_attributes[hyperedge_name]['tail'] == tail
assert H._hyperedge_attributes[hyperedge_name]['head'] == head
assert H._hyperedge_attributes[hyperedge_name]['weight'] == 5
assert H._hyperedge_attributes[hyperedge_name]['color'] == 'black'
# Test that successor list contains the correct info
assert frozen_head in H._successors[frozen_tail]
assert hyperedge_name in H._successors[frozen_tail][frozen_head]
# Test that the precessor list contains the correct info
assert frozen_tail in H._predecessors[frozen_head]
assert hyperedge_name in H._predecessors[frozen_head][frozen_tail]
# Test that forward-stars and backward-stars contain the correct info
for node in frozen_tail:
assert hyperedge_name in H._forward_star[node]
for node in frozen_head:
assert hyperedge_name in H._backward_star[node]
# Test that adding same hyperedge will only update attributes
new_attrib = {'weight': 10}
H.add_hyperedge(tail, head, new_attrib)
assert H._hyperedge_attributes[hyperedge_name]['weight'] == 10
assert H._hyperedge_attributes[hyperedge_name]['color'] == 'black'
try:
H.add_hyperedge(set(), set())
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def test_get_node_attributes():
node_a = 'A'
node_b = 'B'
node_c = 'C'
attrib_c = {'alt_name': 1337}
node_d = 'D'
attrib_d = {'label': 'black', 'sink': True}
# Test adding unadded nodes with various attribute settings
H = DirectedHypergraph()
H.add_node(node_a)
H.add_node(node_b, source=True)
H.add_node(node_c, attrib_c)
H.add_node(node_d, attrib_d, sink=False)
assert H.get_node_attributes(node_a) == {}
assert H.get_node_attributes(node_d) == {'label': 'black', 'sink': False}
# Test getting non-existent node's attributes
try:
H.get_node_attributes("X")
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def test_get_node_attributes():
node_a = 'A'
node_b = 'B'
node_c = 'C'
attrib_c = {'alt_name': 1337}
node_d = 'D'
attrib_d = {'label': 'black', 'sink': True}
# Test adding unadded nodes with various attribute settings
H = DirectedHypergraph()
H.add_node(node_a)
H.add_node(node_b, source=True)
H.add_node(node_c, attrib_c)
H.add_node(node_d, attrib_d, sink=False)
assert H.get_node_attributes(node_a) == {}
assert H.get_node_attributes(node_d) == {'label': 'black', 'sink': False}
# Test getting non-existent node's attributes
try:
H.get_node_attributes("X")
assert False
except ValueError:
pass
except BaseException as e:
assert False, e
def test_add_node():
node_a = 'A'
node_b = 'B'
node_c = 'C'
attrib_c = {'alt_name': 1337}
node_d = 'D'
attrib_d = {'label': 'black', 'sink': True}
# Test adding unadded nodes with various attribute settings
H = DirectedHypergraph()
H.add_node(node_a)
H.add_node(node_b, source=True)
H.add_node(node_c, attrib_c)
H.add_node(node_d, attrib_d, sink=False)
assert node_a in H._node_attributes
assert H._node_attributes[node_a] == {}
assert node_b in H._node_attributes
assert H._node_attributes[node_b]['source'] is True
assert node_c in H._node_attributes
assert H._node_attributes[node_c]['alt_name'] == 1337
assert node_d in H._node_attributes
assert H._node_attributes[node_d]['label'] == 'black'
assert H._node_attributes[node_d]['sink'] is False
# Test adding a node that has already been added
H.add_nodes(node_a, common=False)
assert H._node_attributes[node_a]['common'] is False
# Pass in bad (non-dict) attribute
try:
H.add_node(node_a, ["label", "black"])
assert False
except AttributeError:
pass
except BaseException as e:
assert False, e
def test_add_node():
node_a = 'A'
node_b = 'B'
node_c = 'C'
attrib_c = {'alt_name': 1337}
node_d = 'D'
attrib_d = {'label': 'black', 'sink': True}
# Test adding unadded nodes with various attribute settings
H = DirectedHypergraph()
H.add_node(node_a)
H.add_node(node_b, source=True)
H.add_node(node_c, attrib_c)
H.add_node(node_d, attrib_d, sink=False)
assert node_a in H._node_attributes
assert H._node_attributes[node_a] == {}
assert node_b in H._node_attributes
assert H._node_attributes[node_b]['source'] is True
assert node_c in H._node_attributes
assert H._node_attributes[node_c]['alt_name'] == 1337
assert node_d in H._node_attributes
assert H._node_attributes[node_d]['label'] == 'black'
assert H._node_attributes[node_d]['sink'] is False
# Test adding a node that has already been added
H.add_nodes(node_a, common=False)
assert H._node_attributes[node_a]['common'] is False
# Pass in bad (non-dict) attribute
try:
H.add_node(node_a, ["label", "black"])
assert False
except AttributeError:
pass
except BaseException as e:
assert False, e
def read_hg_from_file(file_name):
'''
returns a hypergraph based on the info in a file. Assumption: file_name has been written using write_hg_on_file
:param file_name:
'''
hg = DirectedHypergraph()
in_file = open(file_name, 'r')
lines = in_file.readlines()
sep = '\t'
for line in lines:
#line.strip()
values = line.split(sep)
#for value in values:
if values[0] == 'node':
# I am processing a node
node_id = values[1]
node_attrs = ast.literal_eval(values[2])
hg.add_node(node_id, node_attrs)
if values[0] == 'edge':
tail = None
head = None
edge = values[1]
edge_attrs = ast.literal_eval(values[2])
# I am processsing an edge
for j in range(2, len(values), 1):
values[j] = values[j].strip()
tail = edge_attrs['tail']
#print(tail)
#tail_list = eval(tail)
head = edge_attrs['head']
# turn string representation of head into an actual list
#head_list = ast.literal_eval(head)
#print("ID, TAIL, HEAD: {2} - {0} - {1} - {3}".format(tail,head,values[1], edge_attrs))
hg.add_hyperedge(tail, head, edge_attrs)
print_hg_std_out_only(hg)
in_file.close()
return hg
def test_returns_only_one_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(len(output), 1)
def test_returns_only_one_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(len(output), 1)
class TestComputeLowerBound(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
def test_returns_12_for_lower_bound_for_nielsen_H_21(self):
'''
Test graph is discussed in Section 3.2 example 2 of
Nielsen et al.\
'''
H_2 = self.nielsenGraph.copy()
e1 = H_2.get_hyperedge_id({'s'}, {'1'})
e2 = H_2.get_hyperedge_id({'1'}, {'2'})
e3 = H_2.get_hyperedge_id({'1', '2'}, {'t'})
H_2.remove_hyperedge(H_2.get_hyperedge_id({'s'}, {'2'}))
H_2.remove_hyperedge(H_2.get_hyperedge_id({'4'}, {'t'}))
# weight vector
W = {'s': 0, '1': 1, '2': 2, '3': 1, '4': 4, 't': 4}
# predecessor function
pred = {'s': None, '1': e1, '2': e2, 't': e3}
# ordering
ordering = ['s', '1', '2', 't']
# branch of H_2 for the test
H_2_1 = H_2.copy()
H_2_1.remove_hyperedge(
H_2_1.get_hyperedge_id({'s'}, {'1'}))
self.assertEqual(ksh._compute_lower_bound(
H_2_1, 0, pred, ordering, W, 't'), 12)
class TestComputeLowerBound(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
def test_returns_12_for_lower_bound_for_nielsen_H_21(self):
'''
Test graph is discussed in Section 3.2 example 2 of
Nielsen et al.\
'''
H_2 = self.nielsenGraph.copy()
e1 = H_2.get_hyperedge_id({'s'}, {'1'})
e2 = H_2.get_hyperedge_id({'1'}, {'2'})
e3 = H_2.get_hyperedge_id({'1', '2'}, {'t'})
H_2.remove_hyperedge(H_2.get_hyperedge_id({'s'}, {'2'}))
H_2.remove_hyperedge(H_2.get_hyperedge_id({'4'}, {'t'}))
# weight vector
W = {'s': 0, '1': 1, '2': 2, '3': 1, '4': 4, 't': 4}
# predecessor function
pred = {'s': None, '1': e1, '2': e2, 't': e3}
# ordering
ordering = ['s', '1', '2', 't']
# branch of H_2 for the test
H_2_1 = H_2.copy()
H_2_1.remove_hyperedge(H_2_1.get_hyperedge_id({'s'}, {'1'}))
self.assertEqual(
ksh._compute_lower_bound(H_2_1, 0, pred, ordering, W, 't'), 12)
def test_returns_shortest_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
hyperpath = output[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 2)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'t'}))
def test_returns_shortest_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
hyperpath = output[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 2)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'t'}))
class TestBranchingStep(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
def test_returns_disconnected_nodes_on_graph_with_two_nodes(self):
H = DirectedHypergraph()
s, t = 's', 't'
H.add_node(s)
H.add_node(t)
e1 = H.add_hyperedge({s}, {t})
predecessor = {s: None, t: e1}
ordering = [s, t]
branch = ksh._branching_step(H, predecessor, ordering)[0]
self.assertEqual(branch.get_hyperedge_id_set(), set([]))
self.assertEqual(branch.get_node_set(), {'s', 't'})
def test_returns_correct_branching_for_nielsen_graph(self):
H = self.nielsenGraph
ordering = ['s', '1', '2', 't']
pred = {'s': None, '1': H.get_hyperedge_id({'s'}, {'1'}),
'2': H.get_hyperedge_id({'s'}, {'2'}),
't': H.get_hyperedge_id({'2', '1'}, {'t'})}
branches = ksh._branching_step(H, pred, ordering)
self.assertEqual(len(branches), 3)
# branch 1
b1 = branches[0]
self.assertEqual(b1.get_node_set(), H.get_node_set())
hyperedges = b1.get_hyperedge_id_set()
hyperedgesTuple = [(b1.get_hyperedge_tail(e),
b1.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 6)
self.assertIn(({'s'}, {'2'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'1', '2'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
# branch 2
b2 = branches[1]
self.assertEqual(b2.get_node_set(), H.get_node_set())
hyperedges = b2.get_hyperedge_id_set()
hyperedgesTuple = [(b2.get_hyperedge_tail(e),
b2.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 7)
self.assertIn(({'s'}, {'1'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'1'}, {'2'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'1', '2'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
# branch 3
b3 = branches[2]
self.assertEqual(b3.get_node_set(), H.get_node_set())
hyperedges = b3.get_hyperedge_id_set()
hyperedgesTuple = [(b3.get_hyperedge_tail(e),
b3.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 8)
self.assertIn(({'s'}, {'1'}), hyperedgesTuple)
self.assertIn(({'s'}, {'2'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'1'}, {'2'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'4'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
def get_hyperpath_from_predecessors(H, Pv, source_node, destination_node,
node_weights=None, attr_name="weight"):
"""Gives the hyperpath (DirectedHypergraph) representing the shortest
B-hyperpath from the source to the destination, given a predecessor
function and source and destination nodes.
:note: The IDs of the hyperedges in the subhypergraph returned may be
different than those in the original hypergraph (even though the
tail and head sets are identical).
:param H: the hypergraph which the path algorithm was executed on.
:param Pv: dictionary mapping each node to the ID of the hyperedge that
preceeded it in the path.
:param source_node: the source node of the path.
:param destination_node: the destination node of the path.
:returns: DirectedHypergraph -- shortest B-hyperpath from source_node to
destination_node.
:raises: TypeError -- Algorithm only applicable to directed hypergraphs
:raises: KeyError -- Node key in predecessor is not in H
:raises: KeyError -- Hyperedge key in predecessor is not in H
:raises: ValueError -- Multiple nodes without predecessor
:raises: ValueError -- Hypertree does not have source node
"""
if not isinstance(H, DirectedHypergraph):
raise TypeError("Algorithm only applicable to directed hypergraphs")
# Check that Pv is a valid predecessor function:
# - keys must be nodes in H mapping to hyperedges in H
# - exactly one node must map to None (i.e., only one node
# without predecessor)
nodes_without_predecessor = 0
for node, hyperedge_id in Pv.items():
if not H.has_node(node):
raise KeyError(
"Node key %s in predecessor is not in H" % node)
if hyperedge_id is None:
nodes_without_predecessor += 1
elif not H.has_hyperedge_id(hyperedge_id):
raise KeyError(
"Hyperedge key %s in predecessor is not in H" % hyperedge_id)
if nodes_without_predecessor > 1:
raise ValueError(
"Multiple nodes without predecessor. %s received" % Pv)
elif nodes_without_predecessor == 0:
raise ValueError(
"Hypertree does not have source node. %s received" % Pv)
path = DirectedHypergraph()
# keep track of which nodes are or have been processed
processedOrInQueue = {n: False for n in Pv}
nodesToProcess = [destination_node]
processedOrInQueue[destination_node] = True
while nodesToProcess:
node = nodesToProcess.pop(0)
hyperedge_id = Pv[node]
if hyperedge_id:
for n in H.get_hyperedge_tail(hyperedge_id):
if not processedOrInQueue[n]:
nodesToProcess.append(n)
processedOrInQueue[n] = True
path.add_hyperedge(H.get_hyperedge_tail(hyperedge_id),
H.get_hyperedge_head(hyperedge_id),
weight=H.get_hyperedge_weight(
hyperedge_id))
elif not path.has_node(node):
path.add_node(node)
return path
def aco_algorithm(start_node_set, hg, ANT_NUM, COL_NUM, tau, W_UTILITY):
#set the values of the utility function weights
W_COST = W_UTILITY['cost']
W_AVAIL = W_UTILITY['avail']
W_QUAL = W_UTILITY['qual']
W_TIME = W_UTILITY['time']
#setup the logger
#logging.basicConfig(filename='aco.log',level=logging.INFO)
logger = logging.getLogger(__name__)
#currently optimal path
p_opt = DirectedHypergraph()
utility_opt = 0.0
#counters for colony
col = 0
while col < COL_NUM:
#counter for ant number
ant = 0
logger.info("Processing COLONY n. {0}".format(col))
#h_graph to store partial pheromone update
hg_phero = hg.copy()
#do something
p = DirectedHypergraph()
#add source node to optimal path (and its attributes)
for node in start_node_set:
p.add_node(node, hg.get_node_attributes(node))
while ant < ANT_NUM:
logger.info("--- Processing COLONY n. {1}, ANT n. {0}".format(ant, col))
p = DirectedHypergraph()
#add source node to optimal path (and its attributes)
for node in start_node_set:
p.add_node(node, hg.get_node_attributes(node))
""" call aco_search on p"""
# recursive
visited = []
p = aco_search(p, hg, start_node_set, 0, visited)
# non recursive
#p = aco_search_norec(p, hg, start_node_set)
#PRINT CURRENT OPTIMAL PATH
print_hg(p,'hyp_file.txt')
#calculate utility of p
utility = calculate_utility(p, W_COST, W_TIME, W_QUAL, W_AVAIL)
#do partial pheromone update
partial_phero_update(hg_phero, p, W_COST, W_TIME, W_QUAL, W_AVAIL)
#check if p is better than current optimal solution
#update if p is optimal
logger.debug("Utility of current path: {0} ".format(utility))
logger.debug("Current OPTIMAL UTILITY: {0}".format(utility_opt))
if utility > utility_opt:
utility_opt = utility
p_opt = p
logger.info("***** optimal path updated!!! *****")
ant = ant + 1
#pheromone update
#TBC TBC
col = col + 1
#actual pheromone update after processing an entire colony
final_phero_update(hg, p_opt, tau)
#do something else
logger.info("********** OPTIMAL PATH FOUND ******************")
print_hg(p_opt, 'hyp_file.txt')
logger.info("****** UTILITY: "+str(calculate_utility(p_opt, W_COST, W_TIME, W_QUAL, W_AVAIL)))
logger.info("***********************************************")
return p_opt
def aco_algorithm(start_node_set, hg, ANT_NUM, COL_NUM, tau, W_UTILITY):
#set the values of the utility function weights
W_COST = W_UTILITY['cost']
W_AVAIL = W_UTILITY['avail']
W_QUAL = W_UTILITY['qual']
W_TIME = W_UTILITY['time']
#setup the logger
#logging.basicConfig(filename='aco.log',level=logging.INFO)
logger = logging.getLogger(__name__)
#currently optimal path
p_opt = DirectedHypergraph()
utility_opt = 0.0
#counters for colony
col = 0
while col < COL_NUM:
#counter for ant number
ant = 0
logger.info("Processing COLONY n. {0}".format(col))
#h_graph to store partial pheromone update
hg_phero = hg.copy()
#do something
p = DirectedHypergraph()
#add source node to optimal path (and its attributes)
for node in start_node_set:
p.add_node(node, hg.get_node_attributes(node))
while ant < ANT_NUM:
logger.info("--- Processing COLONY n. {1}, ANT n. {0}".format(
ant, col))
p = DirectedHypergraph()
#add source node to optimal path (and its attributes)
for node in start_node_set:
p.add_node(node, hg.get_node_attributes(node))
""" call aco_search on p"""
# recursive
visited = []
p = aco_search(p, hg, start_node_set, 0, visited)
# non recursive
#p = aco_search_norec(p, hg, start_node_set)
#PRINT CURRENT OPTIMAL PATH
print_hg(p, 'hyp_file.txt')
#calculate utility of p
utility = calculate_utility(p, W_COST, W_TIME, W_QUAL, W_AVAIL)
#do partial pheromone update
partial_phero_update(hg_phero, p, W_COST, W_TIME, W_QUAL, W_AVAIL)
#check if p is better than current optimal solution
#update if p is optimal
logger.debug("Utility of current path: {0} ".format(utility))
logger.debug("Current OPTIMAL UTILITY: {0}".format(utility_opt))
if utility > utility_opt:
utility_opt = utility
p_opt = p
logger.info("***** optimal path updated!!! *****")
ant = ant + 1
#pheromone update
#TBC TBC
col = col + 1
#actual pheromone update after processing an entire colony
final_phero_update(hg, p_opt, tau)
#do something else
logger.info("********** OPTIMAL PATH FOUND ******************")
print_hg(p_opt, 'hyp_file.txt')
logger.info("****** UTILITY: " +
str(calculate_utility(p_opt, W_COST, W_TIME, W_QUAL, W_AVAIL)))
logger.info("***********************************************")
return p_opt
def convert_pnet_to_hypergraph(pnet):
""" pre-process pnet to number tau-split and tau-join transitions"""
tau_pre_processing_pnet(pnet)
""" Convert a Petri net (in pnml format) into a hypergraph (Halp format) """
hg = DirectedHypergraph()
transitions = get_transitions(pnet)
places = get_places(pnet)
"""STEP 1: Pre-process places to find xor places (splits and joints)
If input/output of a transitions is 2 or more places, then mark those places as "X" and put in hypergraph"""
for place in places:
inc_arcs = get_incoming_arcs(place, pnet)
out_arcs = get_outgoing_arcs(place, pnet)
isSink = False
isSource = False
if len(inc_arcs) > 1:
#create node for place in hypergraph
node_id = get_id(place)
#check if join is end event (sink)
if (len(out_arcs) == 0):
isSink = True
logger.debug(
"STEP 1 - Creating xor-join node -- {0}".format(node_id))
hg.add_node(node_id,
source=isSource,
sink=isSink,
type='xor-join',
name=" ")
head = []
head.append(node_id)
isSink = False
isSource = False
#create node for all source of incoming arcs
for arc in inc_arcs:
node_id2 = get_id(get_element(get_arc_source(arc), pnet))
node_name = get_transition_name(
get_element(get_arc_source(arc), pnet))
logger.debug(
"STEP 1 - Creating transition node -- {0} -- {1}".format(
node_id, node_name))
hg.add_node(node_name,
source=isSource,
sink=isSink,
type='transition',
name=node_name)
tail = []
tail.append(node_name)
#create hyperedge
logger.debug(
"STEP 1 - Creating hyperedge from {0} to {1}".format(
str(tail), str(head)))
hg.add_hyperedge(tail, head, name=" ", phero=0.5)
if len(out_arcs) > 1:
node_id = get_id(place)
#create node for place in hypergraph (if it does not exist already)
tail = []
tail.append(node_id)
if (not hg.has_node(node_id)):
#check if source (start event)
if (len(inc_arcs) == 0):
isSource = True
logger.debug(
"STEP 1 - Creating xor-split node -- {0}".format(node_id))
hg.add_node(node_id,
source=isSource,
sink=isSink,
type='xor-split',
name=" ")
#create node for all targets of outgoing arcs
isSink = False
isSource = False
for arc in out_arcs:
node_id2 = get_id(get_element(get_arc_target(arc), pnet))
node_name = get_transition_name(
get_element(get_arc_target(arc), pnet))
if (not hg.has_node(node_id2)):
logger.debug(
"STEP 1 - Creating transition node -- {0} -- {1}".
format(node_id, node_name))
hg.add_node(node_name,
source=isSource,
sink=isSink,
type='transition',
name=node_name)
head = []
head.append(node_name)
#create hyperedge
logger.debug(
"STEP 1 - Creating hyperedge from {0} to {1}".format(
str(tail), str(head)))
hg.add_hyperedge(tail, head, name=" ", phero=0.5)
""" STEP2 : Process each transition """
for transition in transitions:
logger.debug("######## Processing transition {0}".format(
get_transition_name(transition)))
isSink = False
isSource = False
#check if transition is not a node in hg and add if needed
#if (not hg.has_node(get_transition_name(transition))):
#check if transition is start
inc_arcs = get_incoming_arcs(transition, pnet)
for inc_arc in inc_arcs:
source_place = get_element(get_arc_source(inc_arc), pnet)
place_inc = get_incoming_arcs(source_place, pnet)
if not place_inc:
isSource = True
logger.debug("Transition is START: {0}".format(
get_transition_name(transition)))
#check if trsnasition is end event
out_arcs = get_outgoing_arcs(transition, pnet)
for out_arc in out_arcs:
sink_place = get_element(get_arc_target(out_arc), pnet)
place_out = get_outgoing_arcs(sink_place, pnet)
if not place_out:
isSink = True
logger.debug("Transition is END: {0}".format(
get_transition_name(transition)))
#create node in hypergraph
logger.debug("STEP 2 - Creating transition node")
hg.add_node(get_transition_name(transition),
source=isSource,
sink=isSink,
type='transition',
name=get_transition_name(transition))
#look BACKWARD
if not isSource:
inc_arcs = get_incoming_arcs(transition, pnet)
tail = []
x_head = [get_transition_name(transition)]
xplace_list = []
otherp_list = []
xplace_tail = []
for inc_arc in inc_arcs:
place = get_element(get_arc_source(inc_arc), pnet)
#separate xor places from other forward places of this transition
if (hg.has_node(get_id(place))):
xplace_list.append(place)
xplace_tail.append(get_id(place))
else:
otherp_list.append(place)
#create forward hyperedge to possibly multiple xor nodes
he_from_xors_needed = False
for place in xplace_tail:
temp_tail = []
temp_tail.append(place)
if (not hg.has_hyperedge(temp_tail, x_head)):
he_from_xors_needed = True
if (he_from_xors_needed):
logger.debug(
"STEP 2 - Creating backward hyperedge to (multiple) xor - TAIL {0} -- HEAD {1} "
.format(str(xplace_tail), str(x_head)))
hg.add_hyperedge(xplace_tail, x_head, name=" ", phero=0.5)
#create forward normal hyperdge
tail = []
# for place in otherp_list:
# inc_arcs_l2 = get_incoming_arcs(place)
# for inc_arc_l2 in inc_arcs_l2:
# trans2 = get_element(get_arc_source(inc_arc_l2))
# tail.append(get_transition_name(trans2))
# if(tail):
# logger.info("STEP 2 - Creating real backward hyperedge - TAIL {0} -- HEAD {1} ".format(str(tail),str(x_head)))
# hg.add_hyperedge(tail, x_head, name = " ", phero = 0.0, cost = 0.4, avail = 0.6, qual = 0.2, time = 0.99)
#look FORWARD
if not isSink:
out_arcs = get_outgoing_arcs(transition, pnet)
head = []
x_tail = [get_transition_name(transition)]
xplace_list = []
otherp_list = []
xplace_head = []
for out_arc in out_arcs:
place = get_element(get_arc_target(out_arc), pnet)
#separate xor places from other forward places of this transition
if (hg.has_node(get_id(place))):
xplace_list.append(place)
xplace_head.append(get_id(place))
else:
otherp_list.append(place)
#create forward hyperedge to possibly multiple xor nodes
he_to_xors_needed = False
for place in xplace_head:
temp_head = []
temp_head.append(place)
if (not hg.has_hyperedge(x_tail, temp_head)):
he_to_xors_needed = True
if (he_to_xors_needed):
logger.debug(
"STEP 2 - Creating forward hyperedge to (multiple) xor - TAIL {0} -- HEAD {1} "
.format(str(x_tail), str(xplace_head)))
hg.add_hyperedge(x_tail, xplace_head, name=" ", phero=0.5)
#create forward normal hyperdge
head = []
for place in otherp_list:
out_arcs_l2 = get_outgoing_arcs(place, pnet)
for out_arc_l2 in out_arcs_l2:
trans2 = get_element(get_arc_target(out_arc_l2), pnet)
head.append(get_transition_name(trans2))
if (head):
logger.debug(
"STEP 2 - Creating real forward hyperedge - TAIL {0} -- HEAD {1} "
.format(str(x_tail), str(head)))
hg.add_hyperedge(x_tail,
head,
name=" ",
phero=0.5,
cost=0.4,
avail=0.6,
qual=0.2,
time=0.99)
""" POST PROCESSING of tau-split/join generated by inductive miner """
hg = tau_post_processing(hg)
""" reduction of tau split/join """
#hg = tau_reduction(hg)
return hg
class TestKShortestHyperpaths(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
# valid input tests
def test_raises_exception_if_H_not_B_hypegraph(self):
H = DirectedHypergraph()
H.add_nodes([1, 2, 3])
H.add_hyperedge([1], [2, 3])
source, destination = 1, 2
self.assertRaises(TypeError, ksh.k_shortest_hyperpaths, H, source,
destination, 1)
def test_raises_exception_if_H_not_hypegraph(self):
H = "DirectedHypergraph"
source, destination = 1, 2
self.assertRaises(TypeError, ksh.k_shortest_hyperpaths, H, source,
destination, 1)
def test_raises_exception_if_source_not_in_graph(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError, ksh.k_shortest_hyperpaths, H, 3,
destination, 1)
def test_raises_exception_if_destination_not_in_graph(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError, ksh.k_shortest_hyperpaths, H, source, 3,
1)
def test_raises_exception_if_k_not_integer(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(TypeError, ksh.k_shortest_hyperpaths, H, source,
destination, 0.1)
def test_raises_exception_if_k_not_positive(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError, ksh.k_shortest_hyperpaths, H, source,
destination, -4)
self.assertRaises(ValueError, ksh.k_shortest_hyperpaths, H, source,
destination, 0)
# various cases
def test_returns_only_one_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(len(output), 1)
def test_returns_shortest_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
hyperpath = output[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 2)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'t'}))
def test_returns_empty_list_if_no_s_t_path(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'1', '2'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(output, [])
def test_returns_3_shortest_hypergraphs_for_nielsen_example_with_k_equal_3(
self):
threeShortest = ksh.k_shortest_hyperpaths(self.nielsenGraph, 's', 't',
3)
self.assertEqual(len(threeShortest), 3)
# shortest path
hyperpath = threeShortest[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', '2', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 3)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1', '2'}, {'t'}))
# second shortest path
hyperpath = threeShortest[1]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', '2', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 3)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1', '2'}, {'t'}))
# third shortest path
hyperpath = threeShortest[2]
self.assertEqual(hyperpath.get_node_set(), {'s', '2', '3', '4', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 4)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'3'}))
self.assertTrue(hyperpath.get_hyperedge_id({'2', '3'}, {'4'}))
self.assertTrue(hyperpath.get_hyperedge_id({'4'}, {'t'}))
'''
Created on Jun 16, 2016
@author: UNIST
'''
from halp.directed_hypergraph import DirectedHypergraph
from org.emettelatripla.util.util import *
from org.emettelatripla.aco.ACO_directed_hypergraph import *
from org.emettelatripla.aco.ACO_util import *
import logging
# Initialize an empty hypergraph
H = DirectedHypergraph()
# Add nodes 's' and 't' individually with arbitrary attributes
H.add_node('A', sink=False, source=True, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('B', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('C', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('D', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('E', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('G', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('H', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.78)
H.add_node('F', source=False, sink=True, cost=0.1, avail=0.98, qual=0.4, time=0.45)
hyperedges = [(['A'], ['B'], {'name' : " ", 'phero': 0.3}),
(['A'], ['D','E'], {'name' : " ", 'phero': 0.1}),
(['A'], ['G'], {'name' : " ", 'phero': 0.6}),
(['B'], ['C'], {'name' : " ", 'phero': 0.0}),
(['D','E'], ['F'], {'name' : " ", 'phero': 0.0}),
(['E','H'], ['F'], {'name' : " ", 'phero': 0.0}),
(['G'], ['H'], {'name' : " ", 'phero': 0.0}),
class TestBranchingStep(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
def test_returns_disconnected_nodes_on_graph_with_two_nodes(self):
H = DirectedHypergraph()
s, t = 's', 't'
H.add_node(s)
H.add_node(t)
e1 = H.add_hyperedge({s}, {t})
predecessor = {s: None, t: e1}
ordering = [s, t]
branch = ksh._branching_step(H, predecessor, ordering)[0]
self.assertEqual(branch.get_hyperedge_id_set(), set([]))
self.assertEqual(branch.get_node_set(), {'s', 't'})
def test_returns_correct_branching_for_nielsen_graph(self):
H = self.nielsenGraph
ordering = ['s', '1', '2', 't']
pred = {
's': None,
'1': H.get_hyperedge_id({'s'}, {'1'}),
'2': H.get_hyperedge_id({'s'}, {'2'}),
't': H.get_hyperedge_id({'2', '1'}, {'t'})
}
branches = ksh._branching_step(H, pred, ordering)
self.assertEqual(len(branches), 3)
# branch 1
b1 = branches[0]
self.assertEqual(b1.get_node_set(), H.get_node_set())
hyperedges = b1.get_hyperedge_id_set()
hyperedgesTuple = [(b1.get_hyperedge_tail(e), b1.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 6)
self.assertIn(({'s'}, {'2'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'1', '2'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
# branch 2
b2 = branches[1]
self.assertEqual(b2.get_node_set(), H.get_node_set())
hyperedges = b2.get_hyperedge_id_set()
hyperedgesTuple = [(b2.get_hyperedge_tail(e), b2.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 7)
self.assertIn(({'s'}, {'1'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'1'}, {'2'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'1', '2'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
# branch 3
b3 = branches[2]
self.assertEqual(b3.get_node_set(), H.get_node_set())
hyperedges = b3.get_hyperedge_id_set()
hyperedgesTuple = [(b3.get_hyperedge_tail(e), b3.get_hyperedge_head(e))
for e in hyperedges]
self.assertEqual(len(hyperedges), 8)
self.assertIn(({'s'}, {'1'}), hyperedgesTuple)
self.assertIn(({'s'}, {'2'}), hyperedgesTuple)
self.assertIn(({'s'}, {'3'}), hyperedgesTuple)
self.assertIn(({'1'}, {'2'}), hyperedgesTuple)
self.assertIn(({'2'}, {'3'}), hyperedgesTuple)
self.assertIn(({'2', '3'}, {'4'}), hyperedgesTuple)
self.assertIn(({'4'}, {'t'}), hyperedgesTuple)
self.assertIn(({'4'}, {'1'}), hyperedgesTuple)
def make_hypergraph(file_prefix,
delim=';',
sep='\t',
keep_singleton_nodes=False):
'''
Creates the directed hypergraph object from the hypernodes and hyperedges files.
Returns the hypergraph object.
'''
#NOTE: This is directly copied from https://github.com/annaritz/pathway-connectivity
hypernodes = {}
with open(file_prefix + '-hypernodes.txt') as fin:
for line in fin:
if line[0] == '#':
continue
row = line.strip().split(sep)
if len(row) == 1:
hypernodes[row[0]] = ['OtherComplexes-FIX']
else:
hypernodes[row[0]] = row[1].split(delim)
print('%d hypernodes from hypernodes file' % (len(hypernodes)))
identifier2id = {}
id2identifier = {}
H = DirectedHypergraph()
if keep_singleton_nodes:
for n in hypernodes:
H.add_node(n)
skipped1 = 0
skipped2 = 0
tailsizes = []
headsizes = []
selfloops = []
noinselfloops = 0
indegree = []
outdegree = []
numtargets = 0
with open(file_prefix + '-hyperedges.txt') as fin:
for line in fin:
if line[0] == '#':
continue
row = line.strip().split(sep)
tail = set()
head = set()
## Tail includes tail and regulators.
## Head includes head.
if row[0] != 'None':
tail.update(row[0].split(delim))
if row[1] != 'None':
head.update(row[1].split(delim))
if row[2] != 'None':
tail.update(row[2].split(delim))
#NOTE: This line was commented out to exclude negative regulators in the tail
#if row[3] != 'None':
#tail.update(row[3].split(delim))
hedge_id = row[4]
## THIS IS A HACK FOR NOW ( should be incorporated in the make-hypergraph.py code)
## IGnore any reactions that have a Reactome Identifier (e.g. has "HSA") instead of
## a PAthway Commons identifier.
if any(['HSA' in s for s in tail] + ['HSA' in s for s in head]):
skipped1 += 1
elif len(tail) == 0 or len(head) == 0:
skipped2 += 1
else:
hid = H.add_hyperedge(tail, head, identifier=hedge_id)
tailsizes.append(len(tail))
headsizes.append(len(head))
intersection = tail.intersection(head)
if len(intersection) > 0:
selfloops.append([v for v in intersection])
identifier2id[hedge_id] = hid
id2identifier[hid] = hedge_id
print('%d reactions skipped because of Reactome identifier' % (skipped1))
print('%d reactions skipped because of an empty tail or head' % (skipped2))
## annotate nodes
num_hypernodes = 0
for node in H.get_node_set():
if node in hypernodes and hypernodes[node] != [node]:
H.add_node(node,
hypernode_members=hypernodes[node],
is_hypernode=True)
num_hypernodes += 1
else:
H.add_node(node, is_hypernode=False, hypernode_members=[])
H.add_node(node)
return H, identifier2id, id2identifier
def get_hyperpath_from_predecessors(H,
Pv,
source_node,
destination_node,
node_weights=None,
attr_name="weight"):
"""Gives the hyperpath (DirectedHypergraph) representing the shortest
B-hyperpath from the source to the destination, given a predecessor
function and source and destination nodes.
:note: The IDs of the hyperedges in the subhypergraph returned may be
different than those in the original hypergraph (even though the
tail and head sets are identical).
:param H: the hypergraph which the path algorithm was executed on.
:param Pv: dictionary mapping each node to the ID of the hyperedge that
preceeded it in the path.
:param source_node: the source node of the path.
:param destination_node: the destination node of the path.
:returns: DirectedHypergraph -- shortest B-hyperpath from source_node to
destination_node.
:raises: TypeError -- Algorithm only applicable to directed hypergraphs
:raises: KeyError -- Node key in predecessor is not in H
:raises: KeyError -- Hyperedge key in predecessor is not in H
:raises: ValueError -- Multiple nodes without predecessor
:raises: ValueError -- Hypertree does not have source node
"""
if not isinstance(H, DirectedHypergraph):
raise TypeError("Algorithm only applicable to directed hypergraphs")
# Check that Pv is a valid predecessor function:
# - keys must be nodes in H mapping to hyperedges in H
# - exactly one node must map to None (i.e., only one node
# without predecessor)
nodes_without_predecessor = 0
for node, hyperedge_id in Pv.items():
if not H.has_node(node):
raise KeyError("Node key %s in predecessor is not in H" % node)
if hyperedge_id is None:
nodes_without_predecessor += 1
elif not H.has_hyperedge_id(hyperedge_id):
raise KeyError("Hyperedge key %s in predecessor is not in H" %
hyperedge_id)
if nodes_without_predecessor > 1:
raise ValueError("Multiple nodes without predecessor. %s received" %
Pv)
elif nodes_without_predecessor == 0:
raise ValueError("Hypertree does not have source node. %s received" %
Pv)
path = DirectedHypergraph()
# keep track of which nodes are or have been processed
processedOrInQueue = {n: False for n in Pv}
nodesToProcess = [destination_node]
processedOrInQueue[destination_node] = True
while nodesToProcess:
node = nodesToProcess.pop(0)
hyperedge_id = Pv[node]
if hyperedge_id:
for n in H.get_hyperedge_tail(hyperedge_id):
if not processedOrInQueue[n]:
nodesToProcess.append(n)
processedOrInQueue[n] = True
path.add_hyperedge(H.get_hyperedge_tail(hyperedge_id),
H.get_hyperedge_head(hyperedge_id),
weight=H.get_hyperedge_weight(hyperedge_id))
elif not path.has_node(node):
path.add_node(node)
return path
def convert_pnet_to_hypergraph(pnet):
""" pre-process pnet to number tau-split and tau-join transitions"""
tau_pre_processing_pnet(pnet)
""" Convert a Petri net (in pnml format) into a hypergraph (Halp format) """
hg = DirectedHypergraph()
transitions = get_transitions(pnet)
places = get_places(pnet)
"""STEP 1: Pre-process places to find xor places (splits and joints)
If input/output of a transitions is 2 or more places, then mark those places as "X" and put in hypergraph"""
for place in places:
inc_arcs = get_incoming_arcs(place,pnet)
out_arcs = get_outgoing_arcs(place,pnet)
isSink = False
isSource = False
if len(inc_arcs) > 1:
#create node for place in hypergraph
node_id = get_id(place)
#check if join is end event (sink)
if (len(out_arcs) == 0):
isSink = True
logger.debug("STEP 1 - Creating xor-join node -- {0}".format(node_id))
hg.add_node(node_id, source = isSource, sink = isSink, type = 'xor-join', name = " ")
head = []
head.append(node_id)
isSink = False
isSource = False
#create node for all source of incoming arcs
for arc in inc_arcs:
node_id2 = get_id(get_element(get_arc_source(arc), pnet))
node_name = get_transition_name(get_element(get_arc_source(arc), pnet))
logger.debug("STEP 1 - Creating transition node -- {0} -- {1}".format(node_id, node_name))
hg.add_node(node_name, source = isSource, sink = isSink, type = 'transition', name = node_name)
tail = []
tail.append(node_name)
#create hyperedge
logger.debug("STEP 1 - Creating hyperedge from {0} to {1}".format(str(tail), str(head)))
hg.add_hyperedge(tail, head, name = " ", phero = 0.5)
if len(out_arcs) > 1:
node_id = get_id(place)
#create node for place in hypergraph (if it does not exist already)
tail = []
tail.append(node_id)
if(not hg.has_node(node_id)):
#check if source (start event)
if (len(inc_arcs) == 0):
isSource = True
logger.debug("STEP 1 - Creating xor-split node -- {0}".format(node_id))
hg.add_node(node_id, source = isSource, sink = isSink, type = 'xor-split', name = " ")
#create node for all targets of outgoing arcs
isSink = False
isSource = False
for arc in out_arcs:
node_id2 = get_id(get_element(get_arc_target(arc), pnet))
node_name = get_transition_name(get_element(get_arc_target(arc),pnet))
if(not hg.has_node(node_id2)):
logger.debug("STEP 1 - Creating transition node -- {0} -- {1}".format(node_id, node_name))
hg.add_node(node_name, source = isSource, sink = isSink, type = 'transition', name = node_name)
head = []
head.append(node_name)
#create hyperedge
logger.debug("STEP 1 - Creating hyperedge from {0} to {1}".format(str(tail), str(head)))
hg.add_hyperedge(tail, head, name = " ", phero = 0.5)
""" STEP2 : Process each transition """
for transition in transitions:
logger.debug("######## Processing transition {0}".format(get_transition_name(transition)))
isSink = False
isSource = False
#check if transition is not a node in hg and add if needed
#if (not hg.has_node(get_transition_name(transition))):
#check if transition is start
inc_arcs = get_incoming_arcs(transition,pnet)
for inc_arc in inc_arcs:
source_place = get_element(get_arc_source(inc_arc),pnet)
place_inc = get_incoming_arcs(source_place,pnet)
if not place_inc:
isSource = True
logger.debug("Transition is START: {0}".format(get_transition_name(transition)))
#check if trsnasition is end event
out_arcs = get_outgoing_arcs(transition,pnet)
for out_arc in out_arcs:
sink_place = get_element(get_arc_target(out_arc),pnet)
place_out = get_outgoing_arcs(sink_place,pnet)
if not place_out:
isSink = True
logger.debug("Transition is END: {0}".format(get_transition_name(transition)))
#create node in hypergraph
logger.debug("STEP 2 - Creating transition node")
hg.add_node(get_transition_name(transition), source = isSource, sink = isSink, type = 'transition', name = get_transition_name(transition))
#look BACKWARD
if not isSource:
inc_arcs = get_incoming_arcs(transition,pnet)
tail = []
x_head = [get_transition_name(transition)]
xplace_list = []
otherp_list = []
xplace_tail = []
for inc_arc in inc_arcs:
place = get_element(get_arc_source(inc_arc),pnet)
#separate xor places from other forward places of this transition
if(hg.has_node(get_id(place))):
xplace_list.append(place)
xplace_tail.append(get_id(place))
else:
otherp_list.append(place)
#create forward hyperedge to possibly multiple xor nodes
he_from_xors_needed = False
for place in xplace_tail:
temp_tail = []
temp_tail.append(place)
if(not hg.has_hyperedge(temp_tail,x_head)):
he_from_xors_needed = True
if(he_from_xors_needed):
logger.debug("STEP 2 - Creating backward hyperedge to (multiple) xor - TAIL {0} -- HEAD {1} ".format(str(xplace_tail),str(x_head)))
hg.add_hyperedge(xplace_tail, x_head, name = " ", phero = 0.5)
#create forward normal hyperdge
tail = []
# for place in otherp_list:
# inc_arcs_l2 = get_incoming_arcs(place)
# for inc_arc_l2 in inc_arcs_l2:
# trans2 = get_element(get_arc_source(inc_arc_l2))
# tail.append(get_transition_name(trans2))
# if(tail):
# logger.info("STEP 2 - Creating real backward hyperedge - TAIL {0} -- HEAD {1} ".format(str(tail),str(x_head)))
# hg.add_hyperedge(tail, x_head, name = " ", phero = 0.0, cost = 0.4, avail = 0.6, qual = 0.2, time = 0.99)
#look FORWARD
if not isSink:
out_arcs = get_outgoing_arcs(transition,pnet)
head = []
x_tail = [get_transition_name(transition)]
xplace_list = []
otherp_list = []
xplace_head = []
for out_arc in out_arcs:
place = get_element(get_arc_target(out_arc),pnet)
#separate xor places from other forward places of this transition
if(hg.has_node(get_id(place))):
xplace_list.append(place)
xplace_head.append(get_id(place))
else:
otherp_list.append(place)
#create forward hyperedge to possibly multiple xor nodes
he_to_xors_needed = False
for place in xplace_head:
temp_head = []
temp_head.append(place)
if(not hg.has_hyperedge(x_tail,temp_head)):
he_to_xors_needed = True
if(he_to_xors_needed):
logger.debug("STEP 2 - Creating forward hyperedge to (multiple) xor - TAIL {0} -- HEAD {1} ".format(str(x_tail),str(xplace_head)))
hg.add_hyperedge(x_tail, xplace_head, name = " ", phero = 0.5)
#create forward normal hyperdge
head = []
for place in otherp_list:
out_arcs_l2 = get_outgoing_arcs(place,pnet)
for out_arc_l2 in out_arcs_l2:
trans2 = get_element(get_arc_target(out_arc_l2),pnet)
head.append(get_transition_name(trans2))
if(head):
logger.debug("STEP 2 - Creating real forward hyperedge - TAIL {0} -- HEAD {1} ".format(str(x_tail),str(head)))
hg.add_hyperedge(x_tail, head, name = " ", phero = 0.5, cost = 0.4, avail = 0.6, qual = 0.2, time = 0.99)
""" POST PROCESSING of tau-split/join generated by inductive miner """
hg = tau_post_processing(hg)
""" reduction of tau split/join """
#hg = tau_reduction(hg)
return hg
class TestKShortestHyperpaths(unittest.TestCase):
def setUp(self):
self.nielsenGraph = DirectedHypergraph()
self.nielsenGraph.add_node('s')
self.nielsenGraph.add_node('1')
self.nielsenGraph.add_node('2')
self.nielsenGraph.add_node('3')
self.nielsenGraph.add_node('4')
self.nielsenGraph.add_node('t')
self.nielsenGraph.add_hyperedge({'s'}, {'1'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'s'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1'}, {'2'}, weight=1)
self.nielsenGraph.add_hyperedge({'2'}, {'3'}, weight=1)
self.nielsenGraph.add_hyperedge({'1', '2'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'t'}, weight=1)
self.nielsenGraph.add_hyperedge({'2', '3'}, {'4'}, weight=1)
self.nielsenGraph.add_hyperedge({'4'}, {'1'}, weight=1)
# valid input tests
def test_raises_exception_if_H_not_B_hypegraph(self):
H = DirectedHypergraph()
H.add_nodes([1, 2, 3])
H.add_hyperedge([1], [2, 3])
source, destination = 1, 2
self.assertRaises(TypeError,
ksh.k_shortest_hyperpaths, H, source, destination, 1)
def test_raises_exception_if_H_not_hypegraph(self):
H = "DirectedHypergraph"
source, destination = 1, 2
self.assertRaises(TypeError,
ksh.k_shortest_hyperpaths, H, source, destination, 1)
def test_raises_exception_if_source_not_in_graph(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError,
ksh.k_shortest_hyperpaths, H, 3, destination, 1)
def test_raises_exception_if_destination_not_in_graph(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError,
ksh.k_shortest_hyperpaths, H, source, 3, 1)
def test_raises_exception_if_k_not_integer(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(TypeError,
ksh.k_shortest_hyperpaths,
H, source, destination, 0.1)
def test_raises_exception_if_k_not_positive(self):
H = DirectedHypergraph()
source, destination = 1, 2
H.add_nodes([source, destination])
self.assertRaises(ValueError,
ksh.k_shortest_hyperpaths,
H, source, destination, -4)
self.assertRaises(ValueError,
ksh.k_shortest_hyperpaths,
H, source, destination, 0)
# various cases
def test_returns_only_one_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(len(output), 1)
def test_returns_shortest_hyperpath_for_k_equals_one(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('3')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'s'}, {'2'}, weight=1)
H.add_hyperedge({'s'}, {'3'}, weight=1)
H.add_hyperedge({'1'}, {'t'}, weight=1)
H.add_hyperedge({'2', '3'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
hyperpath = output[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 2)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'t'}))
def test_returns_empty_list_if_no_s_t_path(self):
H = DirectedHypergraph()
H.add_node('s')
H.add_node('1')
H.add_node('2')
H.add_node('t')
H.add_hyperedge({'s'}, {'1'}, weight=1)
H.add_hyperedge({'1', '2'}, {'t'}, weight=1)
output = ksh.k_shortest_hyperpaths(H, 's', 't', 1)
self.assertEqual(output, [])
def test_returns_3_shortest_hypergraphs_for_nielsen_example_with_k_equal_3(
self):
threeShortest = ksh.k_shortest_hyperpaths(
self.nielsenGraph, 's', 't', 3)
self.assertEquals(len(threeShortest), 3)
# shortest path
hyperpath = threeShortest[0]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', '2', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 3)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1', '2'}, {'t'}))
# second shortest path
hyperpath = threeShortest[1]
self.assertEqual(hyperpath.get_node_set(), {'s', '1', '2', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 3)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'1'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'1', '2'}, {'t'}))
# third shortest path
hyperpath = threeShortest[2]
self.assertEqual(hyperpath.get_node_set(), {'s', '2', '3', '4', 't'})
self.assertEqual(len(hyperpath.get_hyperedge_id_set()), 4)
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'2'}))
self.assertTrue(hyperpath.get_hyperedge_id({'s'}, {'3'}))
self.assertTrue(hyperpath.get_hyperedge_id({'2', '3'}, {'4'}))
self.assertTrue(hyperpath.get_hyperedge_id({'4'}, {'t'}))
def initialize(H, source, target, node_dict={}):
'''
Finds the set of reachable and backwards-recoverable edges, sets up the tail reached counters, the inedge lists, and the heap pointer for each edge.
Initializes the taillength for each edge, and the heap, and the reachable edge counter
'''
edgedict = {}
#find reachable and backwards-recoverable edge list
reachableedges = findreachableandbackrecoverable(H, source, target)
#trim H
H2 = DirectedHypergraph()
if len(node_dict) == 0:
for v in H.node_iterator():
H2.add_node(v, H.get_node_attributes(v))
for edge in reachableedges:
H2.add_hyperedge(H.get_hyperedge_tail(edge),
H.get_hyperedge_head(edge),
weight=H.get_hyperedge_weight(edge))
H2.add_node('SUPERSOURCE', {'label': 'SUPERSOURCE'})
for edge in H2.get_forward_star('SUPERSOURCE'):
forwardstarlist = []
for v in H2.get_hyperedge_head(edge):
if len(H2.get_forward_star(v)) > 0:
forwardstarlist.append(v)
H2.remove_hyperedge(edge)
if len(forwardstarlist) > 0:
H2.add_hyperedge(['SUPERSOURCE'], forwardstarlist, weight=0)
else:
H2.add_hyperedge(['SUPERSOURCE'], [], weight=0)
H = H2
for v in H.get_node_set():
#need to remap the edges because just calling remove_node(v) removes also all the hyperedges v is in
if len(H.get_forward_star(v)) == 0 and v != 'SUPERTARGET':
#find edges that need to be replaced
backedges = H.get_backward_star(v)
for e in backedges:
tail = H.get_hyperedge_tail(e)
head = H.get_hyperedge_head(e)
head.remove(v)
w = H.get_hyperedge_weight(e)
H.remove_hyperedge(e)
H.add_hyperedge(tail, head, weight=w)
H.remove_node(v)
reachableedges = []
H2.add_node('SUPERSOURCE', {'label': 'SUPERSOURCE'})
for edge in H.hyperedge_id_iterator():
reachableedges.append(edge)
#initialize edgedict
for e in H.hyperedge_id_iterator():
edgedict[e] = {
'isremoved': False,
'bestinedges': [],
'candidateinedges': [],
'tailcount': len(H.get_hyperedge_tail(e))
}
#initialize taildistancelist
taildistancelist = {}
for e in reachableedges:
taildistancelist[e] = 'inf'
#initialize reachableedgecounter
reachableedgecounter = len(reachableedges)
#initialize heap
heap = []
entry_finder = {
} # mapping of tasks to entries, this and the line below are strictly for the heap
counter = itertools.count() # unique sequence count
for e in H.get_forward_star(source):
if e in reachableedges:
add_node(heap, e, weight(H, [e]), counter, entry_finder)
#initialize reachedtable
reachedtable = {}
for e in H.hyperedge_id_iterator():
reachedtable[e] = []
return reachableedges, edgedict, taildistancelist, heap, reachableedgecounter, reachedtable, entry_finder, counter, H
@author: UNIST
'''
from halp.directed_hypergraph import DirectedHypergraph
from org.emettelatripla.util.util import *
from org.emettelatripla.aco.ACO_directed_hypergraph import *
from org.emettelatripla.aco.ACO_util import *
import logging
# Initialize an empty hypergraph
H = DirectedHypergraph()
# Add nodes 's' and 't' individually with arbitrary attributes
H.add_node('A',
sink=False,
source=True,
cost=0.245,
avail=0.99,
qual=0.7,
time=0.78)
H.add_node('B',
sink=False,
source=False,
cost=0.245,
avail=0.99,
qual=0.7,
time=0.78)
H.add_node('C',
sink=False,
source=False,
cost=0.245,
avail=0.99,
@author: UNIST
'''
from halp.directed_hypergraph import DirectedHypergraph
from org.emettelatripla.util.util import *
from org.emettelatripla.aco import ACO_util
from org.emettelatripla.aco.ACO_util import calc_utility_avail
from org.emettelatripla.aco.ACO_util import calc_utility_cost
from org.emettelatripla.aco.ACO_util import calc_utility_time
from org.emettelatripla.aco.ACO_util import calc_utility_qual
# Initialize an empty hypergraph
H = DirectedHypergraph()
# Add nodes 's' and 't' individually with arbitrary attributes
H.add_node('A', sink=False, source=True, cost=0.245, avail=0.99, qual=0.7, time=0.75, phero=0.0)
H.add_node('B', sink=False, source=False, cost=0.645, avail=0.92, qual=0.7, time=0.79, phero=0.0)
H.add_node('C', sink=False, source=False, cost=0.745, avail=0.69, qual=0.7, time=0.98, phero=0.0)
H.add_node('D', sink=False, source=False, cost=0.845, avail=0.99, qual=0.5, time=0.28, phero=0.0)
H.add_node('E', sink=False, source=False, cost=0.445, avail=0.99, qual=0.3, time=0.48, phero=0.0)
H.add_node('G', sink=False, source=False, cost=0.545, avail=0.99, qual=0.7, time=0.98, phero=0.0)
H.add_node('H', sink=False, source=False, cost=0.245, avail=0.99, qual=0.7, time=0.68, phero=0.0)
H.add_node('F', source=False, sink=True, cost=0.1, avail=0.98, qual=0.4, time=0.45, phero=0.0)
hyperedges = [(['A'], ['B'], {'weight': 2}),
(['A'], ['D','E'], {'weight': 100}),
(['A'], ['G'], {'weight': 1}),
(['B'], ['C'], {'weight': 3}),
(['D','E'], ['F'], {'weight': 3}),
(['E','H'], ['F'], {'weight': 3}),
(['G'], ['H'], {'weight': 3}),