def ged(args):
timeout = 300
ind1, ind2 = args
G1 = cgp_2_dag(ind1.active_net_list())
G2 = cgp_2_dag(ind2.active_net_list())
#G1 = ind1
#G2 = ind2
duration = 0
start = time.time()
sim_gp = None
while duration <= timeout and sim_gp == None:
for v in similarity.optimize_graph_edit_distance(G1,
G2,
node_match=match):
sim_gp = v
duration = time.time() - start
if duration > timeout:
print('Timeout')
break
break
print('SIM: {}'.format(sim_gp))
return sim_gp, ind2
def compute_ged(sample_graph: nx.DiGraph, reference_graph: nx.DiGraph, use_edge_cost: bool = False) \
-> Tuple[float, float]:
ged_generator = optimize_graph_edit_distance(
sample_graph,
reference_graph,
node_match=lambda v, u: v['label'] == u['label'],
edge_match=lambda e1, e2: e1['label'] == e2['label'],
edge_ins_cost=lambda e: 1 if use_edge_cost else 0,
edge_del_cost=lambda e: 1 if use_edge_cost else 0)
total_size = sample_graph.number_of_nodes(
) + reference_graph.number_of_nodes()
if use_edge_cost:
total_size += sample_graph.number_of_edges(
) + reference_graph.number_of_edges()
ged = total_size
while True:
try:
new_ged = func_timeout(0.1, next, args=(ged_generator, ))
ged = new_ged
except (FunctionTimedOut, StopIteration):
break
return ged, total_size
def test_optimize_graph_edit_distance(self):
G1 = circular_ladder_graph(2)
G2 = circular_ladder_graph(6)
bestcost = 1000
for cost in optimize_graph_edit_distance(G1, G2):
assert cost < bestcost
bestcost = cost
assert bestcost == 22
def compGraphSimilarity(t1, t2, hyper=True, debug=False):
if len(t1) == 0 and len(t2) == 0:
return {}, 0
res = 0
simi = {}
keys1 = list(t1.keys())
keys2 = list(t2.keys())
share = [x for x in keys1 if x in keys2]
keys = list(set(keys1 + keys2))
for key in keys:
if key not in keys1:
triples1 = []
triples2 = t2[key]
if key not in keys2:
triples2 = []
triples1 = t1[key]
if key in share:
triples1 = t1[key]
triples2 = t2[key]
if not hyper:
dg1 = createGraph(triples1)
dg2 = createGraph(triples2)
else:
dg1 = createHyperGraph(triples1)
dg2 = createHyperGraph(triples2)
nor = max(graph_edit_distance(dg1, nx.DiGraph()),
graph_edit_distance(dg2, nx.DiGraph()))
if len(dg1.nodes()) <= 8 or len(dg2.nodes()) <= 8:
simi[key] = graph_edit_distance(dg1, dg2)
print('graph edit distance ...')
if debug:
print(f'len of nodes1: {len(dg1.nodes())}')
print(f'len of edges1: {len(dg1.edges())}')
print(f'len of nodes2: {len(dg2.nodes())}')
print(f'len of edges2: {len(dg2.edges())}')
else:
print('try optimize_graph_edit_distance function ...')
print(f'len of nodes1: {len(dg1.nodes())}')
print(f'len of edges1: {len(dg1.edges())}')
print(f'len of nodes2: {len(dg2.nodes())}')
print(f'len of edges2: {len(dg2.edges())}')
ith = 0
for v in optimize_graph_edit_distance(dg1, dg2):
ith += 1
minv = v
print(f'optimize {ith} times: {v}')
simi[key] = minv
simi[key] = simi[key] / nor
for i, j in simi.items():
res += j
res = res / len(simi)
return simi, res
def sim_measure(G1, G2):
for distance in optimize_graph_edit_distance(
G1,
G2,
node_subst_cost=node_subst_cost,
node_del_cost=lambda e: 2,
node_ins_cost=lambda e: 2,
edge_subst_cost=edge_subst_cost,
edge_del_cost=lambda e: 2,
edge_ins_cost=lambda e: 2):
max_distance = 8 * (max(len(G1.nodes), len(G2.nodes)) +
max(len(G1.edges), len(G2.edges)) + 1)
yield 1 - (distance / max_distance)