def test_dfs(self):
for i in range(0, len(self.primary)):
primary = list(nx.dfs_edges(self.primary[i], source=0))
followup = list(
nx.dfs_edges(self.followup[i],
source=self.n_node_range[1] + 1))
self.assertGreaterEqual(len(list(followup)), len(list(primary)))
def _get_relevant_vars(self, g):
"""
Args
----
g : nx.DiGraph
A graph of variable dependencies.
Returns
-------
dict
Dictionary that maps a variable name to all other variables in the
graph that are relevant to it.
"""
succs = {}
for nodes in self.inputs:
for node in nodes:
succs[node] = set([v for u, v in nx.dfs_edges(g, node)])
succs[node].add(node)
relevant = {}
grev = g.reverse()
for nodes in self.outputs:
for node in nodes:
relevant[node] = set()
preds = set([v for u, v in nx.dfs_edges(grev, node)])
preds.add(node)
for inps in self.inputs:
for inp in inps:
common = preds.intersection(succs[inp])
relevant[node].update(common)
relevant.setdefault(inp, set()).update(common)
return relevant
def _get_relevant_vars(self, g):
"""
Args
----
g : nx.DiGraph
A graph of variable dependencies.
Returns
-------
dict
Dictionary that maps a variable name to all other variables in the
graph that are relevant to it.
"""
succs = {}
for nodes in self.inputs:
for node in nodes:
succs[node] = set([v for u, v in nx.dfs_edges(g, node)])
succs[node].add(node)
relevant = {}
grev = g.reverse()
for nodes in self.outputs:
for node in nodes:
relevant[node] = set()
preds = set([v for u, v in nx.dfs_edges(grev, node)])
preds.add(node)
for inps in self.inputs:
for inp in inps:
common = preds.intersection(succs[inp])
relevant[node].update(common)
relevant.setdefault(inp, set()).update(common)
return relevant
def test_dfs(self):
"""
Run DFS and verify that the list of edges returned for the
followup case is not longer than the primary case.
:return:
"""
for i in range(0, len(self.primary)):
# Choose a node that has at least degree one
src = list(self.primary[i].out_edges)[0][0]
primary = list(nx.dfs_edges(self.primary[i], source=src))
followup = list(nx.dfs_edges(self.followup[i], source=src))
self.assertGreaterEqual(len(list(followup)), len(list(primary)))
def belief_propagation(graph, query_node=None):
"""Belief propagation.
Perform exact inference on tree structured graphs.
Return the belief of all query_nodes.
"""
if query_node is None: # pick random node
query_node = choice(graph.get_vnodes())
# Depth First Search to determine edges
dfs = nx.dfs_edges(graph, query_node)
# Convert tuple to reversed list
backward_path = list(dfs)
forward_path = reversed(backward_path)
# Messages in forward phase
for (v, u) in forward_path: # Edge direction: u -> v
msg = u.spa(v)
graph[u][v]['object'].set_message(u, v, msg)
# Messages in backward phase
for (u, v) in backward_path: # Edge direction: u -> v
msg = u.spa(v)
graph[u][v]['object'].set_message(u, v, msg)
# Return marginal distribution
return query_node.belief()
def root_tree(self, tree: nx.Graph, root_sample: str,
remaining_samples: List[str]):
"""Roots a tree produced by UPGMA.
Adds the root at the top of the UPGMA reconstructed tree. By the
ultrametric assumption, the root is placed as the parent to the last
two unjoined nodes.
Args:
tree: Networkx object representing the tree topology
root_sample: Ignored in this case, the root is known in this case
remaining_samples: The last two unjoined nodes in the tree
Returns:
A rooted tree.
"""
tree.add_node("root")
tree.add_edges_from([("root", remaining_samples[0]),
("root", remaining_samples[1])])
rooted_tree = nx.DiGraph()
for e in nx.dfs_edges(tree, source="root"):
rooted_tree.add_edge(e[0], e[1])
return rooted_tree
def linearize(filename):
graph_name = filename.split('.')[0] + '.graphml'
g = nx.read_graphml(graph_name)
print nx.info(g)
# get first strong connected component
con = list(nx.strongly_connected_component_subgraphs(g))
con.sort(key=lambda x: len(x), reverse=True)
print[len(item) for item in con]
print nx.info(con[0])
dfs_edges = list(nx.dfs_edges(con[0]))
dfs_edges.append((dfs_edges[-1][-1], dfs_edges[0][0]))
#print dfs_edges
with open(filename.split('.')[0] + '.linear.edges', 'w') as f:
for item in dfs_edges:
f.write(item[0] + ' ' + item[1] + ' ' +
str(con[0].edge[item[0]][item[1]]['ew']) + '\n')
def monotone_draw(G, root, edge_length):
""" take tree
assign unique slope
use tan-1 for slopes
if path, may consider same slop
run DFS
"""
i = 0 # starting with zero angle
vertexmanager.setCoordinate(G.node[root], 0.0, 0.0)
for e in nx.dfs_edges(G, root):
u, v = e
slp = math.atan(i)
x_u, y_u = vertexmanager.getCoordinate(G.node[u])
x_v = x_u + math.cos(slp)
y_v = y_u + math.sin(slp)
vertexmanager.setCoordinate(G.node[v], x_v + edge_length,
y_v + edge_length)
i = i + 1
return G
def resolve(edges, relevant_nodes=None):
relevant_nodes_provided = bool(relevant_nodes)
relevant_nodes = relevant_nodes or []
graph = nx.DiGraph()
for e, v in edges:
graph.add_edge(e, v)
if not relevant_nodes_provided:
relevant_nodes.append(e)
relevant_nodes.append(v)
condition = BelongsToNodes(relevant_nodes)
ordered_paths = []
for node in relevant_nodes:
dfs_edges = nx.dfs_edges(graph, node)
path = make_path(dfs_edges, condition)
ordered_paths.append(path)
ordered_paths.sort(key=lambda x: len(x))
order = []
for path in ordered_paths:
for path_part in path:
if path_part not in order:
order.append(path_part)
return order
def own_DFS(graph, s, dest=0, paths=False):
visited = set()
def dfs(G, source=None):
if source is None:
nodes = G
else:
nodes = [source]
for start in nodes:
if start in visited:
continue
visited.add(start)
stack = [(start, iter(G[start]))]
while stack:
parent, children = stack[-1]
try:
child = next(children)
if child not in visited:
yield parent, child
visited.add(child)
stack.append((child, iter(G[child])))
except StopIteration:
stack.pop()
path = []
edges = list(nx.dfs_edges(graph, s))
edges.reverse()
for x in edges:
if x[1] == dest:
path.append(dest)
dest = x[0]
path.append(s)
path.reverse()
return path if paths else dfs(graph, s)
def get_dependency_rules(graph, root_node=None,
node_attrib='label', edge_attrib='label'):
"""
Given a graph, returns a set of its dependency rules. If root_node is
given, returns only those rules from the subgraph rooted at that node.
A dependency rules is represented by a
(source node label, edge/relation label, target node label) triple, e.g.
('woman', 'dt', 'the').
Returns
-------
rules : set of (str, str, str) tuples
each dependency production rule is represented by a
(source node label, edge/relation label, target node label)
tuple
"""
rules = set()
if not root_node:
# root node is the first element in a topological sort of the graph
root_node = nx.topological_sort(graph)[0]
for source, target in nx.dfs_edges(graph, root_node):
rules.add( (ensure_utf8(graph.node[source].get(node_attrib, source)),
ensure_utf8(graph[source][target].get(edge_attrib, '')),
ensure_utf8(graph.node[target].get(node_attrib, target))) )
return rules
def find_all_paths(graph, start, end):
# Think about the case where start is also an end
all_paths = []
current_path = []
def append_path(p):
tot_weight = 0
for src, tgt in current_path:
tot_weight += graph[src][tgt].get("weight", 1)
all_paths.append((path_to_str(current_path), tot_weight))
for e in nx.dfs_edges(nx.bfs_tree(graph, start)):
if e[0] == start: #We start a new path
if len(current_path):
# Do we end in an out node ?
append_path(current_path)
current_path = []
if e[1] in end: # We found a path
append_path(current_path)
current_path.append(e)
if len(current_path):
append_path(current_path)
return all_paths
def find_dfs_spanning(G):
"""Find edges of the DFS spanning tree for graph G
This is used to visualize the spanning tree (spanning forest,
tree cover) in example small graphs. This function is also used
to compute DFS intervals, among others in `find_dfs_intervals()`
Parameters
----------
G : NetworkX graph
Graph to find spanning-tree in.
Returns
-------
edges : list
A list of edges in the depth-first-search.
Examples
--------
>>> G = nx.path_graph(5)
>>> find_dfs_spanning(G)
[(0, 1), (1, 2), (2, 3), (3, 4)]
Notes
-----
The source is chosen arbitrarily and repeatedly until all
components in the graph are searched.
"""
# this may not cover all nodes
return list(nx.dfs_edges(G))
def isConnected(self, G):
isConnected = False
for node in G.nodes:
lista = list(nx.dfs_edges(G, source=node))
if self.isConnectedLocal(node, lista, len(G.nodes)):
return True
return False
def share_from_user(G, u, fl_dict):
# compute BFS/DFS-tree with root u
# tree_edges = nx.bfs_edges(G, u) # use built-in
# tree_edges = find_bfs_edges(G, u) # use weighted
tree_edges = nx.dfs_edges(G, u)
# (exact) my friend list
my_list = []
for v in G.neighbors(u):
my_list.append((u, v, 1.0))
fl_dict[u].extend(my_list)
# init
list_at_node = [[] for v in G.nodes_iter()]
# propagate
for (v,w) in tree_edges:
# print "v,w =", v, w
t_level = G.edge[v][w]['t']
if v == u: # prepare
a_list = prepare_friend_list(G, u, t_level)
# print "len(a_list) =", len(a_list)
list_at_node[w] = a_list
else: # forward
new_list = forward_friend_list(list_at_node[v], t_level)
# print "len(new_list) =", len(new_list)
list_at_node[w] = new_list
# add new_list into fl_dict[w]
fl_dict[w].extend(list_at_node[w])
def SST(G):
g = G.copy()
for edge in g.edges():
g.add_edge(edge[0], edge[1], score=0)
N = 50
nodes = G.nodes()
reNodes = []
flag = {}
for node in nodes:
flag[node] = 0
while N > 0:
N -= 1
infected = random.choice(nodes) # 初始为1个感染节点
for edge in nx.dfs_edges(G, infected):
g.add_edge(edge[0],
edge[1],
score=g.edge[edge[0]][edge[1]]['score'] + 1)
edgesDict = nx.get_edge_attributes(g, 'score')
edgeRank = sorted(edgesDict.iteritems(), key=lambda x: x[1], reverse=True)
for edge in edgeRank:
if flag[edge[0][0]] == 0:
flag[edge[0][0]] = 1
reNodes.add(edge[0][0])
if flag[edge[0][1]] == 0:
flag[edge[0][1]] = 1
reNodes.add(edge[0][1])
return reNodes
def est_num_matches_powerlaw_graph(self, subg):
dfs_edges = list(nx.dfs_edges(subg))
non_dfs_edges = self.set_minus(subg.edges(), dfs_edges)
gTmp = nx.Graph()
cur_num_matches = 1
for e in dfs_edges: #Compute case I
if (cur_num_matches == 1):
cur_num_matches *= (self.sum_of_power[1])
else:
node0, node1 = e[0], e[1]
deg = self.get_degree(gTmp, node0)
if (deg == 0):
deg = self.get_degree(gTmp, node1)
if (deg == 0):
raise (
Exception('We do not expect both node has degree 0.'))
r1 = self.cal_gamma1(deg)
cur_num_matches *= r1
gTmp.add_edge(*e)
for e in non_dfs_edges: #Compute case II
node0, node1 = e[0], e[1]
deg0 = self.get_degree(gTmp, node0)
deg1 = self.get_degree(gTmp, node1)
r2 = self.cal_gamma2(deg0, deg1)
cur_num_matches *= r2
gTmp.add_edge(*e)
gTmp.clear()
return cur_num_matches
def join_count_tables(table_info, parsed_join_clauses, count_tables, join_how):
g = make_join_graph(parsed_join_clauses)
df_ret = None
for edge in nx.dfs_edges(g, source=parsed_join_clauses[0][0]):
t1, t2 = edge
join_columns = g.edges[edge]["join_columns"]
cs1 = join_columns[t1] # columns to join
cs2 = join_columns[t2] # columns to join
if df_ret is None:
df_ret = count_tables[t1].add_prefix(t1 + ":")
log.info("Joining {} and {} on {}".format(
t1, t2, ", ".join([c1 + "=" + c2 for c1, c2 in zip(cs1, cs2)])))
# NOTE: Since we are traversing the join graph in a DFS order, it is
# guaranteed that at this point `df_ret` already contains `t1.c1`.
df_ret = df_ret.merge(
count_tables[t2].add_prefix(t2 + ":"),
how=join_how,
left_on=["{}:{}".format(t1, c) for c in cs1],
right_on=["{}:{}".format(t2, c) for c in cs2],
)
# NOTE: `np.nanprod()` treats `np.nan` as 1.
df_ret["cnt"] = np.nanprod([df_ret[f"{t}:cnt"] for t in table_info],
axis=0)
return df_ret
def downstream_edge_info(wg, n):
downstream_edges = list(nx.dfs_edges(wg, n))
down_switch_dict = {}
e_file = gv.filepaths["edges"]
for d in downstream_edges:
# edge info:
p = d[0].lstrip()
q = d[1].lstrip()
edge_of_path_name_1 = p + "_to_" + q
edge_of_path_name_2 = q + "_to_" + p
edge_search_result_1 = db._edge_search(edge_of_path_name_1)
edge_search_result_2 = db._edge_search(edge_of_path_name_2)
# try:
with open(e_file, 'r+') as f:
csvr = csv.reader(f)
csvr = list(csvr)
for row in csvr:
if row[0].lstrip() == edge_of_path_name_1 or row[0].lstrip(
) == edge_of_path_name_2:
if edge_search_result_1 != 0 or edge_search_result_2 != 0:
if row[1].lstrip() == "switch":
# print("[i] Downstream Switch: {}, Status: {}, Availability: {}".format(row[0], row[4],
# row[13]))
down_switch_dict[row[0]] = row[4]
if row[1].lstrip() == "transformer":
pass
# print("[i] Downstream Transformer: {}, Status: {}, Availability: {}".format(row[0],
# row[4],
# row[13]))
# except:
# print("[x] Error in downstream edge search.")
return down_switch_dict
def _dfs_edges(graph, source, max_steps=None):
"""
Perform a depth-first search on the given DiGraph, with a limit on maximum steps.
:param networkx.DiGraph graph: The graph to traverse.
:param Any source: The source to begin traversal.
:param int max_steps: Maximum steps of the traversal, or None if not limiting steps.
:return: An iterator of edges.
"""
if max_steps is None:
yield networkx.dfs_edges(graph, source)
else:
steps_map = defaultdict(int)
traversed = {source}
stack = [source]
while stack:
src = stack.pop()
for dst in graph.successors(src):
if dst in traversed:
continue
traversed.add(dst)
dst_steps = max(steps_map[src] + 1, steps_map[dst])
if dst_steps > max_steps:
continue
yield src, dst
steps_map[dst] = dst_steps
stack.append(dst)
def renumber_nodes(G, start=1):
"""Renumber nodes so that NeuronLand converter does not mess up.
Returns: (new_graph, node_map)
node_graph: a new DiGraph with the nodes numbered by bfs sequence.
node_map: dict mapping node number in G to that in node_graph
"""
ret = nx.DiGraph()
node_map = {}
# The nodes are connected as child->parent, we are starting from root,
# hence reverse
for ii, (n1, n2) in enumerate(nx.dfs_edges(G, start)):
m1 = ii+1
m2 = ii+2
if n1 in node_map:
m1 = node_map[n1]
else:
node_map[n1] = m1
ret.add_node(m1)
ret.node[m1].update(G.node[n1])
node_map[n2] = m2
ret.add_edge(m1, m2, length=G[n1][n2])
ret.node[m2].update(G.node[n2])
ret.node[m2]['p'] = m1
ret.node[1]['p'] = -1
return ret, node_map
def _dfs_edges(graph, source, max_steps=None):
"""
Perform a depth-first search on the given DiGraph, with a limit on maximum steps.
:param networkx.DiGraph graph: The graph to traverse.
:param Any source: The source to begin traversal.
:param int max_steps: Maximum steps of the traversal, or None if not limiting steps.
:return: An iterator of edges.
"""
if max_steps is None:
yield networkx.dfs_edges(graph, source)
else:
steps_map = defaultdict(int)
traversed = { source }
stack = [ source ]
while stack:
src = stack.pop()
for dst in graph.successors(src):
if dst in traversed:
continue
traversed.add(dst)
dst_steps = max(steps_map[src] + 1, steps_map[dst])
if dst_steps > max_steps:
continue
yield src, dst
steps_map[dst] = dst_steps
stack.append(dst)
def bfs(self, source): gen = nx.dfs_edges(self.G, source, 2) expansion = [] res = [] paths = [] while True: try: u, v = gen.next() path_from_source = nx.shortest_path(self.G, source, u) path_from_target = nx.shortest_path(self.G, source, v) likehood_source = reduce(self.mul, map(self.get_clustering, path_from_source)) likehood_target = reduce(self.mul, map(self.get_clustering, path_from_target)) if likehood_source > self.cut_off: if u not in self.term: res.append(u) paths.append(path_from_source) if likehood_source > self.cut_off: if v not in self.term: res.append(v) paths.append(path_from_target) except StopIteration as e: break return res, paths
def compute_initial_guess(num_nodes, relative_rotations, relative_edges):
graph = nx.Graph()
graph.add_nodes_from(range(num_nodes))
for (ind, edge) in enumerate(relative_edges):
(n, theta) = so3.matrix_to_axis_angle(relative_rotations[ind])
graph.add_edge(edge[0], edge[1], weight=theta, index=ind)
tree = nx.minimum_spanning_tree(graph)
global_rotation = []
for i in range(num_nodes):
global_rotation.append(numpy.identity(3))
edges = nx.dfs_edges(tree, 0)
for edge in edges:
ind = graph[edge[0]][edge[1]]["index"]
mat = relative_rotations[ind]
if relative_edges[ind][0] == edge[0] and relative_edges[ind][1] == edge[1]:
pass
elif relative_edges[ind][0] == edge[1] and relative_edges[ind][1] == edge[0]:
mat = mat.transpose()
else:
logging.error("GRAPH ERROR")
global_rotation[edge[1]] = mat.dot(global_rotation[edge[0]])
return global_rotation
def work_trace(node):
tracepoints = []
basic_blocks = []
syscalls = []
interactions = []
datapoints = []
root = True
node_ids = reversed([
node.id,
*(e[1]
for e in nx.dfs_edges(context["cached_graph"].reverse(), node.id)),
])
for current_node_id in node_ids:
current_node = Node(current_node_id)
if root:
tracepoints.extend(current_node.tracepoints)
root = False
basic_blocks.extend(current_node.basic_blocks)
syscalls.extend(current_node.syscalls)
interactions.extend(current_node.interactions)
datapoints.extend(current_node.datapoints)
trace = json.dumps({
"node_id": node.id,
"tracepoints": tracepoints,
"basic_blocks": basic_blocks,
"syscalls": syscalls,
"interactions": interactions,
"datapoints": datapoints,
})
redis_client.rpush("work.trace", trace)
def depths(dg):
"""Return the depths of nodes in a directed
graph."""
depths = defaultdict(int)
for (u, v) in nx.dfs_edges(dg):
depths[v] = max(depths[v], depths[u] + 1)
return depths
def get_tree_edges(mst, root):
'''
iterate over tree edges from the mst rooted at the specified node
each edge is a tuple (a,b), which implies a -> b
'''
for edge in nx.dfs_edges(mst, root):
yield edge
def _get_relevant_systems(self):
"""
Given the dict that maps relevant vars to each VOI, find the mapping
of each VOI to the set of systems that need to run.
"""
relevant_systems = {}
grev = self._sgraph.reverse()
for voi, relvars in iteritems(self.relevant):
rev = True if voi in self._outset else False
if rev:
voicomp = self._prom_to_abs[voi][0].rsplit('.', 1)[0]
gpath = set([voicomp])
gpath.update([v for u,v in nx.dfs_edges(grev, voicomp)])
comps = set()
for relvar in relvars:
for absvar in self._prom_to_abs[relvar]:
parts = absvar.split('.')
for i in range(len(parts)-1):
cname = '.'.join(parts[:i+1])
# in rev mode, need to eliminate irrelevant systems that have shared promoted vars
if rev:
if cname in gpath:
comps.add(cname)
else:
comps.add(cname)
relevant_systems[voi] = tuple(comps)
return relevant_systems
def remove_symbol_definitions(self, symbols, statement):
"""Remove symbols and dependencies not used elsewhere. statement
is the statement from which the symbol was removed
"""
graph = self._create_dependency_graph()
removed_ind = self.index(statement)
# Statements defining symbols and dependencies
candidates = set()
for s in symbols:
for i in range(removed_ind - 1, -1, -1):
stat = self[i]
if isinstance(stat, Assignment) and stat.symbol == s:
candidates.add(i)
break
for i in candidates.copy():
if i in graph:
candidates |= set(nx.dfs_preorder_nodes(graph, i))
# All statements needed for removed_ind
if removed_ind in graph:
keep = {down for _, down in nx.dfs_edges(graph, removed_ind)}
else:
keep = set()
candidates -= keep
# Other dependencies after removed_ind
additional = {
down
for up, down in graph.edges
if up > removed_ind and down in candidates
}
for add in additional.copy():
if add in graph:
additional |= set(nx.dfs_preorder_nodes(graph, add))
remove = candidates - additional
for i in reversed(sorted(remove)):
del self[i]
def layer_plot(tree, opt_path, buchi):
"""
plot 3D layer graph
:param tree: tree built by alg
:param buchi: buchi state
:return: none
"""
path = list(nx.dfs_edges(tree))
# 2D workspace in 3D
fig = plt.figure(2)
plt.rc('text', usetex=True)
plt.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
ax = fig.add_subplot(111, projection='3d')
for i in range(len(path)):
x_pre = np.array([path[i][0][0][0], path[i][1][0][0]])
y_pre = np.array([path[i][0][0][1], path[i][1][0][1]])
z_pre = np.asarray([buchi[path[i][0][1]], buchi[path[i][1][1]]])
ax.plot(x_pre, y_pre, z_pre, 'b--d', markerfacecolor='None')
x_pre = np.asarray([point[0][0] for point in opt_path[0]])
y_pre = np.asarray([point[0][1] for point in opt_path[0]])
z_pre = np.asarray([buchi[point[1]] for point in opt_path[0]])
ax.plot(x_pre, y_pre, z_pre, 'r--d')
# region_plot(regions, 'region', ax)
# region_plot(obs, 'obs', ax)
plt.savefig('3D.png', bbox_inches='tight', dpi=600)
def score_parsimony(self, cm=None):
"""
Score the parsimony of the tree.
:param cm:
Character matrix, if the Cassiopeia_Tree object does not already have one stored.
:return:
An integer representing the number of mutations in the tree.
"""
if cm is not None:
self.cm = cm
assert self.cm is not None
net = self.get_network().copy()
copy_dict = {}
for n in net:
copy_dict[n] = copy.copy(n)
net = nx.relabel_nodes(net, copy_dict)
#net = fill_in_tree(net, cm)
#net = tree_collapse(net)
root = [n for n in net if net.in_degree(n) == 0][0]
score = 0
for e in nx.dfs_edges(net, source=root):
score += e[0].get_mut_length(e[1])
return score
def _recursive_train_local_classifiers(self, X, y, node_id, progress):
if self.graph_.node[node_id].get("classifier", None):
# Already encountered this node, skip
return
progress.update(1)
self._train_local_classifier(X, y, node_id)
for child_node_id in self.graph_.successors(node_id):
out_degree = self.graph_.out_degree(child_node_id)
if not out_degree:
# Terminal node, skip
progress.update(1)
continue
if out_degree < 2:
# If node has less than 2 children, no point training a local classifier
self.logger.warning(
"*** Not enough children to train classifier for node %s, skipping (%s < 2)",
child_node_id,
self.graph_.out_degree(child_node_id),
)
# For tracking progress, count this node as well as all of its descendants
progress.update(
1 + len(list(dfs_edges(self.graph_, child_node_id))))
continue
self._recursive_train_local_classifiers(
X=X,
y=y,
node_id=child_node_id,
progress=progress,
)
def match_nodes_to_blocks(self, meta_molecule):
"""
This function matches the nodes in the meta_molecule
to the blocks in the force-field. It does the essential
bookkeeping for two cases and populates the node_to_block,
and node_to_fragment dicts as well as the fragments attribute.
It distinguishes two cases:
1) the node corresponds to a single residue block; here
node_to_block entry is simply the resname of the block
2) the node has the from_itp attribute; in this case
the node is part of a multiresidue block in the FF,
all nodes corresponding to that block form a fragment.
All fragments are added to the fragments attribute, and
the nodes in those fragments all have the entry node_to_block
set to the block. In addition it is recorded to which fragment
specifically the node belongs in the node_to_fragment dict.
Parameters
----------
meta_molecule: polyply.src.meta_molecule.MetaMolecule
The meta molecule to process.
"""
regular_graph = nx.Graph()
restart_graph = nx.Graph()
restart_attr = nx.get_node_attributes(meta_molecule, "from_itp")
# in case we only have a single residue
# we assume the user is sane and that residue is not from
# an itp file
if len(meta_molecule.nodes) == 1:
regular_graph.add_nodes_from(meta_molecule.nodes)
# this breaks down when to proteins are directly linked
# because they would appear as one connected component
# and not two seperate components referring to two molecules
# but that is an edge-case we can worry about later
for idx, jdx in nx.dfs_edges(meta_molecule):
# the two nodes are restart nodes
if idx in restart_attr and jdx in restart_attr:
restart_graph.add_edge(idx, jdx)
else:
regular_graph.add_edge(idx, jdx)
# regular nodes have to match a block in the force-field by resname
for node in regular_graph.nodes:
self.node_to_block[node] = meta_molecule.nodes[node]["resname"]
# fragment nodes match parts of blocks, which describe molecules
# with more than one residue
for fragment in nx.connected_components(restart_graph):
block_name = restart_attr[list(fragment)[0]]
if all([restart_attr[node] == block_name for node in fragment]):
self.fragments.append(fragment)
for node in fragment:
self.node_to_block[node] = block_name
self.node_to_fragment[node] = len(self.fragments) - 1
else:
raise IOError
def dfs_path(self, node, roadcode=None):
if node not in self:
raise nx.NetworkXError('source node %s not in graph' % node)
path = [node]
prev_node = node
for child, prant in dfs_edges_reverse(self, node):
if prev_node == child:
path.append(prant)
prev_node = prant
else:
raise nx.NetworkXError('Exist branches in the HWY main road.')
path.reverse()
prev_node = node
if path:
first_node = path[0]
else:
first_node = None
for prant, child in nx.dfs_edges(self, node):
if prev_node == prant:
# Circle
if first_node == child:
path.insert(0, prant)
break
path.append(child)
prev_node = child
else:
raise nx.NetworkXError('Exist branches in the HWY main road.')
return path
def resiliency(analysis='nodal'):
"""
This function helps compute the resiliency metric of the network of a
node, or a network
:param kwargs:
:return:
"""
# 0. what's the event?
event = gv.event
# 1. get the graphs
g1 = gv.graph_collection[0]
g2 = gv.graph_collection[1]
nodes = g2.nodes()
edges = g2.edges()
# 2. for which node and edge are you doing the analysis?
wg = nx.DiGraph() # wg: working graph
wg.add_edges_from(edges)
for n in nodes:
# Finding Downstream Edges
print("Downstream Edges of %s -->" % n)
downstream_edges = list(nx.dfs_edges(wg, n))
resiliency_downstream(g2, downstream_edges, event)
# Finding Upstream Edges
print("Upstream Edges of %s -->" % n)
upstream_edges = list(nx.edge_dfs(wg, n, orientation='reverse'))
resiliency_upstream(g2, upstream_edges, event)
def run(self):
done = []
for task in nx.dfs_edges(self.execution_graph):
if not task[0] in done:
self.__execute__(task[0].label, task[0].executable, task[0].parameters)
done.append(task[0])
if not task[1] in done:
self.__execute__(task[1].label, task[1].executable, task[1].parameters)
done.append(task[1])
def transitive_reduction(G):
TR = nx.DiGraph()
TR.add_nodes_from(G.nodes())
for u in G:
u_edges = set(G[u])
for v in G[u]:
u_edges -= {y for x, y in nx.dfs_edges(G, v)}
TR.add_edges_from((u,v) for v in u_edges)
return TR
def _check_graph(self, out_stream=sys.stdout):
# Cycles in group w/o solver
cgraph = self.root._relevance._cgraph
for grp in self.root.subgroups(recurse=True, include_self=True):
path = [] if not grp.pathname else grp.pathname.split('.')
graph = cgraph.subgraph([n for n in cgraph if n.startswith(grp.pathname)])
renames = {}
for node in graph.nodes_iter():
renames[node] = '.'.join(node.split('.')[:len(path)+1])
if renames[node] == node:
del renames[node]
# get the graph of direct children of current group
nx.relabel_nodes(graph, renames, copy=False)
# remove self loops created by renaming
graph.remove_edges_from([(u,v) for u,v in graph.edges()
if u==v])
strong = [s for s in nx.strongly_connected_components(graph)
if len(s)>1]
if strong and isinstance(grp.nl_solver, RunOnce): # no solver, cycles BAD
relstrong = []
for slist in strong:
relstrong.append([])
for s in slist:
relstrong[-1].append(name_relative_to(grp.pathname, s))
relstrong[-1] = sorted(relstrong[-1])
print("Group '%s' has the following cycles: %s" %
(grp.pathname, relstrong), file=out_stream)
# Components/Systems/Groups are not in the right execution order
subnames = [s.pathname for s in grp.subsystems()]
while strong:
# break cycles to check order
lsys = [s for s in subnames if s in strong[0]]
for p in graph.predecessors(lsys[0]):
if p in lsys:
graph.remove_edge(p, lsys[0])
strong = [s for s in nx.strongly_connected_components(graph)
if len(s)>1]
visited = set()
out_of_order = set()
for sub in grp.subsystems():
visited.add(sub.pathname)
for u,v in nx.dfs_edges(graph, sub.pathname):
if v in visited:
out_of_order.add(v)
if out_of_order:
print("In group '%s', the following subsystems are out-of-order: %s" %
(grp.pathname, sorted([name_relative_to(grp.pathname, n)
for n in out_of_order])), file=out_stream)
def _get_relevant_vars(self, g):
"""
Args
----
g : nx.DiGraph
A graph of variable dependencies.
Returns
-------
dict
Dictionary that maps a variable name to all other variables in the
graph that are relevant to it.
"""
relevant = {}
succs = {}
for nodes in self.inputs:
for node in nodes:
relevant[node] = set()
succs[node] = set((node,))
if node in g:
succs[node].update(v for u, v in nx.dfs_edges(g, node))
grev = g.reverse()
self._outset = set()
for nodes in self.outputs:
self._outset.update(nodes)
for node in nodes:
relevant[node] = set()
if node in g:
preds = set(v for u, v in nx.dfs_edges(grev, node))
preds.add(node)
for inps in self.inputs:
for inp in inps:
if inp in g:
common = preds.intersection(succs[inp])
relevant[node].update(common)
relevant[inp].update(common)
return relevant
def normalize_step_weight(graph):
"Changes the edge weights in the graph proportional to the longest path."
longest_path_len = max(nx.shortest_path_length(graph, "ROOT").values())
# add normalized path length as weight to edges.
for category in "ABCEDFGHJKLMNPQRSTUVWXZ":
# for each category, find out how long the longest path is.
cat_longest_path_len = max(nx.shortest_path_length(graph, category).values()) + 1
# normalize the stepsize
stepsize = float(longest_path_len) / cat_longest_path_len
# traverse tree for this category and assign stepsize to edges as weight attribute
for a, b in nx.dfs_edges(graph, category):
graph[a][b]["weight"] = stepsize
def depth(dg):
"""Returns the depth of a directed graph.
A single node has depth 0."""
depths = defaultdict(int)
for (u, v) in nx.dfs_edges(dg):
depths[v] = max(depths[v], depths[u] + 1)
if len(depths) > 0:
return max(depths.values())
elif len(dg.nodes()) == 0: # No nodes in graph
return None
else: # Nodes but no edges in graph
return 0
def hierarchy(G, edge_type=EdgeTypes.parent):
"""Produce child nodes in a depth-first order."""
for root in toplevel(G):
dq = deque()
yield G.node[root], len(dq) # Depth 0
# Iterate over all children
dq.append(root)
for src, dest in nx.dfs_edges(G, source=root):
while len(dq) > 0 and dq[-1] != src:
dq.pop() # Unwind the stack
if G.edge[src][dest].get('type') == edge_type:
yield G.node[dest], len(dq)
dq.append(dest)
def findControllingNode(self, paramName):
current, parent = self.currentContextName, self.currentContext.parentContext
var = self.currentContext.parameters[paramName]
child = None
if not (parent and var.useParentValue):
return None
for child, parent in dfs_edges(self.dependencyGraph, parent):
try:
var = self.contextDict[parent].parameters[paramName]
if not (var.useParentValue and var.hasParent):
return child
except KeyError:
return child
return parent
def cart_to_internal(molecule):
""" Converts the coordinates of the molecule from cartesian to internal
coordinates. """
# First decide on a starting atom
source_node = molecule.atoms.nodes()[0]
# Argh, dictionaries aren't sorted...
completed_bonds = {source_node: []}
for edge in nx.dfs_edges(molecule.atoms, source_node):
completed_bonds[edge[1]] = [edge[0]]
# completed_bonds[2] += [x for x in completed_bonds[1][1:] if x not in completed_bonds[2]]
# completed_bonds[3] += [x for x in completed_bonds[2][1:] if x not in completed_bonds[3]]
for entry in completed_bonds:
print(entry, completed_bonds[entry])
def get_bad_dest(self, b): # pick a random node near b count = 0 ret = None for edge in nx.dfs_edges(self.graph, b): if count == 1000: break node = edge[1] count += 1 if count == 1: ret = node i = randint(0, count - 1) if i == count - 1: ret = node return node
def transitive_reduction(G):
""" Returns transitive reduction of a directed graph
The transitive reduction of G = (V,E) is a graph G- = (V,E-) such that
for all v,w in V there is an edge (v,w) in E- if and only if (v,w) is
in E and there is no path from v to w in G with length greater than 1.
Parameters
----------
G : NetworkX DiGraph
A directed acyclic graph (DAG)
Returns
-------
NetworkX DiGraph
The transitive reduction of `G`
Raises
------
NetworkXError
If `G` is not a directed acyclic graph (DAG) transitive reduction is
not uniquely defined and a :exc:`NetworkXError` exception is raised.
References
----------
https://en.wikipedia.org/wiki/Transitive_reduction
"""
if not is_directed_acyclic_graph(G):
msg = "Directed Acyclic Graph required for transitive_reduction"
raise nx.NetworkXError(msg)
TR = nx.DiGraph()
TR.add_nodes_from(G.nodes())
descendants = {}
# count before removing set stored in descendants
check_count = dict(G.in_degree)
for u in G:
u_nbrs = set(G[u])
for v in G[u]:
if v in u_nbrs:
if v not in descendants:
descendants[v] = {y for x, y in nx.dfs_edges(G, v)}
u_nbrs -= descendants[v]
check_count[v] -= 1
if check_count[v] == 0:
del descendants[v]
TR.add_edges_from((u, v) for v in u_nbrs)
return TR
def cluster(g):
clustered = []
clusters = {}
i = 1
for n in g.nodes():
c = [n]
if n in clustered: continue
edges = list(nx.dfs_edges(g,n))
for e in edges:
n1,n2 = e
clustered+=[n1,n2]
c+=[n1,n2]
c = list(set(c))
clusters[i] = {'num': len(c), 'fams': c[:]}
i+=1
return clusters
def select(self, k=2, rand=False):
if rand:
nodes = []
while len(nodes) != k:
n = rd.randint(1, self.number_of_nodes())
if not n in nodes:
nodes.append(n)
else:
w = int(self.number_of_nodes()/(k + 1))
edges = nx.dfs_edges(self, 1)
nodes = [1]
for n in range(1, k):
for e in range(w):
edge = edges.next()
nodes.append(edge[1])
return nodes
def dfs_custom_tree(G, source=None):
T = nx.Graph()
if source is None:
T.add_nodes_from(G)
else:
T.add_node(source)
#print "All those edges"
#for e in nx.dfs_edges(G,source):
# print e
T.add_edges_from(nx.dfs_edges(G,source))
#FIXME assign weights back to the graph T
for u,v,g in G.edges(data=True):
try:
T[u][v]['weight'] = G[u][v]['weight']
except: continue
return T
def SentimentAnalysis_RGO_Belief_Propagation(nxg): #Bayesian Pearl Belief Propagation is done by #assuming the senti scores as probabilities with positive #and negative signs and the Recursive Gloss Overlap #definition graph being the graphical model. #Sentiment as a belief potential is passed through #the DFS tree of this graph. dfs_positive_belief_propagated=1.0 core_positive_belief_propagated=1.0 dfs_negative_belief_propagated=1.0 core_negative_belief_propagated=1.0 core_xnegscore=core_xposscore=1.0 dfs_knegscore=dfs_kposscore=dfs_vposscore=dfs_vnegscore=1.0 sorted_core_nxg=sorted(nx.core_number(nxg).items(),key=operator.itemgetter(1), reverse=True) kcore_nxg=nx.k_core(nxg,6,nx.core_number(nxg)) for x in sorted_core_nxg: xsset = swn.senti_synsets(x[0]) if len(xsset) > 2: core_xnegscore = float(xsset[0].neg_score())*10.0 core_xposscore = float(xsset[0].pos_score())*10.0 if core_xnegscore == 0.0: core_xnegscore = 1.0 if core_xposscore == 0.0: core_xposscore = 1.0 core_positive_belief_propagated *= float(core_xposscore) core_negative_belief_propagated *= float(core_xnegscore) print "Core Number: RGO_sentiment_analysis_belief_propagation: %f, %f" % (float(core_positive_belief_propagated), float(core_negative_belief_propagated)) #for k,v in nx.dfs_edges(nxg): for k,v in nx.dfs_edges(kcore_nxg): ksynset = swn.senti_synsets(k) vsynset = swn.senti_synsets(v) if len(ksynset) > 2: dfs_knegscore = float(ksynset[0].neg_score())*10.0 dfs_kposscore = float(ksynset[0].pos_score())*10.0 if len(vsynset) > 2: dfs_vnegscore = float(vsynset[0].neg_score())*10.0 dfs_vposscore = float(vsynset[0].pos_score())*10.0 dfs_kposscore_vposscore = float(dfs_kposscore*dfs_vposscore) dfs_knegscore_vnegscore = float(dfs_knegscore*dfs_vnegscore) if dfs_kposscore_vposscore == 0.0: dfs_kposscore_vposscore = 1.0 if dfs_knegscore_vnegscore == 0.0: dfs_knegscore_vnegscore = 1.0 dfs_positive_belief_propagated *= float(dfs_kposscore_vposscore) dfs_negative_belief_propagated *= float(dfs_knegscore_vnegscore) print "K-Core DFS: RGO_sentiment_analysis_belief_propagation: %f, %f" % (float(dfs_positive_belief_propagated),float(dfs_negative_belief_propagated)) return (dfs_positive_belief_propagated, dfs_negative_belief_propagated, core_positive_belief_propagated, core_negative_belief_propagated)
def get_tree_schedule(frcs, graph):
"""
Find the most constrained tree in the graph and returns which messages to compute
it. This is the minimum spanning tree of the perturb_radius edge attribute.
See forward_pass for parameters.
Returns
-------
tree_schedules : numpy.ndarray of numpy.int
Describes how to compute the max marginal for the most constrained tree.
Nx3 2D array of (source pool_idx, target pool_idx, perturb radius), where
each row represents a single outgoing factor message computation.
"""
min_tree = nx.minimum_spanning_tree(graph, 'perturb_radius')
return np.array([(target, source, graph.edge[source][target]['perturb_radius'])
for source, target in nx.dfs_edges(min_tree)])[::-1]
def test_max_steps():
binary_path = os.path.join(test_location, "x86_64", "fauxware")
b = angr.Project(binary_path, load_options={'auto_load_libs': False})
cfg = b.analyses.CFGAccurate(max_steps=5)
dfs_edges = networkx.dfs_edges(cfg.graph)
depth_map = {}
for src, dst in dfs_edges:
if src not in depth_map:
depth_map[src] = 0
if dst not in depth_map:
depth_map[dst] = depth_map[src] + 1
depth_map[dst] = max(depth_map[src] + 1, depth_map[dst])
nose.tools.assert_less_equal(max(depth_map.itervalues()), 5)
def test_dag_execution(self):
# build a DAG
g = nx.Graph()
t1 = Task("hello")
t2 = Task("world")
t3 = Task("!")
g.add_edge(t1, t2)
g.add_edge(t2, t3)
# Arrange
runner = Runner(g)
with mock.patch('job_manager.runner.Runner.__execute__') as me:
for edge in nx.dfs_edges(g):
logging.warning("left: %s, right: %s", edge[0].label, edge[1].label)
# Act
runner.run()
# Assert
me.assert_any_call(t1.label, t1.executable, t1.parameters)
me.assert_any_call(t2.label, t2.executable, t2.parameters)
me.assert_any_call(t3.label, t3.executable, t3.parameters)
def max_product(graph, query_node=None):
"""Max-product algorithm.
Compute setting of variables with maximum probability on graphs
that are tree structured.
Return the setting of all query_nodes.
"""
track = {} # Setting of variables
if query_node is None: # pick random node
query_node = choice(graph.get_vnodes())
# Depth First Search to determine edges
dfs = nx.dfs_edges(graph, query_node)
# Convert tuple to reversed list
backward_path = list(dfs)
forward_path = reversed(backward_path)
# Messages in forward phase
for (v, u) in forward_path: # Edge direction: u -> v
msg = u.mpa(v)
graph[u][v]['object'].set_message(u, v, msg)
# Messages in backward phase
for (u, v) in backward_path: # Edge direction: u -> v
msg = u.mpa(v)
graph[u][v]['object'].set_message(u, v, msg)
# Maximum argument for query node
track[query_node] = query_node.argmax()
# Back-tracking
for (u, v) in backward_path: # Edge direction: u -> v
if v.type == nodes.NodeType.factor_node:
for k in v.record[u].keys(): # Iterate over outgoing edges
track[k] = v.record[u][k]
# Return maximum probability for query node and setting of variable
return query_node.maximum(), track
def transitive_reduction(G):
""" Returns transitive reduction of a directed graph
The transitive reduction of G = (V,E) is a graph G- = (V,E-) such that
for all v,w in V there is an edge (v,w) in E- if and only if (v,w) is
in E and there is no path from v to w in G with length greater than 1.
Parameters
----------
G : NetworkX DiGraph
A directed acyclic graph (DAG)
Returns
-------
NetworkX DiGraph
The transitive reduction of `G`
Raises
------
NetworkXError
If `G` is not a directed acyclic graph (DAG) transitive reduction is
not uniquely defined and a :exc:`NetworkXError` exception is raised.
References
----------
https://en.wikipedia.org/wiki/Transitive_reduction
"""
if not is_directed_acyclic_graph(G):
raise nx.NetworkXError(
"Transitive reduction only uniquely defined on directed acyclic graphs.")
TR = nx.DiGraph()
TR.add_nodes_from(G.nodes())
for u in G:
u_edges = set(G[u])
for v in G[u]:
u_edges -= {y for x, y in nx.dfs_edges(G, v)}
TR.add_edges_from((u, v) for v in u_edges)
return TR
def dfs_edges_by_label(G, source=None, my_label=None):
"""Produce edges in a depth-first-search starting at source,
only following a given label.
my_label : this is a dictionary, specifying an edge label condition to traverse by.
For example, if edges have been added such as, g.add_edge(a, b, relationship='child')
, then use my_label= {'relationship': 'child'} , as a condition for traversal.
"""
if not my_label or my_label == {}:
yield nx.dfs_edges(G, source=None)
if type(my_label) != type({}):
raise SyntaxError, "my_label should be a dictionary"
label_, value_ = my_label.items()[0]
if source is None:
# produce edges for all components
nodes = G
else:
# produce edges for components with source
nodes = [source]
visited = set()
for start in nodes:
if start in visited:
continue
visited.add(start)
stack = [(start, iter(G[start]))]
while stack:
parent, children = stack[-1]
try:
child = next(children)
if G[parent][child][label_] != value_:
continue
if child not in visited:
yield parent, child
visited.add(child)
stack.append((child, iter(G[child])))
except StopIteration:
stack.pop()
def strategy_connected_sequential(G, colors, traversal="bfs"):
"""
Connected sequential ordering (CS). Yield nodes in such an order, that
each node, except the first one, has at least one neighbour in the
preceeding sequence. The sequence can be generated using both BFS and
DFS search (using the strategy_connected_sequential_bfs and
strategy_connected_sequential_dfs method). The default is bfs.
"""
for component_graph in nx.connected_component_subgraphs(G):
source = component_graph.nodes()[0]
yield source # Pick the first node as source
if traversal == "bfs":
tree = nx.bfs_edges(component_graph, source)
elif traversal == "dfs":
tree = nx.dfs_edges(component_graph, source)
else:
raise nx.NetworkXError("Please specify bfs or dfs for connected sequential ordering")
for (_, end) in tree:
# Then yield nodes in the order traversed by either BFS or DFS
yield end
