def __repair_incomplete_sections(self) -> nx.DiGraph:
"""
Try to repair incomplete sections. A section can be under specified either:
* departure time is not specified or
* calender is not set
In this method at least the departure time is calculated from the construction
begins using a BFS search in the section graph from these.
:return: basic section graph (see Train.basis_section_graph)
"""
construction_begins = list(
filter(RouteSection.is_complete, self.sections))
sg = self.basic_section_graph()
for cb in construction_begins:
for pred, successors in nx.bfs_successors(sg, cb):
succ: RouteSection
for succ in successors:
succ.complete_from_predecessor(pred)
sg_reversed = sg.reverse()
for cb in construction_begins:
for pred, successors in nx.bfs_successors(sg_reversed, cb):
succ: RouteSection
for succ in successors:
succ.complete_from_successor(pred)
return sg
def generate_path(self, topo, flow, link_caps):
path = []
count = 0
self.log.debug("Flow%d: %d --> %d: %s" %
(flow.flow_id, flow.src, flow.dst, str(flow.vol)))
while len(path) == 0 and count < self.attempts - 3:
try:
from_srcs = defaultdict()
bfs_src = nx.bfs_successors(topo.graph, flow.src)
self.get_node_with_distance(bfs_src, flow.src, 0, 2, deque([]),
from_srcs, False)
to_dsts = defaultdict()
bfs_dst = nx.bfs_successors(topo.graph, flow.dst)
self.get_node_with_distance(bfs_dst, flow.dst, 0, 2, deque([]),
to_dsts, True)
except nx.exception.NetworkXNoPath:
count += 1
continue
if not self.create_with_middlebox(topo, flow, from_srcs, to_dsts,
link_caps):
if not self.create_with_shortest_path(topo, flow, from_srcs,
to_dsts, link_caps):
count += 1
continue
return True
if count == self.attempts - 3:
self.log.debug("Fail hard")
return False
return path
def limitedInfection(self, graph, infectedNodes):
steps = 0
color = []
inNodes = infectedNodes
for x in inNodes:
try:
listOfParentNodes = nx.bfs_successors(G,x).keys()
listOfSubNodes = nx.bfs_successors(G,x).values()
del listOfSubNodes[0]
del listOfSubNodes[0]
del listOfSubNodes[0]
del listOfSubNodes[0]
except:
continue
print "Processing graph, please wait..."
for subList in range(0, len(listOfSubNodes)):
for item in listOfSubNodes[subList]:
if item not in inNodes:
inNodes.append(item)
name= 'Limited_Infected'
color = Infection.colors(self, graph, inNodes)
Infection.printGraph(self, graph, inNodes, steps, color, name)
steps = steps + 1
print "Nodes infected: " + str(color.count('r'))
print "Nodes left: " + str(len(nx.nodes(graph)))
if color.count('r') == len(nx.nodes(graph)):
break
def _find_loop_nodes_and_successors(self):
graph = self._region.graph
head = self._region.head
# find latching nodes
latching_nodes = set()
queue = [head]
traversed = set()
while queue:
node = queue.pop()
successors = graph.successors(node)
traversed.add(node)
for dst in successors:
if dst in traversed:
latching_nodes.add(node)
else:
queue.append(dst)
# find loop nodes and successors
loop_subgraph = RegionIdentifier.slice_graph(graph,
head,
latching_nodes,
include_frontier=True)
loop_node_addrs = set(node.addr for node in loop_subgraph)
# Case A: The loop successor is inside the current region (does it happen at all?)
loop_successors = set()
for node, successors in networkx.bfs_successors(graph, head):
if node.addr in loop_node_addrs:
for suc in successors:
if suc not in loop_subgraph:
loop_successors.add(suc)
# Case B: The loop successor is the successor to this region in the parent graph
if not loop_successors:
current_region = self._region
parent_region = self._parent_map.get(current_region, None)
while parent_region and not loop_successors:
parent_graph = parent_region.graph
for node, successors in networkx.bfs_successors(
parent_graph, current_region):
if node.addr == current_region.addr:
for suc in successors:
if suc not in loop_subgraph:
loop_successors.add(suc)
current_region = parent_region
parent_region = self._parent_map.get(current_region, None)
return loop_subgraph, loop_successors
def test_limited_bfs_successor(self):
assert dict(nx.bfs_successors(self.G, source=1, depth_limit=3)) == {
1: [0, 2],
2: [3, 7],
3: [4],
7: [8],
}
result = {
n: sorted(s)
for n, s in nx.bfs_successors(self.D, source=7, depth_limit=2)
}
assert result == {8: [9], 2: [3], 7: [2, 8]}
def bfs_test_successor(self):
assert_equal(dict(nx.bfs_successors(self.G, source=1, depth_limit=3)),
{
1: [0, 2],
2: [3, 7],
3: [4],
7: [8]
})
result = dict(
(n, sorted(s))
for n, s in nx.bfs_successors(self.D, source=7, depth_limit=2))
assert_equal(result, {8: [9], 2: [3], 7: [2, 8]})
def __init__(self, graph, miss_deadline_penalty=1):
"""
G: a networkx direct Graph, each edge is associated with a cost and a time.
miss_deadline_penalty: the penalty incurred if the deadline is violated.
"""
assert isinstance(graph, nx.DiGraph)
assert len(graph.edges()) > 0
self.graph = deepcopy(graph)
self.set_cost_time_radius()
self.miss_deadline_penalty = miss_deadline_penalty
self.current_node = None
self.destination = None
self.remaining_time = None
self.last_action = None
self.last_reward = None
self.num_step = 0
# Cumulative reward earned this episode
self.episode_total_reward = None
# the action_space is state-dependent and thus we implement a
# get_action_space as a lambda function to get the list of next nodes
self.get_action_space = \
lambda node: DelayConstrainedNetworkActionSpace([(node, next_node) for next_node \
in list(nx.bfs_successors(self.graph, node, depth_limit=1))[0][1]])
self.observation_space = DelayConstrainedNetworkObservationSpace(
self.graph)
self.seed()
self.reset()
def grow_component(H, max_size):
"""Grow one community by taking BFS components until max_size is reached.
Parameters
----------
H : networkx.DiGraph
The underlying considered instance.
max_size : int
The maximum community size.
Returns
-------
list
The grown community as a list of nodes.
"""
community = []
bfs = []
while len(community) < max_size:
if not bfs:
source = choice(H.nodes())
community.append(source)
bfs = list(nx.bfs_successors(H, source))
H.remove_node(source)
else:
if bfs[0][1]:
new_node = bfs[0][1][0]
bfs[0] = (bfs[0][0], bfs[0][1][1:])
community.append(new_node)
H.remove_node(new_node)
else:
bfs = bfs[1:]
return community
def bfs_edges_modified(tree, source, preference=None):
visited, queue = [], [source]
bfs_tree = nx.bfs_tree(tree, source=source)
predecessors = dict(nx.bfs_predecessors(bfs_tree, source))
edges = []
while queue:
vertex = queue.pop()
if vertex not in visited:
visited.append(vertex)
if (vertex in predecessors.keys()):
edges.append((predecessors[vertex], vertex))
unvisited = set(tree[vertex]) - set(visited)
if (preference != None):
weights = list()
for x in unvisited:
successors = dict(nx.bfs_successors(bfs_tree, source=x))
successors_nodes = list(
itertools.chain.from_iterable(successors.values()))
weights.append(
min([
preference.index(s)
if s in preference else len(preference)
for s in successors_nodes + [x]
]))
unvisited = [
x for _, x in sorted(zip(weights, unvisited),
reverse=True,
key=lambda x: x[0])
]
queue.extend(unvisited)
return edges
def gen_split_obj(
target_data_path: Path,
graph,
model_shape: np.ndarray,
rot_mat: np.ndarray = None,
):
edge_vertices = []
print(graph.nodes)
for node, successors in nx.bfs_successors(graph, "0"):
for succ in successors:
for curr in [node, succ]:
n = graph.nodes[curr]
x, y, z = n["x"], n["y"], n["z"]
edge_vertices.append(np.array([x, y, z]))
print(edge_vertices)
edge_vertices = normalize(edge_vertices,
reference_shape=model_shape,
rot_mat=rot_mat)
with open(target_data_path, "w") as file:
file.write("# Vertices\n")
file.write("# Edge Vertices\n")
for x, y, z in edge_vertices:
file.write(f"v {x:.3f} {y:.3f} {z:.3f}\n")
file.write("\n# Faces\n")
file.write("# Edge lines\n")
for i in range(0, len(edge_vertices), 2):
j = i + 1
file.write(f"l {j} {j + 1}\n")
def __reachable_sets(self):
s_vs = {}
for n in self.G.nodes_iter():
successors = nx.bfs_successors(self.G, n)
s_vs[n] = {rchbl for src in successors for rchbl in successors[src]}
s_vs[n].add(n)
return s_vs
def bfs(graph, start, end):
"""
graphを幅優先探索する
:param graph: グラフ
:param start: 始点ノード
:param end: 終点ノード
:return: 訪れたノード列
"""
graph_successors = nx.bfs_successors(graph, start)
queue = [start]
visited = []
while len(queue) > 0:
v = queue.pop(0)
if v == end:
visited.append(v)
return visited
if v not in visited:
visited.append(v)
queue += [
x for x in graph_successors.get(v, []) if x not in visited
]
return visited
def explore(self, timeout: float):
start = time.time()
nextList = [self.head]
i = 0
for successors in nx.bfs_successors(self, self.head):
if not successors.explored:
nextList.append(successors)
while len(nextList) > 0 and (time.time() - start < timeout):
currentNode = nextList.pop(0)
if currentNode.explored:
pass
for source in currentNode.endpoints:
for target in currentNode.fullGraph.neighbors(source):
# create a new node by exploring it
newGraph = self.evolve_from(currentNode, source, target)
i += 1
if newGraph:
nextList.append(newGraph)
currentNode.explored = True
if len(nextList) != 0:
print_err("timeout, made " + str(i))
else:
print_err("to the end of " + str(i))
def random_generator_playbook_phase_2_rollup(
scg: nx.DiGraph,
instances_dict: InstanceDictType,
):
"""
Build up set of sequences for classifiers by taking the union of sequences
already generated for the classifier subclasses.
:param lpg: Active SysML graph
:param scg: Subclassing Graph projection from the LPG
:param instances_dict: Working dictionary of interpreted sequences for the model
:return: None - side effect is addition of new instances to the instances dictionary
"""
roots = [node for node in scg.nodes if scg.in_degree(node) == 0]
for root in roots:
bfs_dict = dict(nx.bfs_successors(scg, root))
bfs_list = list(bfs_dict.keys())
bfs_list.reverse()
for gen in bfs_list:
new_superset = []
for subset_node in bfs_dict[gen]:
new_superset.extend(instances_dict[subset_node])
instances_dict[gen] = new_superset
def checkG(newg, normal):
domainMap = {}
index = 0
for line in open('dga.txt').readlines():
index += 1
for data in line.strip().split(' '):
if data in domainMap:
print(data)
else:
domainMap[data] = index
for node in newg.nodes:
if node not in normal:
continue
groupSet = set()
domainSet = set()
cnt = 3
for k, v in nx.bfs_successors(newg, node):
cnt -= 1
for node2 in v:
if node2 in domainMap:
domainSet.add(node2)
groupSet.add(domainMap[node2])
if cnt == 0:
break
print(node, domainSet)
input()
def multiplePartion(mutiplelist, infectionG, rumorSourceList):
# 构建关于这个社区的传播子图
tempGraph1 = nx.Graph()
for edge in infectionG.edges:
# if infectG.adj[edge[0]][edge[1]]['Infection']==2: #作为保留项。
if edge[0] in mutiplelist[0] and edge[1] in mutiplelist[0]:
tempGraph1.add_edges_from([edge], weight=1)
print('这个感染区域的传播子图边个数')
print(tempGraph1.number_of_edges())
print(tempGraph1.number_of_nodes())
nodelist=list(tempGraph1.nodes)
resultSource = []
#
tree = Tree()
#初始化这些值。
for nodetemp in (tempGraph1.nodes):
tempGraph1.add_node(nodetemp, T=0)
tempGraph1.add_node(nodetemp, P=0)
peripheryList=nx.periphery(tempGraph1)
print ('边界节点'+str(peripheryList))
randomnode= random.choice(nodelist)
print ('node是多少'+str(randomnode))
dict_Temp=dict(nx.bfs_successors(tempGraph1, source=randomnode))
print (dict_Temp)
for nodeTemps in nodelist:
if nodeTemps in peripheryList:
tempGraph1.add_node(nodeTemps,T=1)
tempGraph1.add_node(nodeTemps,P=1)
else:
if nodeTemps ==randomnode:
def get_bfs(source):
edge_local = dict()
for i in g.edges:
edge_local[tuple(sorted(i))] = 0
bfs_output = nx.Graph(nx.bfs_tree(g, source))
leaf_nodes_list = get_leaf_nodes(bfs_output, source)
parent_nodes_list = list(nx.bfs_predecessors(bfs_output, source))
children_nodes_list = list(nx.bfs_successors(bfs_output, source))
# Initializing the queue with the leaf nodes
queue = list(leaf_nodes_list)
while len(queue) > 0:
current_node = queue.pop(0)
if current_node in leaf_nodes_list:
parents = get_parent_nodes(parent_nodes_list, current_node)
#leaf nodes will have only one parent
temp = (current_node, parents[0])
edge_local[tuple(sorted(temp))] = 1
else:
parents = get_parent_nodes(parent_nodes_list, current_node)
children = get_child_nodes(children_nodes_list, current_node)
forward_val = 1
for c in children:
temp = (current_node, c)
forward_val = forward_val + edge_local[tuple(sorted(temp))]
if len(parents) > 0:
temp = (current_node, parents[0])
edge_local[tuple(sorted(temp))] = forward_val
if len(parents) > 0 and parents[0] not in queue:
queue.append(parents[0])
return edge_local
def nx_tree_to_dd_tree(T):
# build dict from string label to dendropy node
T.add_node('my_root')
random_node = next(iter(T.nodes()))
near = next(iter(T.neighbors(random_node)))
T.remove_edge(random_node, near)
T.add_edge(random_node, 'my_root')
T.add_edge(near, 'my_root')
label_node = dict()
for v in T.nodes():
dd_node = dd.Node(label=v)
label_node[v] = dd_node
# root tree at random node
# root = next(iter(T.nodes()))
dd_tree = dd.Tree()
dd_tree.seed_node = label_node['my_root']
# print(root)
# add the edges in the tree
for v, successors in nx.bfs_successors(T, 'my_root'):
dd_node = label_node[v]
for s in successors:
dd_child = label_node[s]
dd_node.add_child(dd_child)
# nx.draw(T, with_labels = True)
# plt.show()
return dd_tree
def breadthFirstPathS(G, startNode, endNode):
global numExpanded
numExpanded = 0
pathsDict = {startNode: [startNode]}
isFound = False
if endNode == startNode:
isFound = True
iter = nx.bfs_successors(G, startNode)
current = next(iter)
numExpanded += 1
# iterate through the graph, remembering the path to get to each node
while (not isFound):
for node in current[1]:
pathsDict[node] = pathsDict[current[0]] + [node]
numExpanded += 1
if endNode in current[1]:
isFound = True
else:
current = next(iter)
return pathsDict[endNode], numExpanded
def do_layout(sys):
#--------------------------------------
# Generate the product's networkx graph
#--------------------------------------
tic = time.time()
graph = sys.make_positioning_graph()
print 'Graph contains {0} nodes'.format(len(graph.nodes()))
root = sys.artifacts_dict['external source']
tree = nx.bfs_successors(graph,root)
for k,v in tree.items():
k.visited = True
#--------------------------------------
# Use networkx to develop a graph layout
#--------------------------------------
#
positions = nx.graphviz_layout(graph,
prog='dot',
root='external source')
pos_list = [pos for pos in positions.values()]
max_pos = max(list(chain.from_iterable(pos_list)))
scale = 1
# scale = abs(canvas_size/max_pos)
for element in graph.nodes_iter():
element.position = (positions[element][0]*scale,positions[element][1]*scale)
print 'Graph loaded in {}s'.format(time.time()-tic)
def find_ptm_atoms(molecule):
"""
Finds all atoms in molecule that have the node attribute ``PTM_atom`` set
to a value that evaluates to ``True``. ``molecule`` will be traversed
starting at these atoms untill all marked atoms are visited such that they
are identified per "branch", and for every branch the anchor node is known.
The anchor node is the node(s) which are not PTM atoms and share an edge
with the traversed branch.
Parameters
----------
molecule : networkx.Graph
Returns
-------
list[tuple[set, set]]
``[({ptm atom indices}, {anchor indices}), ...]``. Ptm atom indices are
connected, and are connected to the rest of molecule via anchor
indices.
"""
# Atomnames have already been fixed, and missing atoms have been added.
# In addition, unrecognized atoms have been labeled with the PTM attribute.
extra_atoms = set(n_idx for n_idx in molecule
if molecule.nodes[n_idx].get('PTM_atom', False))
ptms = []
while extra_atoms:
# First PTM atom we'll look at
first = next(iter(extra_atoms))
anchors = set()
# PTM atoms we've found
atoms = set()
# Atoms we still need to see this traversal
to_see = set([first])
# Traverse in molecule.
for orig, succ in nx.bfs_successors(molecule, first):
# We've seen orig, so remove it
if orig in to_see:
to_see.remove(orig)
if orig in extra_atoms:
# If this is a PTM atom, we want to see it's neighbours as
# well.
to_see.update(succ)
atoms.add(orig)
else:
# Else, it's an attachment point for the this PTM
anchors.add(orig)
if not to_see:
# We've traversed the interesting bit of the tree
break
# Although we know how far our tree spans we may still have work to do
# for terminal nodes. There has to be a more elegant solution though.
for node in to_see:
if node in extra_atoms:
atoms.add(node)
else:
anchors.add(node)
extra_atoms -= atoms
ptms.append((atoms, anchors))
return ptms
def merge_close_nodes(graph):
"""Merges nodes when they are really close to each other"""
has_successors = dict(nx.bfs_successors(graph, "0"))
nodes_to_be_removed = []
edges_to_be_merged = []
cant_be_removed = {"0"}
for predecessor, node in nx.bfs_edges(graph, "0"):
if node not in cant_be_removed:
curr = graph[predecessor][node]
nums = list(map(int, curr["group_sizes"].split()))
weight = curr["weight"]
diameter = calc_diameter(sum(nums) / len(nums))
if weight < diameter * DIAMETER_TO_WEIGHT_RATIO:
if node in has_successors:
for successor in has_successors[node]:
cant_be_removed.add(successor)
edges_to_be_merged.append(
(graph, predecessor, node, successor))
nodes_to_be_removed.append(node)
print(
f"Merging: weight: {weight:.2f}, average: {diameter:.2f}",
end=" -> ")
print(curr)
for edge_merge in edges_to_be_merged:
merge_edges(*edge_merge)
remove_nodes(graph, nodes_to_be_removed)
def calculate_shift_distance(adata,root='S0',percentile=95, factor=2.0, preference=None):
flat_tree = adata.uns['flat_tree']
dict_label_node = {value: key for key,value in nx.get_node_attributes(flat_tree,'label').items()}
root_node = dict_label_node[root]
##shift distance for each branch
dict_edge_shift_dist = dict()
max_dist = np.percentile(adata.obs['branch_dist'],percentile) ## maximum distance from cells to branch
leaves = [k for k,v in flat_tree.degree() if v==1]
n_nonroot_leaves = len(list(set(leaves) - set([root_node])))
dict_bfs_pre = dict(nx.bfs_predecessors(flat_tree,root_node))
dict_bfs_suc = dict(nx.bfs_successors(flat_tree,root_node))
#depth first search
if(preference != None):
preference_nodes = [dict_label_node[x] for x in preference]
else:
preference_nodes = None
dfs_nodes = dfs_nodes_modified(flat_tree,root_node,preference=preference_nodes)
dfs_nodes_copy = deepcopy(dfs_nodes)
id_leaf = 0
while(len(dfs_nodes_copy)>1):
node = dfs_nodes_copy.pop()
pre_node = dict_bfs_pre[node]
if(node in leaves):
dict_edge_shift_dist[(pre_node,node)] = factor*max_dist*(id_leaf-(n_nonroot_leaves/2.0))
id_leaf = id_leaf+1
else:
suc_nodes = dict_bfs_suc[node]
dict_edge_shift_dist[(pre_node,node)] = (sum([dict_edge_shift_dist[(node,sn)] for sn in suc_nodes]))/float(len(suc_nodes))
return dict_edge_shift_dist
def main():
output_path, tree, classification_config = get_inputs()
successors = dict(nx.bfs_successors(tree, '0'))
add_defaults_to_classification_config(classification_config)
add_default_split_classification_id_to_tree(tree)
add_deep_descendants_to_classification_config(classification_config)
add_cost_by_level_in_tree(tree, successors)
print('\n'.join(map(str, classification_config.items())))
all_trees = classify_tree(tree, successors, classification_config)
print(f"All trees: {len(all_trees)}")
all_trees.sort(key=lambda x: x[0])
validated_trees = []
for cost, curr_tree in all_trees:
if is_valid_tree(curr_tree, classification_config, successors):
validated_trees.append((cost, curr_tree))
print(f"Valid trees: {len(validated_trees)}")
for curr_cost, curr_tree in validated_trees:
all_classifications = get_all_classifications_in_tree(curr_tree, successors)
print(f"Cost={curr_cost:.2f}, {'B1+2 is in tree' if 'LB1+2' in all_classifications else ''}")
# print('\n'.join(map(lambda a: f"{a[0]}: {a[1]}", validated_trees_with_cost)))
classified_tree = validated_trees[0][1]
add_colors_in_tree(classified_tree, classification_config)
# try:
# except IndexError:
# classified_tree = all_trees[0][1]
show_classification_vectors(classified_tree, successors)
nx.write_graphml(classified_tree, output_path)
def update_successors(root_scheme, G_scheme, dict_Sure, dict_StillSure,
RESOLUTION, G_stationPair, heap):
""" 如果一个目的车站的到达时间没有发生改变，则其子树的所有车站的到达时间都不会有变化，直接更新他们的出行方案
root_scheme: 到达时间没有改变的根节点 (出行方案已经更新过)
G_scheme: 树
"""
root = root_scheme[-1]['arrive_station']
set_successors = set() ## 以root为根的所有子节点
dict_successors = dict(nx.bfs_successors(G_scheme, source=root))
for name in dict_successors:
set_successors.add(name)
for successor in dict_successors[name]:
set_successors.add(successor)
set_successors = set_successors - set(dict_Sure.keys()) - set(
dict_StillSure.keys())
for name in set_successors:
if 'scheme' not in G_scheme.node[name]:
#print(name)
continue
dict_StillSure[name] = _update_scheme(root_scheme,
G_scheme.node[name]['scheme'],
RESOLUTION)
heapq.heappush(heap, (dict_StillSure[name][-1]['total_travelT'],
name)) # 加入堆 ###############
def get_observed_graph(self):
"""randomly pick a connected subgraph using BFS."""
train_edge_number = int(self.graph.number_of_edges() *
self.train_edge_ratio)
added_node = set()
added_edges_number = 0
_node = list(self.graph.nodes)
start_node = random.choice(_node)
added_node.add(start_node)
logging.debug("random choose start node {}".format(start_node))
for p, child in nx.bfs_successors(self.graph, start_node):
for n in child:
neighbor_n = set(self.graph.neighbors(n))
added_edges_number += len(neighbor_n & added_node)
added_node.add(n)
if added_edges_number >= train_edge_number:
h = self.graph.subgraph(added_node)
logging.info(
"random sample subgraph done. %d edges sampled. with %d nodes"
% (h.number_of_edges(), h.number_of_nodes()))
return h
raise RuntimeError(
"can not get {:d} edges starting from node {:d}".format(
train_edge_number, start_node))
def add_long_weight(self, start):
'''Add weight to nodes in a RootedTree so that longer paths are formed'''
lowerBound = 1
upperBound = len(self.tree.nodes())/10
digraph = nx.dfs_tree(self.tree, start)
node_visited = dict((key, False) for key in digraph.nodes())
# create a queue and push the starting node
to_visit = queue.Queue()
to_visit.put(start)
attribute = {}
attribute[start] = random.randint(lowerBound, upperBound)
# do the traversal
while to_visit.empty() == False:
node = to_visit.get()
children = dict(nx.bfs_successors(digraph, node, 1))[node]
if len(children) <= 0:
continue
heir = children[random.randint(0, len(children)-1)]
for cNode in children:
if node_visited[cNode] == False:
node_visited[cNode] = True
to_visit.put(cNode)
if (cNode == heir):
attribute[cNode] = attribute[node]
else:
attribute[cNode] = random.randint(
lowerBound, upperBound)
nx.set_node_attributes(self.tree, attribute, "weight")
def get_subgraph(g, edge_factors, start):
graph = nx.Graph()
graph.add_node(start)
for node, edges in nx.bfs_successors(g, start):
for edge in edges:
if edge_factors == 0:
break
graph.add_edge(node, edge)
edge_factors -= 1
return graph
# def edge_facts_subgraph(g, edge_number):
# count = 0
# res = {}
# for start_node in g.nodes:
# res[start_node] = []
# i = 0
# subgraph = nx.bfs_tree(g, start_node)
# for node in subgraph:
# if edge_number == i:
# break
# res[start_node].append(node)
# i += 1
# count += 1
# print(' Subgraph Knowledge[{} edges] {:.3%}\t\r'.format(edge_number, count/len(g.nodes)), file=stderr, end='')
# print()
# return res
def hirarcy(self, c, files_dict):
edges = []
interfaces = 'select path, superClass from classes'
files_Names = [x.split(".")[-1] for x in files_dict]
pathNames = {}
for row in c.execute(interfaces):
nameClass = (row[0]).split(".")[-1]
pathNames[nameClass] = row[0]
nameSuper = (row[1]).split(".")[-1]
if (nameClass in files_Names):
sup = 'root'
if (nameSuper in files_Names):
sup = nameSuper
edges.append((sup, nameClass))
g = networkx.DiGraph()
g.add_edges_from(edges)
degs = g.out_degree()
degsIN = g.in_degree()
succ = dict(networkx.bfs_successors(g, 'root'))
for s in succ:
succ[s] = len(succ[s])
paths = networkx.single_source_dijkstra_path(g, 'root')
depth = {}
for n in g.nodes():
depth[n] = 2
if (n in paths):
depth[n] = len(paths[n])
self.addFromDict(files_dict, degs, pathNames)
self.addFromDict(files_dict, degsIN, pathNames)
self.addFromDict(files_dict, succ, pathNames)
self.addFromDict(files_dict, depth, pathNames)
return files_Names,
def hirarcy(self, c, files_dict):
edges = []
interfaces = 'select path, superClass from classes'
files_Names = [x.split(".")[-1] for x in files_dict]
pathNames = {}
for row in c.execute(interfaces):
nameClass = (row[0]).split(".")[-1]
pathNames[nameClass] = row[0]
nameSuper = (row[1]).split(".")[-1]
if (nameClass in files_Names):
sup = 'root'
if (nameSuper in files_Names):
sup = nameSuper
edges.append((sup, nameClass))
g = networkx.DiGraph()
g.add_node('root')
g.add_edges_from(edges)
degs = g.out_degree()
degsIN = g.in_degree()
succ = dict(networkx.bfs_successors(g, 'root'))
for s in succ:
succ[s] = len(succ[s])
paths = networkx.single_source_dijkstra_path(g, 'root')
depth = {}
for n in g.nodes():
depth[n] = 2
if (n in paths):
depth[n] = len(paths[n])
self.addFromDict(files_dict,degs,pathNames)
self.addFromDict(files_dict,degsIN,pathNames)
self.addFromDict(files_dict,succ,pathNames)
self.addFromDict(files_dict,depth,pathNames)
return files_Names,
def test_BFS_node(self, G, source_node, depth=3):
print('source_node', source_node)
dfs_successor = nx.bfs_successors(G,
source=source_node,
depth_limit=depth)
print(dfs_successor)
dfs_successor = dict(dfs_successor)
# bfs_s
stack = []
dfs_result = defaultdict(list)
depth = 0
stack.append(source_node)
while len(stack) > 0:
node_list = stack
temp = []
for i in list(node_list):
if i in dfs_successor.keys():
for neighbour in dfs_successor[i]:
temp.append(neighbour)
dfs_result[depth].append(neighbour)
depth += 1
stack = temp
print(dfs_result)
return dfs_result
def bfs_seq(graph, root):
"""
Get a BFS transformation of a graph
:param graph: a networkx graph
:param root: a node index
:return: the BFS-ordered node indices
"""
dictionary = dict(nx.bfs_successors(graph, root))
to_visit = [root]
output = [root]
level_seq = [0]
level = 1
while len(to_visit) > 0:
next_level = []
while len(to_visit) > 0:
current = to_visit.pop(0)
neighbor = dictionary.get(current)
if neighbor is not None:
next_level += neighbor
level_seq += [level] * len(neighbor)
output += next_level
to_visit = next_level
level += 1
return output
def findAncestors(node):
Dic = dict(nx.bfs_successors(Dirgraph1, node))
d = Dic.values()
c = []
for e in d:
c = c + e
return c
def _find_loop_nodes_and_successors(self):
graph = self._region.graph
head = self._region.head
# find latching nodes
latching_nodes = set()
queue = [ head ]
traversed = set()
while queue:
node = queue.pop()
successors = graph.successors(node)
traversed.add(node)
for dst in successors:
if dst in traversed:
latching_nodes.add(node)
else:
queue.append(dst)
# find loop nodes and successors
loop_subgraph = RegionIdentifier.slice_graph(graph, head, latching_nodes, include_frontier=True)
loop_node_addrs = set( node.addr for node in loop_subgraph )
# Case A: The loop successor is inside the current region (does it happen at all?)
loop_successors = set()
for node, successors in networkx.bfs_successors(graph, head):
if node.addr in loop_node_addrs:
for suc in successors:
if suc not in loop_subgraph:
loop_successors.add(suc)
# Case B: The loop successor is the successor to this region in the parent graph
if not loop_successors:
parent_graph = self._parent_region.graph
for node, successors in networkx.bfs_successors(parent_graph, self._region):
if node.addr in loop_node_addrs:
for suc in successors:
if suc not in loop_subgraph:
loop_successors.add(suc)
return loop_subgraph, loop_successors
def networkx_test(filename): G = nx.read_gml(filename) t1 = datetime.now() a = nx.bfs_successors(G, 1) t2 = datetime.now() timedelta(0, 4, 316543) c = t2-t1 print a print "breadth first search using networkx graph on network dataset karate took ", c.microseconds, " microseconds"
def _is_child_observed(self, node):
"""Returns True if any descendant of the node
is observed"""
if node.observed:
return True
else:
child_dict = nx.bfs_successors(G, node)
for child in child_dict.keys():
for child_ in child_dict[child]:
if child_.observed:
return True
return False
def bfs_eff_diam(G, NTestNodes, P):
EffDiam = -1
FullDiam = -1
AvgSPL = -1
DistToCntH = {}
NodeIdV = nx.nodes(G)
random.shuffle(NodeIdV)
for tries in range(0, min(NTestNodes, nx.number_of_nodes(G))):
NId = NodeIdV[tries]
b = nx.bfs_successors(G, NId)
for l, h in hops(b, NId):
if h is 0:
continue
if not l + 1 in DistToCntH:
DistToCntH[l + 1] = h
else:
DistToCntH[l + 1] += h
DistNbrsPdfV = {}
SumPathL = 0.0
PathCnt = 0.0
for i in DistToCntH.keys():
DistNbrsPdfV[i] = DistToCntH[i]
SumPathL += i * DistToCntH[i]
PathCnt += DistToCntH[i]
oDistNbrsPdfV = collections.OrderedDict(sorted(DistNbrsPdfV.items()))
CdfV = oDistNbrsPdfV
for i in range(1, len(CdfV)):
if not i + 1 in CdfV:
CdfV[i + 1] = 0
CdfV[i + 1] = CdfV[i] + CdfV[i + 1]
EffPairs = P * CdfV[next(reversed(CdfV))]
for ValN in CdfV.keys():
if CdfV[ValN] > EffPairs:
break
if ValN >= len(CdfV):
return next(reversed(CdfV))
if ValN is 0:
return 1
# interpolate
DeltaNbrs = CdfV[ValN] - CdfV[ValN - 1]
if DeltaNbrs is 0:
return ValN
return ValN - 1 + (EffPairs - CdfV[ValN - 1]) / DeltaNbrs
def get_graph_hops(graph, num_samples):
c = Counter()
for i in range(0, num_samples):
node = sample(graph.nodes(), 1)[0]
b = nx.bfs_successors(graph, node)
for l, h in hops(b, node):
c[l] += h
hopper = Counter()
for l in c:
hopper[l] = float(c[l]) / float(num_samples)
return hopper
def find_dead_ends(graph, start_node, width):
"""Find dead ends in a graph."""
dead_ends = []
def collect_dead_ends(node):
x = node[0]
# do not consider dead ends on the right side of the maze, as those
# represents passages to the enemy's side
if graph.degree(node) == 1 and x < width - 1:
dead_ends.append(node)
for node in nx.bfs_successors(graph, start_node):
collect_dead_ends(node)
return dead_ends
def to_bio_tree(self):
import Bio.Phylo.BaseTree as BT
successor_dict = _nx.bfs_successors(self.G, SuffixTree.ROOT_NAME)
T = BT.Tree(name=SuffixTree.ROOT_NAME)
clade_dict = {SuffixTree.ROOT_NAME:T.clade}
next_up = [ SuffixTree.ROOT_NAME]
while len(next_up) > 0:
current = next_up.pop(0)
children = successor_dict.get(current,[])
for c in children:
new_clade = BT.Clade(name=c)
clade_dict[c] = new_clade
clade_dict[current].clades.append(new_clade)
next_up.extend(children)
return T
def limited_bfs_infection(self, node, target_num): original_target = target_num if target_num == 0: return 0 self.infect_user(node) target_num -= 1 successors = nx.bfs_successors(self.user_network,node) fringe = Queue.Queue() fringe.put(node) while not fringe.empty(): self.plot() coach = fringe.get() if coach in successors and len(successors[coach]) <= target_num: for student in successors[coach]: self.infect_user(student) fringe.put(student) target_num -= len(successors[coach]) return original_target - target_num
def main():
g = nx.Graph()
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(3, 1)
g.add_edge(4, 2)
print("Start search")
bfs_res = nx.bfs_predecessors(g, 0)
for x in bfs_res:
print(x)
print("Start search")
bfs_res = nx.bfs_successors(g, 0)
for x in bfs_res:
print(x)
print("Start search")
bfs_res = nx.bfs_tree(g, 0, depth_limit=1)
for x in bfs_res:
print(x)
nx.draw(g)
plt.show()
def maxmax_clusters(G):
"""Get clusters based on directed MaxMax graph.
My own twist to the MaxMax algorithm, but still in the MaxMax spirit.
Hope & Keller do this:
for node in G.nodes():
if node is marked ROOT:
mark children of node NOT-ROOT
But this means that with this structure, if we start with B and all nodes are
marked ROOT, then D is NOT-ROOT. This means that F and G will not be marked
NOT-ROOT:
A
B C
D
F G
I just return a list containing all maximal QSC subgraphs."""
# Function to create clusters. It takes a node and returns a set containing
# that node and all its successors.
cluster = lambda node: {node} | set(nx.bfs_successors(G,node))
# Get and sort all clusters by size:
clusters = sorted([cluster(node) for node in G.nodes()],key=len,reverse=True)
# Create list to output results:
results = []
# Loop through the ordered set of clusters, starting with the largest.
# Add cluster to the results iff it is not a subset of a cluster already in
# the results.
for c in clusters:
if not(True in [c.issubset(s_i) for s_i in results]):
results.append(c)
return results
def _all_successors(graph, nodes):
return [k for node in nodes for k in nx.bfs_successors(graph, node).keys()]
nodes = map(lambda x:x.lower(), nodes)
if len(nodes) == 1:###only a single node
G.add_node(nodes[0])
else:
for i in range(len(nodes) - 1):
node1 = nodes[i]
node2 = nodes[i+1]
if (node1, node2) in G.edges():##does not allow reverse propagation
continue
try:
G[node2][node1]['weight'] += 1
except KeyError:
G.add_edge(node2, node1, weight=1)
infile.close()
return G
##############analyze diffusion graph#####################
index = 1
cas_file = os.path.join(cas_dir, str(index) + '.cas')
G = generate_graph(cas_file)
graphs = nx.weakly_connected_component_subgraphs(G)
sorted_graphs = sorted(graphs, key=lambda x:len(x.nodes()), reverse=True)
convert_graph_to_csv(sorted_graphs[0], 'temp_file')
paths = nx.bfs_successors(G, 'cgseife')
print paths.keys()
print paths['rogerhighfield']
#print paths['berry_k']['trimetilsilyl']
#print paths
def bfs_test_successor(self):
assert_equal(dict(nx.bfs_successors(self.G, source=1, depth_limit=3)),
{1: [0, 2], 2: [3, 7], 3: [4], 7: [8]})
result = {n: sorted(s) for n, s in nx.bfs_successors(self.D, source=7,
depth_limit=2)}
assert_equal(result, {8: [9], 2: [3], 7: [2, 8]})
def test_successor(self):
assert_equal(nx.bfs_successors(self.G,source=0),
{0: [1], 1: [2,3], 2:[4]})
import networkx as nx
fp1=open("Cit-HepPh.txt",'r')
fp1.readline()
fp1.readline()
fp1.readline()
fp1.readline()
G = nx.DiGraph()
#i=0
while True:
line=fp1.readline()
if not line:
break
tk=line.split('\t')
#print i
#i=i+1
G.add_edge(int(tk[0]),int(tk[1]))
fp2=open("dfs_outputs.txt",'w')
fp2.write(str(dict(nx.bfs_successors(G,9907233))))
fp1.close()
fp2.close()
def obj_transform(dataframe=None, G=None):
dataframe1 = pd.concat([dataframe['enrollment_id'], pd.get_dummies(dataframe['category'])], axis=1)
if G:
betweenness = nx.betweenness_centrality(G)
in_degree = nx.in_degree_centrality(G)
out_degree = nx.out_degree_centrality(G)
pagerank = nx.pagerank(G)
nrow = dataframe.shape[0]
graph_features = np.zeros((nrow, 7))
for i in xrange(nrow):
graph_features[i,0] = in_degree[dataframe['module_id'][i]] * 5000.0
graph_features[i,1] = out_degree[dataframe['module_id'][i]] * 5000.0
graph_features[i,2] = betweenness[dataframe['module_id'][i]] * 5000.0
graph_features[i,3] = pagerank[dataframe['module_id'][i]] * 5000.0
#pre = nx.bfs_predecessors(G, dataframe['module_id'][i])
suc = nx.bfs_successors(G, dataframe['module_id'][i])
graph_features[i,4] = depth(dataframe['module_id'][i], suc)
graph_features[i,5] = len( list(nx.ancestors(G, dataframe['module_id'][i]) ))
graph_features[i,6] = len( list(nx.descendants(G, dataframe['module_id'][i]) ))
temp = pd.DataFrame(graph_features, index=dataframe.index)
temp.columns = ['inDgree', 'outDegree', 'betweenness', 'pagerank',
'depth', 'N_ancestor', 'N_child']
temp['enrollment_id'] = dataframe['enrollment_id']
temp.to_csv('debugDir/checkpoint.csv')
# aggregating
dataframe1 = dataframe1.groupby('enrollment_id').aggregate(np.sum)
temp1 = temp.groupby('enrollment_id').aggregate(np.mean)
nameList = []
colName = ['inDgree', 'outDegree', 'betweenness', 'pagerank',
'depth', 'N_ancestor', 'N_child']
for name in colName:
nameList.append(name + '_mean')
temp1.columns = nameList
dataframe1 = pd.concat([dataframe1, temp1], axis=1)
temp1 = temp.groupby('enrollment_id').aggregate(np.std)
nameList = []
for name in colName:
nameList.append(name + '_std')
temp1.columns = nameList
dataframe1 = pd.concat([dataframe1, temp1], axis=1)
temp1 = temp.groupby('enrollment_id').aggregate(np.min)
nameList = []
for name in colName:
nameList.append(name + '_min')
temp1.columns = nameList
dataframe1 = pd.concat([dataframe1, temp1], axis=1)
temp1 = temp.groupby('enrollment_id').aggregate(np.max)
nameList = []
for name in colName:
nameList.append(name + '_max')
temp1.columns = nameList
dataframe1 = pd.concat([dataframe1, temp1], axis=1)
return dataframe1
# inserir o vertice s e t
for i in range(0, vi ):
l = int(i / colunas)
c = i % colunas
# print("i = " + str(i) + "; l = " + str(l) + "; c = " + str(c))
pixel = image[l][c]
G.add_edge('s', str(i), capacity=abs(pixel - media_s))
G.add_edge(str(i), 't', capacity=abs(pixel - media_t))
Gf = ford_fulkerson(G, 's', 't', 'capacity')
flow = Gf.graph['flow_value']
flow_dict = Gf.graph['flow_dict']
suc = nx.bfs_successors(Gf, 's')
resultado = np.zeros((64,64), dtype=np.int8)
vertices = suc['s']
for i in range(0, len(vertices)):
t = int(vertices[i])
l = int(t / 64)
c = t % 64
resultado[l][c] = 1
io.imshow(resultado)
def _keep_fused_form(self,posPreferenceDicts):
# For a span A,B and external tokens C, such as A > B > C, we have to
# Make A the head of the span
# Attach C-level tokens to A
#Remove B-level tokens, which are the subtokens of the fused form della: de la
if self.graph["multi_tokens"] == {}:
return
spanheads = []
spanhead_fused_token_dict = {}
# This double iteration is overkill, one could skip the spanhead identification
# but in this way we avoid modifying the tree as we read it
for fusedform_idx in sorted(self.graph["multi_tokens"]):
fusedform_start, fusedform_end = self.graph["multi_tokens"][fusedform_idx]["id"]
fuseform_span = list(range(fusedform_start,fusedform_end+1))
spanhead = self._choose_spanhead_from_heuristics(fuseform_span,posPreferenceDicts)
#if not spanhead:
# spanhead = self._choose_spanhead_from_heuristics(fuseform_span,posPreferenceDicts)
spanheads.append(spanhead)
spanhead_fused_token_dict[spanhead] = fusedform_idx
bottom_up_order = [x for x in nx.topological_sort(self) if x in spanheads]
for spanhead in bottom_up_order:
fusedform_idx = spanhead_fused_token_dict[spanhead]
fusedform = self.graph["multi_tokens"][fusedform_idx]["form"]
fusedform_start, fusedform_end = self.graph["multi_tokens"][fusedform_idx]["id"]
fuseform_span = list(range(fusedform_start,fusedform_end+1))
if spanhead:
#Step 1: Replace form of head span (A) with fusedtoken form -- in this way we keep the lemma and features if any
self.node[spanhead]["form"] = fusedform
# 2- Reattach C-level (external dependents) to A
#print(fuseform_span,spanhead)
internal_dependents = set(fuseform_span) - set([spanhead])
external_dependents = [nx.bfs_successors(self,x) for x in internal_dependents]
for depdict in external_dependents:
for localhead in depdict:
for ext_dep in depdict[localhead]:
deprel = self[localhead][ext_dep]["deprel"]
self.remove_edge(localhead,ext_dep)
self.add_edge(spanhead,ext_dep,deprel=deprel)
#3- Remove B-level tokens
for int_dep in internal_dependents:
self.remove_edge(self.head_of(int_dep),int_dep)
self.remove_node(int_dep)
#4 reconstruct tree at the very end
new_index_dict = {}
for new_node_index, old_node_idex in enumerate(sorted(self.nodes())):
new_index_dict[old_node_idex] = new_node_index
T = DependencyTree() # Transfer DiGraph, to replace self
for n in sorted(self.nodes()):
T.add_node(new_index_dict[n],self.node[n])
for h, d in self.edges():
T.add_edge(new_index_dict[h],new_index_dict[d],deprel=self[h][d]["deprel"])
#4A Quick removal of edges and nodes
self.__init__()
#4B Rewriting the Deptree in Self
# TODO There must a more elegant way to rewrite self -- self= T for instance?
for n in sorted(T.nodes()):
self.add_node(n,T.node[n])
for h,d in T.edges():
self.add_edge(h,d,T[h][d])
# 5. remove all fused forms form the multi_tokens field
self.graph["multi_tokens"] = {}
if not nx.is_tree(self):
print("Not a tree after fused-form heuristics:",self.get_sentence_as_string())
