def get_frequency(G_q, train_g_path):
"""
# Projecting a Query Graph to BoFG histogram
"""
train_lst = fn.get_file_list(train_g_path, ".g")
freq_lst = []
for g_tr in train_lst:
G_tr = nx.read_gpickle(train_g_path + g_tr)
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open(train_g_path + g_tr[:-2] + ".nodelabel", "r") as nl:
G_tr_nlabels = json.load(nl)
G_q_nlabels = [int(n_tup[1]["label"]) for n_tup in G_q.nodes(data=True)]
if fn.is_subset(G_tr_nlabels, G_q_nlabels):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match("label", 1)
em = iso.numerical_edge_match("weight", 0)
GM = iso.GraphMatcher(G_q, G_tr, node_match=nm, edge_match=em)
frequency = len(list(GM.subgraph_isomorphisms_iter()))
if frequency > 0:
BoFG_ID = int(g_tr[-5:-2])
freq_lst.append((BoFG_ID, frequency))
return freq_lst
def ___non_isomorphic_graphs_dict(nx_objects):
# nx_objects = [nx.relabel.convert_node_labels_to_integers(o, label_attribute='number') for o in objects]
# Add labels as attributes
for g in nx_objects:
node_number = len(g.nodes())
labels = random.sample(range(node_number), node_number)
i = 0
for n in g.nodes():
g.nodes[n]['number'] = labels[i]
i += 1
# Filter out isomorphic graphs
nm = iso.numerical_node_match('number', 0)
graphs = dict()
checked = []
for g in nx_objects:
if g not in checked:
isomorphic = [
x for x in nx_objects if iso.is_isomorphic(x, g, node_match=nm)
]
graphs[g] = len(isomorphic)
checked = checked + isomorphic
return graphs
def check_isomorphism(json_1, json_2):
g1 = json.loads(json_1)
g2 = json.loads(json_2)
try:
nodes_1 = [(i['id'], {'type': i['type']}) for i in g1['nodes']]
edges_1 = [(i['from'],i['to'], {'type': i['type']}) for i in g1['edges']]
nodes_2 = [(i['id'], {'type': i['type']}) for i in g2['nodes']]
edges_2 = [(i['from'],i['to'], {'type': i['type']}) for i in g2['edges']]
except KeyError:
return g1 == g2 # if graph isomorphism check is not possible, fall back to simple json-level equality check
graph_1 = nx.Graph()
graph_1.add_nodes_from(nodes_1)
graph_1.add_edges_from(edges_1)
graph_2 = nx.Graph()
graph_2.add_nodes_from(nodes_2)
graph_2.add_edges_from(edges_2)
nm = iso.numerical_node_match('type',-1)
em = iso.numerical_edge_match('type',-1)
return nx.is_isomorphic(graph_1, graph_2, node_match=nm, edge_match=em)
def get_frequency(G_q, train_g_path):
"""
# Projecting a Query Graph to BoFG histogram
"""
train_lst = fn.get_file_list(train_g_path, '.g')
freq_lst = []
for g_tr in train_lst:
G_tr = nx.read_gpickle(train_g_path + g_tr)
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open(train_g_path + g_tr[:-2] + '.nodelabel', 'r') as nl:
G_tr_nlabels = json.load(nl)
G_q_nlabels = [
int(n_tup[1]['label']) for n_tup in G_q.nodes(data=True)
]
if fn.is_subset(G_tr_nlabels, G_q_nlabels):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match('label', 1)
em = iso.numerical_edge_match('weight', 0)
GM = iso.GraphMatcher(G_q, G_tr, node_match=nm, edge_match=em)
frequency = len(list(GM.subgraph_isomorphisms_iter()))
if frequency > 0:
BoFG_ID = int(g_tr[-5:-2])
freq_lst.append((BoFG_ID, frequency))
return freq_lst
def isomorphic_molecules(graph0, graph1):
"""Check whether two molecule graphs are isomorphic."""
em = iso.numerical_edge_match('bonds', 1)
nm = iso.numerical_node_match('number', 1)
isomorphic = nx.is_isomorphic(graph0, graph1, edge_match=em, node_match=nm)
return isomorphic
def _matcher_factory(self, graph_component, value_type):
factory_dict = dict(node=dict(), edge=dict())
# TODO Is this dangerous?
numerical_default = 0.
categorical_default = None
factory_dict['node']['categorical'] = iso.categorical_node_match(
self.label, categorical_default)
factory_dict['node']['numerical'] = iso.numerical_node_match(
self.label, numerical_default)
factory_dict['edge']['categorical'] = iso.categorical_edge_match(
self.label, categorical_default)
factory_dict['edge']['numerical'] = iso.numerical_edge_match(
self.label, numerical_default)
return factory_dict[graph_component][value_type]
def determine_reward(self, state, features, workflow_vals):
reward = 0
if np.shape(state)[0] != np.shape(self.truth_state)[0]:
self.terminated = False
return reward
#print('workflowvals and truth',workflow_vals,self.workflow_vals_truth)
graph_current = environment.create_DAG(state, features)
graph_truth = environment.create_DAG(self.truth_state,
self.truth_features)
nm = iso.numerical_node_match('feat', range(self.node_types))
if nx.is_isomorphic(graph_current, graph_truth, node_match=nm):
reward = 1000
elif self.loss != 0:
reward = -1
'''if workflow_vals[-1] == self.workflow_vals_truth[-1]:
#print('WOW')
reward = 1000'''
self.terminated = True
return reward
def reactant_indices(R1, R2, P, broken_bond):
"""Match the indices of a pair of reactants from a
product and broken bond.
Parameters
----------
R1 : networkx MultiGraph
Graph representing reactant 1
R2 : networkx MultiGraph
Graph representing reactant 2
P : networkx MultiGraph
Graph representing the product
broken_bond : list (2,)
Indices representing the edge of the product
to be removed.
Returns
-------
pindex: ndarrays (n,)
Indices of the product graph sorted by the order of
the reactants indices.
"""
GM = nx.algorithms.isomorphism.GraphMatcher
em = iso.numerical_edge_match('bonds', 1)
nm = iso.numerical_node_match('number', 1)
Pgraph = P.copy()
u, v = broken_bond
Pgraph.graph.remove_edge(u, v)
Rgraph = R1 + R2
gm = GM(Pgraph.graph, Rgraph.graph, edge_match=em, node_match=nm)
gm.is_isomorphic()
pindex = np.empty(len(Pgraph), dtype=int)
for k, v in gm.mapping.items():
pindex[k] = v
return pindex
def FindUniqueTopologies(traces):
"""
Find all of the unique topologies within this set of traces. A unique topology
either differs in graph structure (parent/child) or function called at a node.
@param traces: the list of traces to compare topologies
"""
# node labels must match
node_match = isomorphism.numerical_node_match('label', None)
unique_graphs = []
durations = []
nodes = []
for trace in traces:
graph_from_trace = ConstructGraphFromTrace(trace)
nodes.append(len(trace.nodes))
durations.append(trace.duration)
# see if this matches any exists graphs
unique_graph = True
for unique_graph in unique_graphs:
if nx.is_isomorphic(graph_from_trace, unique_graph):
unique_graph = False
break
# create new entry for unique graph
if unique_graph:
unique_graphs.append(graph_from_trace)
print(len(traces))
print(statistics.mean(nodes))
print(statistics.pstdev(nodes))
print(statistics.mean(durations))
print(statistics.pstdev(durations))
print(len(unique_graphs))
G_q.add_edge( v1, v2, weight=order_dist )
"""
# Projecting a Query Graph to BoFG histogram
"""
train_path = 'train/model_1/graph/'
train_lst = fn.get_file_list( train_path, '.g' )
for g_tr in train_lst:
G_tr = nx.read_gpickle( train_path + g_tr )
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open( train_path + g_tr[:-2] + '.nodelabel', 'r') as nl:
G_tr_nlabels = json.load( nl )
G_q_nlabels = [ int(n_tup[1]['label']) for n_tup in G_q.nodes(data=True)]
if fn.is_subset( G_tr_nlabels, G_q_nlabels ):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match('label', 1)
em = iso.numerical_edge_match('weight', 0)
GM = iso.GraphMatcher( G_q, G_tr, node_match=nm, edge_match=em )
#==============================================================================
# for subgraph in GM.subgraph_isomorphisms_iter():
# print subgraph
#==============================================================================
if len(list(GM.subgraph_isomorphisms_iter())) > 0:
BoFG_ID = int( g_tr[-5:-2] )
def subgraph_isomorphism(graph, sub):
nm = iso.numerical_node_match('label', -1)
em = iso.numerical_edge_match('label', -1)
matcher = iso.DiGraphMatcher(graph, sub, node_match=nm, edge_match=em)
return matcher.subgraph_is_isomorphic()
def graph_isomorphism(graph1, graph2):
nm = iso.numerical_node_match('label', -1)
em = iso.numerical_edge_match('label', -1)
matcher = iso.DiGraphMatcher(graph1, graph2, node_match=nm, edge_match=em)
return matcher.is_isomorphic()
from networkx import Graph, MultiGraph
from ase import Atoms, Atom
from ase.constraints import FixConstraint, FixBondLengths
from ase.data import chemical_symbols
import networkx.algorithms.isomorphism as iso
import numpy as np
import copy
import warnings
try:
from builtins import super
except (ImportError):
from __builtin__ import super
sym = np.array(chemical_symbols)
em = iso.numerical_edge_match('bonds', 1)
nm = iso.numerical_node_match('number', 1)
class Gratoms(Atoms):
"""Graph based atoms object.
An Integrated class for an ASE atoms object with a corresponding
Networkx Graph.
"""
def __init__(self,
symbols=None,
positions=None,
numbers=None,
tags=None,
momenta=None,
masses=None,
if v1 == v2: # Remove Nodes self to self
del G_q_od[v1][v2]
else: # Modify Weights of Other Nodes & Assign them to Graph G
# Edge Label
order_dist = G_q_od[v1][v2]
order_dist -= 1
G_q.add_edge(v1, v2, weight=order_dist)
"""
# Projecting a Query Graph to BoFG histogram
"""
train_path = 'train/model_1/graph/'
train_lst = fn.get_file_list(train_path, '.g')
for g_tr in train_lst:
G_tr = nx.read_gpickle(train_path + g_tr)
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open(train_path + g_tr[:-2] + '.nodelabel', 'r') as nl:
G_tr_nlabels = json.load(nl)
G_q_nlabels = [int(n_tup[1]['label']) for n_tup in G_q.nodes(data=True)]
if fn.is_subset(G_tr_nlabels, G_q_nlabels):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match('label', 1)
em = iso.numerical_edge_match('weight', 0)
GM = iso.GraphMatcher(G_q, G_tr, node_match=nm, edge_match=em)
#==============================================================================
# for subgraph in GM.subgraph_isomorphisms_iter():
# print subgraph
#==============================================================================
if len(list(GM.subgraph_isomorphisms_iter())) > 0:
BoFG_ID = int(g_tr[-5:-2])
label='descriptor',
value='yutz'), ValueError),
(dict(graph_component='edge',
query_type='goyish',
label='descriptor',
value='yutz'), ValueError)
])
def test_graph_query_params_errors(args, Error):
with pytest.raises(Error):
query_params = GraphQueryParams(**args)
query_params.set_value_type()
@pytest.mark.parametrize('query_param_args,expected_match_function', [
(dict(graph_component='node', label='a_number', value_type='numerical'),
iso.numerical_node_match('a_number', np.nan)),
(dict(graph_component='node', label='a_category',
value_type='categorical'),
iso.categorical_node_match('a_category', None)),
(dict(graph_component='edge', value_type='numerical',
label='a_number'), iso.numerical_edge_match('a_number', np.nan)),
(dict(graph_component='edge', value_type='categorical',
label='a_category'), iso.categorical_edge_match('a_category', None)),
])
def test_graph_query_params_match_fn(query_param_args,
expected_match_function):
# Comparing byte code idea from
# https://stackoverflow.com/questions/20059011/check-if-two-python-functions-are-equal
query_params = GraphQueryParams(**query_param_args)
if query_params.value is not None:
query_params.set_value_type()
nx.draw(G_pat)
G_subgraphs = build_subgraphs(
G, induced='vertex'
) # In this example, if induced = 'nodes' it won't find any isomorphisms.
# Categorical match functions
nm_cat = isomorphism.categorical_node_match("attr", 1)
em_cat = isomorphism.categorical_edge_match("attr", 1)
print find_sub_iso(G_subgraphs,
G_pat,
node_match=nm_cat,
edge_match=em_cat)
# Numerical match functions
nm_num = isomorphism.numerical_node_match(
"attr", 0, atol=0.5,
rtol=1e-05) # Matches if |x-y|<= atol + abs(y)*rtol
print find_sub_iso(G_subgraphs, G_pat, node_match=nm_num, edge_match=None)
# Generic match functions
op = lambda x, y: x >= y
nm_gen = isomorphism.generic_node_match("attr", 0, op)
sub_iso = find_sub_iso(G_subgraphs,
G_pat,
node_match=nm_gen,
edge_match=None)
if sub_iso:
print sub_iso[0]["nodes"].values()
