def get_connection_multigraph_weighted(name2dp, connections): G = MultiDiGraph() for c in connections: dp1 = c.dp1 dp2 = c.dp2 if not G.has_edge(dp1, dp2): already = [] G.add_edge(dp1, dp2) else: already = G.edge[dp1][dp2]['spaces'] R = name2dp[c.dp1].get_rtype(c.s1) already.append(R) G.edge[dp1][dp2]['spaces'] = already # cycles = list(simple_cycles(G)) # for cycle in cycles: # cycle = list(cycle) # cycle = cycle + [cycle[0]] # # for i in range(len(cycle) - 1): # # XXX # _val = G.edge[cycle[i]][cycle[i + 1]]['spaces'] # # print('%s -> %s -> %s' % (cycle[i], val, cycle[i + 1])) return G
def get_connection_multigraph(connections): G = MultiDiGraph() for c in connections: dp1 = c.dp1 dp2 = c.dp2 G.add_edge(dp1, dp2, s1=c.s1) return G
def convert_grandalf_graph_to_networkx_graph(G): from networkx import MultiDiGraph nxg = MultiDiGraph() for v in G.V(): nxg.add_node(v.data) for e in G.E(): nxg.add_edge(e.v[0].data, e.v[1].data) return nxg
def get_meausurements_graph(po): G = MultiDiGraph() for name, sr in iterate_measurements_relations((), po): a = sr.a b = sr.b attr_dict = dict(sr=sr) G.add_edge(a, b, attr_dict=attr_dict) return G
def add_edge(mygraph: MultiDiGraph, edge: str, origincolor: str, colormap: dict) -> MultiDiGraph: edge = reduce(str.removesuffix, [" bags", " bag"], edge) origincolornum = colormap.get(origincolor) num, tcolor = edge.split(" ", 1) for _ in range(int(num)): mygraph.add_edge(origincolornum, colormap.get(tcolor)) return mygraph
def get_edges_data_from(graph: nx.MultiDiGraph, node_from_id: int, route_id: int) -> list: edges = set() for node_to_id in graph.neighbors(node_from_id): for edge in graph.get_edge_data(node_from_id, node_to_id).values(): if edge['route_id'] == route_id: edges.add( (int(edge['route_id']), node_from_id, node_to_id, int(edge['duration']), int(edge['period']))) return list(edges)
def relationship_edges(schema_graph_nx: nx.MultiDiGraph, class_add_mod: dict, **kwargs) -> nx.MultiDiGraph: """ Notes: ===== # pass the below dictionary as the third argument (kwargs) to relationship_edges(). # "in" indicates that the relationship has an in-edges behaviour. # "out" indicates that the relationship has an out-edges behaviour. rel_dict = { "rdfs:subClassOf": { "parentOf": "in" }, "schema:domainIncludes": { "domainValue": "in" }, "sms:requiresDependency": { "requiresDependency": "out" }, "sms:requiresComponent": { "requiresComponent": "out" }, "schema:rangeIncludes": { "rangeValue": "out" } } """ for rel, rel_lab_node_type in kwargs.items(): for rel_label, node_type in rel_lab_node_type.items(): if rel in class_add_mod: parents = class_add_mod[rel] if type(parents) == list: for _parent in parents: if node_type == "in": n1 = extract_name_from_uri_or_curie(_parent["@id"]) n2 = class_add_mod["rdfs:label"] if node_type == "out": n1 = class_add_mod["rdfs:label"] n2 = extract_name_from_uri_or_curie(_parent["@id"]) # do not allow self-loops if n1 != n2: schema_graph_nx.add_edge(n1, n2, key=rel_label) elif type(parents) == dict: if node_type == "in": n1 = extract_name_from_uri_or_curie(parents["@id"]) n2 = class_add_mod["rdfs:label"] if node_type == "out": n1 = class_add_mod["rdfs:label"] n2 = extract_name_from_uri_or_curie(parents["@id"]) # do not allow self-loops if n1 != n2: schema_graph_nx.add_edge(n1, n2, key=rel_label) return schema_graph_nx
def add_reshape_before_op_node(graph: nx.MultiDiGraph, data_node_name: str, op_node_name: str, edge_attrs: dict): """ Adds reshape operation which expands dimension of the specified data tensor to 4D. :param graph: graph to operate on. :param data_node_name: the name of the data node to be reshaped to 4D tensor. :param op_node_name: name of the TFCustomSubgraphCall node which produces the tensor. :param edge_attrs: edge attributes which should be preserved. :return: None """ data_node = Node(graph, data_node_name) graph.remove_edge(data_node_name, op_node_name) assert data_node['shape'] is not None new_shape = make_shape_4d(data_node['shape']) # reshape shape data node reshape_shape_data_node_name = unique_id(graph, "Reshape_shape_") graph.add_node(reshape_shape_data_node_name, kind='data', precision="FP32", name=reshape_shape_data_node_name, value=new_shape, shape=[1]) # reshape operation node reshape_node_name = unique_id(graph, "Reshape_") graph.add_node(reshape_node_name, kind='op', precision="FP32", type='Reshape', name=reshape_node_name, op='Reshape', data_type=data_node['data_type']) update_ie_fields(graph.node[reshape_node_name]) # reshaped data node reshaped_value = None if data_node['value'] is not None: reshaped_value = np.reshape(data_node['value'], new_shape) reshaped_data_node_name = unique_id(graph, "reshaped_data_") graph.add_node(reshaped_data_node_name, kind='data', precision="FP32", name=reshaped_data_node_name, shape=new_shape, value=reshaped_value, nchw_layout=True) graph.add_edges_from([(data_node_name, reshape_node_name, { 'in': 0 }), (reshape_shape_data_node_name, reshape_node_name, { 'in': 1 }), (reshape_node_name, reshaped_data_node_name, { 'out': 0 }), (reshaped_data_node_name, op_node_name, edge_attrs)])
def replace_pattern(self, graph: nx.MultiDiGraph, match: dict): node = match['pad'] for port, input_node in node.in_nodes().items(): if port != 0: graph.remove_edge(input_node.id, node.id) # remove Pad operation if all pads are equal to 0 if np.all(node.pads == 0): remove_op_node_with_data_node(graph, node)
def find_and_replace_pattern(self, graph: nx.MultiDiGraph): for n in pseudo_topological_sort(graph): if graph.node[n][ 'kind'] == 'data' or graph.node[n]['op'] != 'Switch': continue switch_op_node = Node(graph, n) pred_id_data_node = switch_op_node.in_node(1) graph.remove_edge(pred_id_data_node.id, switch_op_node.id) remove_op_node_with_data_node(graph, switch_op_node)
def query_inductions(sample: nx.MultiDiGraph, edge_queries: List[List[Edge]], ownership: Ownership): remote_queries = mpi.comm.alltoall(edge_queries) answers = [ list(filter(lambda e: e[1] in ownership, q)) for q in remote_queries ] remote_answers = mpi.comm.alltoall(answers) for remote_answer in remote_answers: sample.add_edges_from(remote_answer)
def get_graph(): graph = MultiDiGraph() graph.add_edge('B', 'A', edge_label='biolink:sub_class_of') graph.add_edge('C', 'B', edge_label='biolink:sub_class_of') graph.add_edge('D', 'C', edge_label='biolink:sub_class_of') graph.add_edge('D', 'A', edge_label='biolink:related_to') graph.add_edge('E', 'D', edge_label='biolink:sub_class_of') graph.add_edge('F', 'D', edge_label='biolink:sub_class_of') return graph
def get_vertex_attrib(G: nx.MultiDiGraph): X_V = np.zeros(shape=(G.number_of_nodes(), 2), dtype=np.float32) index = 0 for node in G.nodes(data=True): u, info = node X_V[index][0] = G.in_degree(u) X_V[index][1] = G.out_degree(u) index += 1 return X_V / 6
def test_content_hash() -> None: # the order of properties should not matter for the content hash g = MultiDiGraph() g.add_node("1", reported={"a": {"a": 1, "c": 2, "b": 3}, "c": 2, "b": 3, "d": "foo", "z": True, "kind": "a"}) g.add_node("2", reported={"z": True, "c": 2, "b": 3, "a": {"b": 3, "c": 2, "a": 1}, "d": "foo", "kind": "a"}) access = GraphAccess(g) sha1 = node(access, "1")["hash"] # type: ignore sha2 = node(access, "2")["hash"] # type: ignore assert sha1 == sha2
def replace_sub_graph(self, graph: nx.MultiDiGraph, match: dict): decoder_node = match['decoder'] graph.remove_edge(decoder_node.id, match['sparse_to_dense'].id) graph.remove_edge(decoder_node.id, match['cast'].id) replace_node(match['sparse_to_dense'], decoder_node) # update the TensorFlow infer function for the CTCGreedyDecoder to make necessary changes with the second input decoder_node['old_infer'] = decoder_node.infer decoder_node.infer = __class__.tf_greedy_decoder_infer return {}
def get_edge_attrib_for_GCN(G: nx.MultiDiGraph, edge_attrib, vertex_attrib): N_E = edge_attrib.shape[1] N_V = vertex_attrib.shape[1] X_E = np.zeros(shape=(G.number_of_edges(), N_E + 2 * N_V)) for i, e in enumerate(G.edges(keys=True, data=True)): u, v, k, info = e X_E[i, 0:N_E] = edge_attrib[i] X_E[i, N_E:N_E + N_V] = vertex_attrib[u] X_E[i, N_E + N_V:N_E + 2 * N_V] = vertex_attrib[v] return X_E
def replace_sub_graph(self, graph: nx.MultiDiGraph, match: dict): node = match['op'] # here we request all data flow output edges (control flow edges will not be listed) out_edges = node.out_edges() if len(out_edges) == 0: graph.remove_node(node.id) log.debug('Assert op was removed {}'.format(node.id)) else: raise Error('Data flow edge coming out of Assert node {}'.format( node.id))
def construct_multi_di_graph(edges: List[Tuple[str, str, Any]]) -> MultiDiGraph: """Constructs a multi directed graph from a list of edges. Arguments: edges: A list of tuples with entries: start, end and identifier. """ g = MultiDiGraph() for start, end, key in edges: g.add_edge(start, end, key=key) return g
def __init__(self, g_input: Graph) -> None: log.info( f"FeatureConcatenator: Initiating with a graph of {g_input.number_of_nodes()} nodes " f"and {g_input.number_of_edges()} edges" ) self.g_input = g_input self.g = MultiDiGraph(deepcopy(g_input)) self._obtain_attrs() self._init_feat_attrs()
def get_all_successors(bag: str, graph: nx.MultiDiGraph) -> set: child_bags = [] for child_bag in graph.successors(bag): succ = get_all_successors(child_bag, graph) for i in range(graph.number_of_edges(bag, child_bag)): child_bags.append(child_bag) child_bags += succ return child_bags
def inserir_nodo_grafo(grafo: MultiDiGraph, chave: int, nodo: dict, nodo_novo: dict): grafo.add_node(chave,\ posicao_labirinto=nodo_novo["posicao_labirinto"],\ chave=chave,\ acao=nodo_novo["acao"],\ custo_caminho=nodo_novo["custo_caminho"]) if nodo is not None: grafo.add_edge(nodo["chave"], chave)
def eliminate_dead_nodes(graph: nx.MultiDiGraph): nodes_to_remove = set() for node_name, node_attrs in graph.nodes(data=True): if not node_attrs['is_output_reachable'] or ( node_attrs['is_const_producer'] and not node_attrs['is_undead']): nodes_to_remove.add(node_name) log.debug('Removing the following dead nodes: {}'.format('\n'.join( sorted(map(str, nodes_to_remove))))) graph.remove_nodes_from(nodes_to_remove)
def im_json_to_graph(im_json): """Return networkx graph from Kappy's influence map JSON. Parameters ---------- im_json : dict A JSON dict which contains an influence map generated by Kappy. Returns ------- graph : networkx.MultiDiGraph A graph representing the influence map. """ imap_data = im_json['influence map']['map'] # Initialize the graph graph = MultiDiGraph() id_node_dict = {} # Add each node to the graph for node_dict in imap_data['nodes']: # There is always just one entry here with the node type e.g. "rule" # as key, and all the node data as the value node_type, node = list(node_dict.items())[0] # Add the node to the graph with its label and type attrs = { 'fillcolor': '#b7d2ff' if node_type == 'rule' else '#cdffc9', 'shape': 'box' if node_type == 'rule' else 'oval', 'style': 'filled' } graph.add_node(node['label'], node_type=node_type, **attrs) # Save the key of the node to refer to it later new_key = '%s%s' % (node_type, node['id']) id_node_dict[new_key] = node['label'] def add_edges(link_list, edge_sign): attrs = { 'sign': edge_sign, 'color': 'green' if edge_sign == 1 else 'red', 'arrowhead': 'normal' if edge_sign == 1 else 'tee' } for link_dict in link_list: source = link_dict['source'] for target_dict in link_dict['target map']: target = target_dict['target'] src_id = '%s%s' % list(source.items())[0] tgt_id = '%s%s' % list(target.items())[0] graph.add_edge(id_node_dict[src_id], id_node_dict[tgt_id], **attrs) # Add all the edges from the positive and negative influences add_edges(imap_data['wake-up map'], 1) add_edges(imap_data['inhibition map'], -1) return graph
def summarize_nodes(graph: nx.MultiDiGraph, facet_properties: List = None) -> Dict: """ Summarize the nodes in a graph. Parameters ---------- graph: networkx.MultiDiGraph The graph facet_properties: List A list of properties to facet on Returns ------- Dict The node stats """ stats = { TOTAL_NODES: 0, NODE_CATEGORIES: set(), COUNT_BY_CATEGORY: { 'unknown': { 'count': 0 } } } stats[TOTAL_NODES] = len(graph.nodes()) if facet_properties: for facet_property in facet_properties: stats[facet_property] = set() for n, data in graph.nodes(data=True): if 'category' not in data: stats[COUNT_BY_CATEGORY]['unknown']['count'] += 1 continue categories = data['category'] stats[NODE_CATEGORIES].update(categories) for category in categories: if category in stats[COUNT_BY_CATEGORY]: stats[COUNT_BY_CATEGORY][category]['count'] += 1 else: stats[COUNT_BY_CATEGORY][category] = {'count': 1} if facet_properties: for facet_property in facet_properties: stats = get_facet_counts(data, stats, COUNT_BY_CATEGORY, category, facet_property) stats[NODE_CATEGORIES] = sorted(list(stats[NODE_CATEGORIES])) if facet_properties: for facet_property in facet_properties: stats[facet_property] = sorted(list(stats[facet_property])) return stats
def from_osmnx(oxg: nx.MultiDiGraph, use_label: bool): """ The method transforms an OSMX MultiDiGraph into a PrimalGraph object :param oxg: an OSMX MultiDiGraph :param use_label: if true, it maps streets' type as labels (required for the HICN algorithm) otherwise, streets' type are standardized as "unlabeled" (required for the ICN algorithm) :return: PrimalGraph """ # creating an empty primal graph primal_graph = PrimalGraph() # converting a MultiDiGraph into a simple Graph oxg = nx.Graph(oxg) # removing self-loops from the resulting graph oxg.remove_edges_from(oxg.selfloop_edges()) # latitude (y-axis) and longitude (x-axis) node_dictionary = { nid: (data['y'], data['x']) for nid, data in oxg.nodes(data=True) } # updating the dictionary of nodes primal_graph.node_dictionary = node_dictionary eid = 0 edge_dictionary = {} for source, target, data in oxg.edges(data=True): name = data.get( 'name', 'unknown') # unknown is the default value for streets' name label = data.get( 'highway', 'unclassified' ) # unclassified is the default value for streets' type length = compute_distance( node_dictionary[source], node_dictionary[target] ) # straight-line distance between source and target nodes # creating a new PrimalEdge with information from the current edge edge = primal_graph.Edge( eid, source, target, float(length), 'unknown' if type(name) == list else name, 'unclassified' if type(label) == list else label if use_label else 'unclassified') # storing the new edge in the edge dictionary edge_dictionary[eid] = edge eid += 1 # updating the dictionary of edges primal_graph.edge_dictionary = edge_dictionary # building and returning the resulting PrimalGraph return primal_graph.build_graph()
def scale_free_graph(n, alpha=0.41,beta=0.54,delta_in=0.2,delta_out=0): def _choose_node(G,distribution,delta): cumsum = 0.0 psum = float(sum(distribution.values()))+float(delta)*len(distribution) r = random.random() for i in range(0, len(distribution)): cumsum += (distribution[i]+delta)/psum if r < cumsum: break return i G = MultiDiGraph() G.add_edges_from([(0,1),(1,2),(2,0)]) gamma = 1 - alpha - beta while len(G)<n: r = random.random() if r < alpha: v = len(G) w = _choose_node(G, G.in_degree(),delta_in) elif r < alpha+beta: v = _choose_node(G, G.out_degree(),delta_out) w = _choose_node(G, G.in_degree(),delta_in) else: v = _choose_node(G, G.out_degree(),delta_out) w = len(G) G.add_edge(v,w) return G
def _add_entry_point_for_graph(graph: nx.MultiDiGraph, tag=True): entry_points = [] name = graph.graph["name"] for node_id in graph.nodes: if graph.in_degree(node_id) == 0: # 入口节点 entry_points.append(node_id) if tag is True: graph.add_node("{}@entry".format(name), label="ENTRY", type="ENTRY", expression="ENTRY") else: graph.add_node("entry", label="ENTRY", type="ENTRY", expression="ENTRY") for entry_point in entry_points: if tag is True: graph.add_edge("{}@entry".format(name), entry_point) else: graph.add_edge("entry", entry_point) return graph
def sst(n): S = MultiDiGraph() morphisms = [('X' + str(m + 1), 'X' + str(m), 'd' + str(m) + str(i)) for m in range(n) for i in range(m + 2)] relations = [] if n > 1: relations = [(('X'+str(m+2),'X'+str(m),'d'+str(m+1)+str(j)+'d'+str(m)+str(i)),\ ('X'+str(m+2),'X'+str(m),'d'+str(m+1)+str(i)+'d'+str(m)+str(j-1))) for m in range(n-1) for j in range(1,m+3) for i in range(j)] S.add_edges_from(morphisms) return fic(S, relations)
def delete_not_executable(graph: nx.MultiDiGraph): nodes_to_remove = set() for node_name, node_attrs in graph.nodes(data=True): if node_attrs[ 'kind'] == 'data' and 'executable' in node_attrs and not node_attrs[ 'executable']: [nodes_to_remove.add(op) for op, _ in graph.in_edges(node_name)] nodes_to_remove.add(node_name) log.debug('Removing the following not executable nodes: {}'.format( '\n'.join(sorted(map(str, nodes_to_remove))))) graph.remove_nodes_from(nodes_to_remove)
def combine_dots(dotlist, mathid): g1 = drawing.nx_agraph.read_dot(TMP + dotlist[-1]) g = MultiDiGraph() for d in dotlist: g2 = drawing.nx_agraph.read_dot(TMP + d) g1 = compose(g1, g2) g.add_nodes_from(g1.nodes(data=True)) g.add_edges_from(g1.edges(data=True)) g.to_directed() g = nx_agraph.to_agraph(g) g.write(TMP + '-'.join(mathid) + '.dot')
def transaction_cycle(graph: nx.MultiDiGraph) -> None: """ Find a cycle from an account back to itself, to determine if a series of transactions ever comes back full circle. This function tracks a series of transactions from one account to others, to see if any Ether that this account sent out eventually may have come back to it, as a means of studying the flow of currency amongst accounts. Preconditions: - list(graph.nodes) != [] """ # Find any relevant nodes that we can recurse on to find cycles: # Criteria: # - Must have at least 1 successor (outgoing transaction) # - Must have at least 1 predecessor (incoming transaction) accounts = [] for node in graph.nodes(): num_predecessors = len(list(graph.predecessors(node))) num_successors = len(list(graph.successors(node))) if num_successors >= 1 and num_predecessors >= 1: accounts.append(node) # Loop through all the possible candidate accounts for having a cycle. cycles = [] for account in accounts: main_acc = account # Now, we will check every successor of this main node (to see # whether or not it is involved in a cycle that ends back at # this main node.) print(f"Starting Account: {main_acc}") print("Beginning search for cycle starting with this account...") cycle = _check_cycle(graph, main_acc, main_acc, set(), 0) if cycle is not None: print(f"Cycle found for: {main_acc}") cycles.append(cycle) else: print(f"No Cycle found for: {main_acc}") print("---------------------------------------") # Print a summary of what was found. print("###########SUMMARY############") print(f"Number of cycles found: {len(cycles)}") if cycles == []: print("Unfortunately, no cycles could be found.") else: for i in range(0, len(cycles)): print(f"Cycle {i + 1}: {cycles[i]}")
def __init__(self, activation_fn=None): """Initialize the NetworkXKB.""" # parameters if activation_fn is None: activation_fn = (lambda graph, mem_id: None) self.activation_fn = activation_fn # variables self.graph = MultiDiGraph() self.inverted_index = defaultdict(set) self.query_results = None self.result_index = None self.clear()
def add_data_from_single_image_graph_to_cluster_graph(line_graph: nx.DiGraph, graph: nx.MultiDiGraph): for node in line_graph.adj: for neighbour in nx.neighbors(line_graph, node): edge = line_graph.get_edge_data(node, neighbour) for neighbour2 in nx.neighbors(line_graph, neighbour): edge2 = line_graph.get_edge_data(neighbour, neighbour2) graph.add_edge(edge['cluster'], edge2['cluster'], key=None, nodes_from=str(node) + "_" + str(neighbour), nodes_to=str(neighbour) + "_" + str(neighbour2))
def add_cfg_edges(g: nx.MultiDiGraph, node): """Add edges with attr `cfg` or `in` for control flow for the given node""" if isinstance(node, clang.graph.FunctionInfo): for cfg_b in node.cfgBlocks: g.add_node(cfg_b, attr="cfg") for succ in cfg_b.successors: g.add_edge(cfg_b, succ, attr="cfg") g.add_node(succ, attr="cfg") for stmt in cfg_b.statements: g.add_edge(stmt, cfg_b, attr="in") g.add_node(stmt, attr=(stmt.name))
def read_cref(inmap): modules = MultiDiGraph() while True: l = inmap.readline() words = l.split() if len(words) == 2: last_symbol = words[0] last_module = words[1] elif len(words) == 1: modules.add_edge(words[0], last_module, label=last_symbol); elif len(l) == 0: break return modules
def im_json_to_graph(im_json): """Return networkx graph from Kappy's influence map JSON. Parameters ---------- im_json : dict A JSON dict which contains an influence map generated by Kappy. Returns ------- graph : networkx.MultiDiGraph A graph representing the influence map. """ imap_data = im_json['influence map']['map'] # Initialize the graph graph = MultiDiGraph() id_node_dict = {} # Add each node to the graph for node_dict in imap_data['nodes']: # There is always just one entry here with the node type e.g. "rule" # as key, and all the node data as the value node_type, node = list(node_dict.items())[0] # Add the node to the graph with its label and type attrs = {'fillcolor': '#b7d2ff' if node_type == 'rule' else '#cdffc9', 'shape': 'box' if node_type == 'rule' else 'oval', 'style': 'filled'} graph.add_node(node['label'], node_type=node_type, **attrs) # Save the key of the node to refer to it later new_key = '%s%s' % (node_type, node['id']) id_node_dict[new_key] = node['label'] def add_edges(link_list, edge_sign): attrs = {'sign': edge_sign, 'color': 'green' if edge_sign == 1 else 'red', 'arrowhead': 'normal' if edge_sign == 1 else 'tee'} for link_dict in link_list: source = link_dict['source'] for target_dict in link_dict['target map']: target = target_dict['target'] src_id = '%s%s' % list(source.items())[0] tgt_id = '%s%s' % list(target.items())[0] graph.add_edge(id_node_dict[src_id], id_node_dict[tgt_id], **attrs) # Add all the edges from the positive and negative influences add_edges(imap_data['wake-up map'], 1) add_edges(imap_data['inhibition map'], -1) return graph
def to_directed(self): """Return a directed representation of the graph. A new multidigraph is returned with the same name, same nodes and with each edge (u,v,data) replaced by two directed edges (u,v,data) and (v,u,data). """ from networkx import MultiDiGraph G=MultiDiGraph() G.add_nodes_from(self) G.add_edges_from( ((u,v,data) for u,nbrs in self.adjacency_iter() \ for v,datalist in nbrs.iteritems() for data in datalist) ) return G
def combine_dots(dotlist): g1=drawing.nx_agraph.read_dot('dots/'+dotlist[-1]) g = MultiDiGraph() for i in xrange(len(dotlist)): g2=drawing.nx_agraph.read_dot('dots/'+dotlist[i]) g1=compose(g1,g2) g.add_nodes_from(g1.nodes(data=True)) g.add_edges_from(g1.edges(data=True)) g.to_directed() g = nx_agraph.to_agraph(g) g.write('dots/combined.dot')
def combine_dots(dotlist,sciid): g1=drawing.nx_agraph.read_dot(TMP+dotlist[-1]) g = MultiDiGraph() for d in dotlist: g2=drawing.nx_agraph.read_dot(TMP + d) g1=compose(g1,g2) g.add_nodes_from(g1.nodes(data=True)) g.add_edges_from(g1.edges(data=True)) g.to_directed() g = nx_agraph.to_agraph(g) g.write(TMP+'-'.join(sciid)+'.dot')
def __init__(self, filename='graph.json'): self.filename=filename self.graph = MultiDiGraph() self.typed_nodes = {} self.typed_nodes[None] = [] try: self.load_file(filename) except IOError as e: print 'file "%s" does not exist, creating' % filename
def selector(request): request.session['viewer'] = request.path_info if request.method == 'POST': form = Neo4jQueryForm(request.POST) if form.is_valid(): host = request.session.get('host', None) if host: gdb = GraphDatabase(host) node = gdb.node[form.cleaned_data['node']] depth = form.cleaned_data['depth'] new_nodes = [] graph = MultiDiGraph() node_id = str(node.id) graph.add_node(node_id, **node.properties) new_nodes.append(node_id) for i in range(depth): added_nodes = [] for node_id in new_nodes: node = gdb.node[node_id] for relation in node.relationships.all(): start = relation.start end = relation.end if start not in new_nodes: start_id = str(start.id) graph.add_node(start_id, **start.properties) added_nodes.append(start_id) if end not in new_nodes: end_id = str(end.id) graph.add_node(end_id, **end.properties) added_nodes.append(end_id) graph.add_edge(start_id, end_id, **relation.properties) new_nodes += added_nodes interactor = NetworkxInteractor(graph) request.session['interactor'] = interactor request.session['layout'] = None response_dictionary = set_response_dictionary(request) else: form = Neo4jConnectionForm() return render_to_response('neo4j/index.html', { 'form': form, }) return render_to_response('neo4j/explorer.html', response_dictionary) else: interactor = request.session.get('interactor') return render_to_response('neo4j/explorer.html', set_response_dictionary(request))
def compute_max_weight(G: networkx.MultiDiGraph, start: int = META_REACTANT) -> None: """Compute maximum weight paths. This function annotates each node of the graph with its maximum weight from the starting node and a link to its predecessor. """ def extract_max(labels): max_weight = -1 max_label = None for label in labels: if G.node[label]['max_weight'] > max_weight: max_weight = G.node[label]['max_weight'] max_label = label if max_label is not None: labels.remove(max_label) return max_label, max_weight labels = [] for label in G.nodes_iter(): G.node[label]['max_weight'] = np.inf if label == start else -1 G.node[label]['predecessor'] = None G.node[label]['bottleneck'] = None labels.append(label) while labels: # Find out which node has maximal weight. current, weight = extract_max(labels) for neighbor in G[current]: m = min(weight, G.edge[current][neighbor][0]['weight']) if G.node[neighbor]['max_weight'] < m: # We can reach the neighbor node from the current node # through a path with a wider bottleneck that the one # we (perhaps) already knew. G.node[neighbor]['max_weight'] = m G.node[neighbor]['predecessor'] = current # Update the location of the bottleneck. if weight < m: G.node[neighbor]['bottleneck'] \ = G.node[current]['bottleneck'] else: G.node[neighbor]['bottleneck'] = (current, neighbor)
def FullConnection(group1: Group, group2: Group, graph: nx.MultiDiGraph): for node in group1.get_nodes(): graph.add_node(node) for node in group2.get_nodes(): graph.add_node(node) for i in group1.get_nodes(): for j in group2.get_nodes(): graph.add_edge(i, j)
def InjectConnection(group1: Group, group2: Group, graph: nx.MultiDiGraph): neuron_group_1 = group1.get_nodes() neuron_group_2 = group2.get_nodes() if len(neuron_group_1) != len(neuron_group_2): raise Exception('Size of group do not match for inject connection') for node in neuron_group_1: graph.add_node(node) for node in neuron_group_2: graph.add_node(node) for i in range(len(neuron_group_1)): graph.add_edge(neuron_group_1[i], neuron_group_2[i])
class AbstractGame: def __init__(self, player1, player2, initial_gamestate): self.game_graph = MultiDiGraph() self.player1 = player1 self.player2 = player2 self.initial_gamestate = self.canonicalize(initial_gamestate) def canonicalize(self, gamestate): raise NotImplementedError def possible_moves(self, gamestate, player): raise NotImplementedError def other_player(self, player): if player == self.player1: return self.player2 elif player == self.player2: return self.player1 else: raise ValueError("%s is neither %s nor %s" % (player, self.player1, self.player2)) def is_winning_position(self, gamestate, player): raise NotImplementedError def is_losing_position(self, gamestate, player): raise NotImplementedError def good_moves(self, gamestate, player, lookahead_depth): if lookahead_depth == 0: yield from self.possible_moves(gamestate, player) else: lookahead_depth -= 1 sign = {self.player1: 1, self.player2: -1} def is_game_over(gamestate): return evaluate_gamestate(gamestate, 0) != 0 def evaluate_gamestate(gamestate, depth): """ Returns 1 if this gamestate favors the first player, -1 if it favors the second player, and 0 if it is neutral. """ if self.is_winning_position(gamestate, self.player1): return 1000 - depth elif self.is_winning_position(gamestate, self.player2): return -1000 + depth else: return 0 def negamax(gamestate, current_depth, current_player): if is_game_over(gamestate) or current_depth > lookahead_depth: return sign[current_player] * evaluate_gamestate(gamestate, current_depth) max_score = -1000 for possible_gamestate in self.possible_moves(gamestate, current_player): max_score = max(max_score, -negamax(possible_gamestate, current_depth + 1, self.other_player(current_player))) return max_score moves_and_lookaheads = {move: -negamax(move, 1, self.other_player(player)) for move in self.possible_moves(gamestate, player)} if len(moves_and_lookaheads) == 0: return best_lookahead = max(moves_and_lookaheads.values()) good_moves = {self.canonicalize(move) for move, lookahead in moves_and_lookaheads.items() if lookahead == best_lookahead} for move in good_moves: yield move def play(self, lookahead=0): new_moves = set() # A set of node, player tuples containing all new moves that can be played in this graph. def play_new_moves(): new_new_moves = set() # The moves that will be new after current new moves have been played. for gamestate, player in new_moves: next_player = self.other_player(player) for move_result in self.good_moves(gamestate, player, lookahead): move_result = self.canonicalize(move_result) if move_result not in self.game_graph: # Add the result to the graph if it's not there. self.game_graph.add_node(move_result, players=set()) self.game_graph.add_edge(gamestate, move_result, key=player) # Add this move to the graph if next_player not in self.game_graph.node[move_result]['players']: self.game_graph.node[move_result]['players'].add(next_player) new_new_moves.add((move_result, next_player)) new_moves.clear() new_moves.update(new_new_moves) new_moves.add((self.initial_gamestate, self.player1)) self.game_graph.add_node(self.initial_gamestate, players=set()) while len(new_moves) != 0: play_new_moves() self.game_graph
def __init__(self): MultiDiGraph.__init__(self) self.elaborated = False
def in_edges(self,node): for _,_,data in MultiDiGraph.in_edges(self,node,data=True):#necessary because for out we can specify data="object", for in we can't yield data["object"]
def overwrite_edge(self,morph,edge2): edge = self.InverseLookUp[morph] MultiDiGraph.remove_edge(self,edge.source,edge.target,key = edge.key) self.InverseLookUp[morph] = edge2
def __init__(self): MultiDiGraph.__init__(self) self.elaborated = False self.abstract_busy_signals = dict()
def simu_abstract(ts, simu_type): """Create a bi/dual-simulation abstraction for a Finite Transition System. @param ts: input finite transition system, the one you want to get its bi/dual-simulation abstraction. @type ts: L{FTS} @param simu_type: string 'bi'/'dual', flag used to switch b.w. bisimulation algorithm and dual-simulation algorithm. @return: the bi/dual simulation, and the corresponding partition. @rtype: L{FTS}, C{dict} References ========== 1. Wagenmaker, A. J.; Ozay, N. "A Bisimulation-like Algorithm for Abstracting Control Systems." 54th Annual Allerton Conference on CCC 2016 """ # create MultiDiGraph instance from the input FTS G = MultiDiGraph(ts) # build coarsest partition S0 = dict() Part = MultiDiGraph() # a graph associated with the new partition n_cells = 0 hash_ap = dict() # map ap to cells in Part for node in G: ap = repr(G.node[node]['ap']) if ap not in S0: S0[ap] = set() hash_ap[ap] = set() Part.add_node(n_cells, ap=ap, cov=S0[ap]) # hash table S0--->G n_cells += 1 S0[ap].add(node) sol = [] for ap in S0: sol.append(S0[ap]) IJ = np.ones([n_cells, n_cells]) transitions = np.zeros([n_cells, n_cells]) while np.sum(IJ) > 0: # get i,j from IJ matrix, i--->j ind = np.nonzero(IJ) i = ind[1][0] j = ind[0][0] IJ[j, i] = 0 si = sol[i] sj = sol[j] pre_j = _pre(G, sj) if si.issubset(pre_j): transitions[j, i] = 1 else: isect = si.intersection(pre_j) if isect == set(): continue else: # check if the isect has existed check_isect = False if simu_type == 'dual': assert len(sol) == n_cells for k in range(n_cells): if sol[k] == isect: check_isect = True break if not check_isect: # assume that i != j sol.append(isect) # update transition matrix transitions = np.pad(transitions, (0, 1), 'constant') transitions[n_cells, :] = 0 transitions[:, n_cells] = transitions[:, i] transitions[j, n_cells] = 1 if simu_type == 'bi': sol[i] = sol[i].difference(sol[n_cells]) transitions[i, :] = 0 if i == j: transitions[j, n_cells] = 0 # update IJ matrix IJ = np.pad(IJ, (0, 1), 'constant', constant_values=1) if simu_type == 'bi': IJ[i, :] = 1 IJ[:, i] = 1 n_cells += 1 else: transitions[j, k] = 1 IJ = ((IJ - transitions) > 0).astype(int) [ts_simu, part_hash] = _output_fts(ts, transitions, sol) return ts_simu, part_hash
def imbalancedCitationsPublicationsExample(): """ Illustrative example of imbalanced citations / publications to verify ShapeSim is working correctly """ graph = MultiDiGraph() authors = ['Alice', 'Bob', 'Carol', 'Dave', 'Ed', 'Frank'] conference = 'KDD' # Citation & publication count configuration citationsPublications = { 'Alice': (100, 10), 'Bob': (80, 10), 'Carol': (100, 100), 'Dave': (50, 10), 'Ed': (10, 10), 'Frank': (1000, 100) } actualCitationsPublications = defaultdict(lambda: (0, 0)) # Helper functions for repeatedly adding papers to the graph addPapersToAuthor = lambda n, author: [addPublicationPaper(author) for _ in itertools.repeat(None, n)] addCitationsToPaper = lambda n, paper, author: [addCitationPaper(paper, author) for _ in itertools.repeat(None, n)] # Helper for getting the next id def __getNextId(): global nextId oldId = nextId nextId += 1 return oldId def addPublicationPaper(author): """ Helper method to add a 'publication' paper, connected to both an author and a conference """ paper = "%s's Paper %d" % (author, (__getNextId())) graph.add_node(paper) graph.add_edges_from([(author, paper), (paper, author), (paper, conference), (conference, paper)]) citationCount, publicationCount = actualCitationsPublications[author] actualCitationsPublications[author] = (citationCount, publicationCount + 1) return paper def addCitationPaper(citedPaper, citedAuthor): """ Helper method to add a 'citation' paper, which is only connected to the conference and the paper it cites """ citingPaper = "Citing Paper %d" % __getNextId() graph.add_node(citingPaper) graph.add_edges_from([(conference, citingPaper), (citingPaper, conference), (citingPaper, citedPaper)]) citationCount, publicationCount = actualCitationsPublications[citedAuthor] actualCitationsPublications[citedAuthor] = (citationCount + 1, publicationCount) return citingPaper allPapers = [] # Construct the graph graph.add_nodes_from(authors + [conference]) for authorName in citationsPublications: citationCount, publicationCount = citationsPublications[authorName] # Add citations & publications to author authorPapers = addPapersToAuthor(publicationCount, authorName) allPapers.extend(authorPapers) citationsPerPaper = citationCount / publicationCount for paper in authorPapers: citingPapers = addCitationsToPaper(citationsPerPaper, paper, authorName) allPapers.extend(citingPapers) nodeIndex = { 'paper': {i: allPapers[i] for i in xrange(0, len(allPapers))}, 'conference': {0: 'KDD'}, 'author': {0: 'Alice', 1: 'Bob', 2: 'Carol', 3: 'Dave', 4: 'Ed', 5: 'Frank'} } # Test PathSim / NeighborSim cpaAdjMatrix, extraData = getMetaPathAdjacencyData(graph, nodeIndex, ['conference', 'paper', 'author']) extraData['fromNodes'] = extraData['toNodes'] extraData['fromNodesIndex'] = extraData['toNodesIndex'] neighborSimMostSimilar, similarityScores = findMostSimilarNodes( cpaAdjMatrix, 'Alice', extraData, method=getNeighborSimScore ) # Test ShapeSim cppaAdjTensor, extraData = getMetaPathAdjacencyTensorData( graph, nodeIndex, ['conference', 'paper', 'paper', 'author'] ) extraData['fromNodes'] = extraData['toNodes'] extraData['fromNodesIndex'] = extraData['toNodesIndex'] shapeSimMostSimilar, similarityScores = findMostSimilarNodes( cppaAdjTensor, 'Alice', extraData, method=getNumpyShapeSimScore, alpha=1.0 ) # Output similarity scores for name, mostSimilar in [('NeighborSim', neighborSimMostSimilar), ('ShapeSim', shapeSimMostSimilar)]: print('\n%s Most Similar to "%s":' % (name, 'Alice')) mostSimilarTable = texttable.Texttable() rows = [['Author', 'Score']] rows += [[name, score] for name, score in mostSimilar] mostSimilarTable.add_rows(rows) print(mostSimilarTable.draw())
def add_edge(self,node1,node2,**kwargs):# inefficient but nobody cares and it's convenient e=Edge(node1,node2,self.keycounter,kwargs) MultiDiGraph.add_edge(self,node1,node2,object = e,key = self.keycounter) self.InverseLookUp[kwargs["morphism"]] = e self.keycounter+=1 return e
def parseArnetminerDataset(): """ Parse the four area dataset, and use only barebones structures to keep everything efficient. Skips papers that: (1) The final parsed network """ inputFile = open(os.path.join(projectRoot, 'data','DBLP-citation-Feb21.txt')) graph = MultiDiGraph() # Sets for authors, papers, conferences, and terms found so far indexToPaperIdMap = {} citationCountMap = {} indexSet = set() beginning = inputFile.tell() print "Parsing nodes for graph..." # Counts for statistics VALID_PAPERS = 1566322 # 99.62% of total papers in DBLP dataset papersProcessed = 0 skippedPaperIndices = set() invalidPaperIndices = set() # Add each paper to graph (adding missing associated terms, authors, and conferences) for title, authors, conference, terms, citationCount, index in __papersFromFile(inputFile, skippedPaperIndices, invalidPaperIndices): # Check that index is unique, and record it assert index not in indexSet indexSet.add(index) # Create unique identifier with paper index & title paperId = '%d----%s' % (index, title) citationCountMap[paperId] = citationCount indexToPaperIdMap[index] = paperId # Add symmetric edges & nodes (if they don't already exist in the network) for author in authors: graph.add_edges_from([(author, paperId), (paperId, author)]) graph.add_edges_from([(conference, paperId), (paperId, conference)]) for term in terms: graph.add_edges_from([(term, paperId), (paperId, term)]) # Output progress papersProcessed += 1 sys.stdout.write("\r Processed %d / %d papers..." % (papersProcessed, VALID_PAPERS)) # Rewind file inputFile.seek(beginning) print "Parsing citations for graph..." # Counts for statistics papersProcessed = 0 successfulCitations = 0 omittedPaperCitations = 0 invalidPaperCitations = 0 invalidCitations = 0 # Add citations to the graph for title, index, citations in __citationsFromFile(inputFile): citingId = '%d----%s' % (index, title) for citationIndex in citations: # Add citation edge if it was found if citationIndex in indexToPaperIdMap: successfulCitations += 1 graph.add_edge(citingId, indexToPaperIdMap[citationIndex]) # Tally missing citation appropriately elif citationIndex in skippedPaperIndices: omittedPaperCitations += 1 elif citationIndex in invalidPaperIndices: invalidPaperCitations += 1 else: print "\nCitation '%d' not found for '%s'" % (citationIndex, title) invalidCitations += 1 # Output progress papersProcessed += 1 sys.stdout.write("\r Processed Citations for %d / %d papers..." % (papersProcessed, VALID_PAPERS)) # Basic statistics about cleanliness of citations totalCitations = invalidCitations + successfulCitations successfulCitationsPercent = 100 * float(successfulCitations) / totalCitations omittedPaperCitationsPercent = 100 * float(omittedPaperCitations) / totalCitations invalidPaperCitationsPercent = 100 * float(invalidPaperCitations) / totalCitations invalidCitationsPercent = 100 * float(invalidCitations) / totalCitations print "\n\nTotal Citations: %d" % totalCitations print " Citations Added (Successful): %d (%2.2f%%)" % (successfulCitations, successfulCitationsPercent) print " Citations Skipped (Skipped Paper): %d (%2.2f%%)" % (omittedPaperCitations, omittedPaperCitationsPercent) print " Citations Skipped (Invalid Paper): %d (%2.2f%%)" % (invalidPaperCitations, invalidPaperCitationsPercent) print " Citations Invalid (Unknown): %d (%2.2f%%)" % (invalidCitations, invalidCitationsPercent) return graph
def out_edges(self,node): for _,_,data in MultiDiGraph.out_edges(self,node,data=True): yield data["object"]
def scale_free_graph(n, G=None, alpha=0.41, beta=0.54, gamma=0.05, delta_in=0.2, delta_out=0, seed=None): """Return a scale free directed graph Parameters ---------- n : integer Number of nodes in graph G : NetworkX graph (optional) Use as starting graph in algorithm alpha : float Probability for adding a new node conecgted to an existing node chosen randomly according to the in-degree distribution. beta : float Probability for adding an edge between two existing nodes. One existing node is chosen randomly according the in-degree distribution and the other chosen randomly according to the out-degree distribution. gamma : float Probability for adding a new node conecgted to an existing node chosen randomly according to the out-degree distribution. delta_in : float Bias for choosing ndoes from in-degree distribution. delta_out : float Bias for choosing ndoes from out-degree distribution. delta_out : float Bias for choosing ndoes from out-degree distribution. seed : integer (optional) Seed for random number generator Examples -------- >>> G=nx.scale_free_graph(100) Notes ----- The sum of alpha, beta, and gamma must be 1. Algorithm from @article{bollobas2003dsf, title={{Directed scale-free graphs}}, author={Bollob{\'a}s, B. and Borgs, C. and Chayes, J. and Riordan, O.}, journal={Proceedings of the fourteenth annual ACM-SIAM symposium on Discrete algorithms}, pages={132--139}, year={2003}, publisher={Society for Industrial and Applied Mathematics Philadelphia, PA, USA} } """ def _choose_node(G,distribution,delta): cumsum=0.0 # normalization psum=float(sum(distribution.values()))+float(delta)*len(distribution) r=random.random() for i in range(0,len(distribution)): cumsum+=(distribution[i]+delta)/psum if r < cumsum: break return i if G is None: # start with 3-cycle G=MultiDiGraph() G.add_edges_from([(0,1),(1,2),(2,0)]) if alpha <= 0: raise ValueError('alpha must be >= 0.') if beta <= 0: raise ValueError('beta must be >= 0.') if gamma <= 0: raise ValueError('beta must be >= 0.') if alpha+beta+gamma !=1.0: raise ValueError('alpha+beta+gamma must equal 1.') G.name="directed_scale_free_graph(%s,alpha=%s,beta=%s,gamma=%s,delta_in=%s,delta_out=%s)"%(n,alpha,beta,gamma,delta_in,delta_out) # seed random number generated (uses None as default) random.seed(seed) while len(G)<n: r = random.random() # random choice in alpha,beta,gamma ranges if r<alpha: # alpha # add new node v v = len(G) # choose w according to in-degree and delta_in w = _choose_node(G, G.in_degree(with_labels=True),delta_in) elif r < alpha+beta: # beta # choose v according to out-degree and delta_out v = _choose_node(G, G.out_degree(with_labels=True),delta_out) # choose w according to in-degree and delta_in w = _choose_node(G, G.in_degree(with_labels=True),delta_in) else: # gamma # choose v according to out-degree and delta_out v = _choose_node(G, G.out_degree(with_labels=True),delta_out) # add new node w w = len(G) G.add_edge(v,w) return G
def __init__(self, player1, player2, initial_gamestate): self.game_graph = MultiDiGraph() self.player1 = player1 self.player2 = player2 self.initial_gamestate = self.canonicalize(initial_gamestate)
class Grafatality(object): def __init__(self, filename='graph.json'): self.filename=filename self.graph = MultiDiGraph() self.typed_nodes = {} self.typed_nodes[None] = [] try: self.load_file(filename) except IOError as e: print 'file "%s" does not exist, creating' % filename def handle(self, line): obj = ujson.loads(line) action = obj['action'] if action == 'add_node': self.load_node(obj) elif action == 'add_edge': self.load_edge(obj) elif action == 'remove_edge': self.load_remove_edge(obj) def load_file(self, filename): f = open(filename) for line in f: self.handle(line) f.close() def listify_typed_node(self, node): if type(node) == list: node = tuple(node) if len(node) == 2: node = tuple(node) return node def load_edge(self, obj): data = obj.get('data', None) key = obj.get('key', None) src_node = obj['src_node'] dst_node = obj['dst_node'] src_node = self.listify_typed_node(src_node) dst_node = self.listify_typed_node(dst_node) if data: self.graph.add_edge(src_node, dst_node, key=key, **data) else: self.graph.add_edge(src_node, dst_node, key=key) def load_remove_edge(self, obj): key = obj.get('key', None) self.graph.remove_edge(obj['src_node'], obj['dst_node'], key=key) def load_node(self, obj): data = obj.get('data', None) node = obj['node'] node_type = None node = self.listify_typed_node(node) if data: self.graph.add_node(node, node_type=node_type, **data) else: self.graph.add_node(node, node_type=node_type) def add_node(self, node, node_type=None, **attr): if node_type: if not node_type in self.typed_nodes: self.typed_nodes[node_type] = [] node = (node, node_type) self.typed_nodes[node_type].append(node) else: self.typed_nodes[None].append(node) data = {"action": "add_node", "node": node} if len(attr): data['data'] = attr self.append_log(data) return self.graph.add_node(node, **attr) def nodes_of_type(self, node_type=None, full=True): if full: return self.typed_nodes[node_type] else: return self.typed_nodes[node_type][0] def add_edge(self, src_node, dst_node, key=None, **attr): data = {"action": "add_edge", "src_node": src_node, "dst_node": dst_node} if len(attr): data['data'] = attr if key: data['key'] = key self.append_log(data) return self.graph.add_edge(src_node, dst_node, key=key, **attr) def remove_edge(self, src_node, dst_node, key): data = {"action": "remove_edge", "src_node": src_node, "dst_node": dst_node, "key": key} self.append_log(data) return self.graph.remove_edge(src_node, dst_node, key) def append_log(self,data): """ This persists the data and while it may be true that the logfile could be kept open indefinitely, for some reason this causes dataloss when running multiprocess files. """ self.log = open(self.filename, 'a') self.log.write(ujson.encode(data)) self.log.write("\n") self.log.close() def shutdown(self): self.log.close()