def sortNodes(path, graph, comms, partition, type_sorting): if path is None and graph is None: return () g = nx.read_gpickle(path) if path is not None else graph degrees_x = [] degrees_y = [] sorted_x = [] sorted_y = [] #in_degree if type_sorting == 0: degrees_x = g.in_degree(comms[0]) #comm X -- to be ordered degrees_y = g.in_degree(comms[1]) #comm Y -- to be ordered sorted_x = sorted(degrees_x ,key=lambda tup: tup[1], reverse=True) sorted_y = sorted(degrees_y ,key=lambda tup: tup[1], reverse=True) #ratio elif type_sorting == 1: for i in comms[0]: degrees_x.append((i,g.in_degree(i)/(g.out_degree(i)+1))) for j in comms[1]: degrees_y.append((j,g.in_degree(j)/(g.out_degree(j)+1))) sorted_x = sorted(degrees_x ,key=lambda tup: tup[1], reverse=True) sorted_y = sorted(degrees_y ,key=lambda tup: tup[1], reverse=True) #betweenness centrality elif type_sorting == 2: centrality_x = nx.betweenness_centrality_subset(g, comms[0], comms[1], normalized=True) centrality_y = nx.betweenness_centrality_subset(g, comms[1], comms[0], normalized=True) sorted_x = sorted([i for i in centrality_x.iteritems() if partition[i[0]] == 0], key=lambda (k,v):(v,k), reverse=False) sorted_y = sorted([i for i in centrality_y.iteritems() if partition[i[0]] == 1], key=lambda (k,v):(v,k), reverse=False) else: for i in comms[0]: degrees_x.append((i,AvgInDegree(i, g))) for j in comms[1]: degrees_y.append((j,AvgInDegree(j, g))) sorted_x = sorted(degrees_x ,key=lambda tup: tup[1], reverse=True) sorted_y = sorted(degrees_y ,key=lambda tup: tup[1], reverse=True) return (sorted_x, sorted_y)
def bet_subset(): graph = { "nodes": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "edges": [[1, 2], [1, 4], [2, 3], [2, 5], [3, 4], [3, 6], [2, 7], [3, 8], [7, 9], [5, 9], [9, 10], [10, 6]], "weights": [3, 4, 5, 6, 7, 8, 9, 10] } # G = nx.Graph() G = nx.DiGraph() G.add_nodes_from(graph['nodes']) G.add_edges_from(graph['edges']) source_nodes = [5, 7] target_nodes = [6] result = nx.betweenness_centrality_subset(G, source_nodes, target_nodes, False) print(result) # print(list(max(result.items(), key=lambda k: k[1]))) # print(result.items()) # print(max(result.items(), key=operator.itemgetter(1))) highest = max(result.values()) print(highest) print([k for k, v in result.items() if v == highest]) result = nx.edge_betweenness_centrality_subset(G, source_nodes, target_nodes, False) print(result) highest = max(result.values()) print(highest) print([k for k, v in result.items() if v == highest])
def dummy_edge_mix_BC_weighted_choice(G,node_to_add,destination_node): #average degree D = list(map(lambda x : x[1], list(G.degree(G.nodes)))) edge_to_add = int(np.mean(D)*0.5) DegreeDict = {}; DummyDegreeDict = {}; #calculate betweenness centrality. Bdict = nx.betweenness_centrality_subset(G,sources=set(G.nodes()),targets=set({destination_node})) B = [] for key in Bdict.keys(): B.append((key,Bdict[key])) DegreeDict[key] = G.degree[key]; DummyDegreeDict[key] = 0; #Weighted k-sampling for dummy in range(0, node_to_add): Bdg = [] for element in B: m = DegreeDict[element[0]] n = DummyDegreeDict[element[0]] Bdg.append((element[0],element[1])) target_nodes1 = random.choices(list(map(lambda x : x[0], Bdg)),weights=list(map(lambda x : x[1], Bdg)),k=edge_to_add) target_nodes2 = random.choices(list(map(lambda x : x[0], Bdg)),weights=list(map(lambda x : 1-x[1], Bdg)),k=edge_to_add) while len(list(set(target_nodes1).intersection(target_nodes2))) > 0: target_nodes1 = random.choices(list(map(lambda x : x[0], Bdg)),weights=list(map(lambda x : x[1], Bdg)),k=edge_to_add) target_nodes2 = random.choices(list(map(lambda x : x[0], Bdg)),weights=list(map(lambda x : 1-x[1], Bdg)),k=edge_to_add) target_nodes = target_nodes1+target_nodes2 #add dummy node G.add_node(G.number_of_nodes()) dummyNode = G.number_of_nodes()-1 #add dummy edge for target in target_nodes: G.add_edge(target,dummyNode); G.add_edge(dummyNode,target); DummyDegreeDict[target]+=1;
def get_path_subgraph(self, sources, targets): """Return an induced subgraph of all paths connecting two sets of nodes. Parameters ---------- sources : list A list of node names to be used as path sources. targets : list A list of node names to be used as path targets. Returns ------- networkx.Graph An induced subgraph that contains all nodes and edges between ``sources`` and ``targets``. """ bc = networkx.betweenness_centrality_subset(self, sources=sources, targets=targets) path_nodes = [ key for key, value in bc.items() if value > 0 or key in sources or key in targets ] return (self.subgraph(path_nodes))
def getNodeSpecBetweenness(): global outfile global data global source global sink global distance global dist_mat weight = [] sources = [] sinks = [] sinks.append(sink) for i in range(0, len(dist_mat[source])): if dist_mat[source, i] <= distance: sources.append(i) print "sources are: ", sources print "sinks are: ", sinks G = nx.from_numpy_matrix(data) for i in xrange(len(data)): for j in xrange(i + 1, len(data)): if (data[i, j] != 0): weight.append(data[i, j]) G = nx.from_numpy_matrix(data) net = nx.betweenness_centrality_subset(G, sources=sources, targets=sinks, normalized=False, weight="weight") f = open(outfile, 'w') with open(outfile, 'w') as f: for key, value in net.items(): f.write('%s %s\n' % (key, value))
def test_K5(self): """Betweenness centrality: K5""" G = networkx.complete_graph(5) b = betweenness_centrality_subset(G, sources=[0], targets=[1, 3], weighted_edges=False) b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0} for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def choose_who_to_vaccinate(graph: networkx.Graph) -> List: people_to_vaccinate = [] # T = networkx.algorithms.maximum_spanning_tree(graph) node2degree = dict(graph.degree) sorted_nodes = sorted(node2degree.items(), key=lambda item: item[1], reverse=True)[:100] l1 = [node[0] for node in sorted_nodes] g2 = graph.subgraph(l1) l2 = networkx.closeness_centrality(g2) sorted_by_closness = sorted(l2.items(), key=lambda item: item[1], reverse=True)[:70] l3 = [i[0] for i in sorted_by_closness] g3 = graph.subgraph(l3) contenders = networkx.betweenness_centrality_subset(g3, l3, l3, normalized=True) sorted_nodes = sorted(contenders.items(), key=lambda item: item[1], reverse=True)[:50] people_to_vaccinate = [i[0] for i in sorted_nodes] patientsRand = [] graph.remove_nodes_from( [n for n in graph if n in set(people_to_vaccinate)]) for i in range(50): patientsRand.append(np.random.choice(graph.nodes())) # ICM(graph, patientsRand, 6) return people_to_vaccinate
def _betmap(G_normalized_weight_sources_tuple): """Pool for multiprocess only accepts functions with one argument. This function uses a tuple as its only argument. We use a named tuple for python 3 compatibility, and then unpack it when we send it to `betweenness_centrality_source` """ return nx.betweenness_centrality_subset(*G_normalized_weight_sources_tuple)
def test_diamond_multi_path(self): """Betweenness Centrality Subset: Diamond Multi Path""" G = nx.Graph() G.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (1, 10), (10, 11), (11, 12), (12, 9), (2, 6), (3, 6), (4, 6), (5, 7), (7, 8), (6, 8), (8, 9)]) b = nx.betweenness_centrality_subset(G, sources=[1], targets=[9], weight=None) expected_b = { 1: 0, 2: 1. / 10, 3: 1. / 10, 4: 1. / 10, 5: 1. / 10, 6: 3. / 10, 7: 1. / 10, 8: 4. / 10, 9: 0, 10: 1. / 10, 11: 1. / 10, 12: 1. / 10, } for n in sorted(G): assert_almost_equal(b[n], expected_b[n])
def test_P5_multiple_target(self): """Betweenness centrality: P5 multiple target""" G = networkx.Graph() G.add_path(range(5)) b_answer = {0: 0, 1: 1, 2: 1, 3: 0.5, 4: 0, 5: 0} b = betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weighted_edges=False) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_K5(self): """Betweenness Centrality Subset: K5""" G = nx.complete_graph(5) b = nx.betweenness_centrality_subset(G, sources=[0], targets=[1, 3], weight=None) b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0} for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_P5_multiple_target(self): """Betweenness Centrality Subset: P5 multiple target""" G = nx.Graph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 1, 2: 1, 3: 0.5, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_box(self): """Betweenness centrality: box""" G = nx.Graph() G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)]) b_answer = {0: 0, 1: 0.25, 2: 0.25, 3: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_box_and_path2(self): """Betweenness centrality: box and path multiple target""" G = nx.Graph() G.add_edges_from([(0, 1), (1, 2), (2, 3), (1, 20), (20, 3), (3, 4)]) b_answer = {0: 0, 1: 1.0, 2: 0.5, 20: 0.5, 3: 0.5, 4: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def most_important_nodes_edges_subset(self, graph, source_nodes, target_nodes, T=0, normalized=False, directed=False): cv=check_graph_validity.Graphs() ret = cv.is_valid_most_important_graph(graph, source_nodes, target_nodes,T) if(not ret[0]): ret.append({}) print (ret) return ret try: # construct networkx graph from given graph if (directed): G=nx.DiGraph() else: G = nx.Graph() G.add_nodes_from(graph['nodes']) G.add_edges_from(graph['edges']) if 'weights' in graph: for i in range(len(graph['edges'])): G[graph['edges'][i][0]][graph['edges'][i][1]]['weight'] = graph['weights'][i] except Exception as e: return ["False", str(e),{}] output={} # clearDict={} result = None if (T == 0): result=nx.betweenness_centrality_subset(G, source_nodes, target_nodes, normalized, weight='weights') #remove nodes that are either in source_node or in target_node # for key,val in result.items(): # if (not(key in source_nodes or key in target_nodes)): # clearDict[key]=val # print(clearDict) elif (T == 1): result =nx.edge_betweenness_centrality_subset(G, source_nodes, target_nodes, normalized, weight='weights') # for key,val in result.items(): # #remove nodes that are either in source_node or in target_node # if(not(key[0] in source_nodes or key[0] in target_nodes or key[1] in source_nodes or key[1] in target_nodes)): # clearDict[key]=val # print(clearDict) # output["betweenness_centrality"] = list(max(clearDict.items(), key=lambda k: k[1])) highest = max(result.values()) nodes_list = [k for k, v in result.items() if v == highest] output["betweenness_centrality"] = [nodes_list,highest] #result print (output) return [True, 'success', output]
def test_P5(self): """Betweenness centrality: P5""" G = nx.Graph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_box(self): """Betweenness Centrality Subset: box""" G = nx.Graph() G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)]) b_answer = {0: 0, 1: 0.25, 2: 0.25, 3: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_box_and_path2(self): """Betweenness Centrality Subset: box and path multiple target""" G = nx.Graph() G.add_edges_from([(0, 1), (1, 2), (2, 3), (1, 20), (20, 3), (3, 4)]) b_answer = {0: 0, 1: 1.0, 2: 0.5, 20: 0.5, 3: 0.5, 4: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_P5_multiple_target(self): """Betweenness Centrality Subset: P5 multiple target""" G = nx.Graph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 1, 2: 1, 3: 0.5, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_P5_directed(self): """Betweenness Centrality Subset: P5 directed""" G = nx.DiGraph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 1, 2: 1, 3: 0, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def Btw(self, U, rho): max = -1 node = 0 btw = nx.betweenness_centrality_subset(self.G, U, self.G.nodes(), False, None) for u in U: if btw[u] > max: max = btw[u] node = u return node
def test_box(self): """Betweenness centrality: box""" G = networkx.Graph() G.add_edge(0, 1) G.add_edge(0, 2) G.add_edge(1, 3) G.add_edge(2, 3) b_answer = {0: 0, 1: 0.25, 2: 0.25, 3: 0} b = betweenness_centrality_subset(G, sources=[0], targets=[3], weighted_edges=False) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_P5_multiple_target(self): """Betweenness centrality: P5 multiple target""" G = networkx.Graph() G.add_path(list(range(5))) b_answer = {0: 0, 1: 1, 2: 1, 3: 0.5, 4: 0, 5: 0} b = betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weighted_edges=False) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_box_and_path(self): """Betweenness Centrality Subset: box and path""" G = nx.Graph() G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 5)]) b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0.5, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
def test_P5(self): """Betweenness centrality: P5""" G = nx.Graph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0, 4: 0, 5: 0} b = betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_P5(self): """Betweenness Centrality Subset: P5""" G = nx.Graph() nx.add_path(G, range(5)) b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
def test_box_and_path(self): """Betweenness centrality: box and path""" G = nx.Graph() G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 5)]) b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0.5, 4: 0, 5: 0} b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3, 4], weight=None) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def test_P5_directed(self): """Betweenness centrality: P5 directed""" G=networkx.DiGraph() G.add_path(list(range(5))) b_answer={0:0,1:1,2:1,3:0,4:0,5:0} b=betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None) for n in sorted(G): assert_almost_equal(b[n],b_answer[n])
def all_tftg_candidates(instance): nx_obj, dict_tf_comm, dict_tg_comm, tf_id, tg_id = instance[0], instance[1], instance[2], instance[3], instance[4] tfs, tgs = dict_tf_comm[tf_id], dict_tg_comm[tg_id] tfs_common, tgs_common = set(tfs).intersection(nx_obj.nodes()), set(tgs).intersection(nx_obj.nodes()) dict_cent_allnodes=nx.betweenness_centrality_subset(nx_obj,tfs_common,tgs_common) set_nodes = set(pd.DataFrame.from_dict(dict_cent_allnodes,orient='index',columns=['paths']).loc[lambda x:x.paths !=0].index.to_list()) nx_obj = nx_obj.subgraph(set_nodes.union(tfs).union(tgs)) ########### dict_res = {} li_li_edges = pd.DataFrame(nx_obj.edges).values.tolist() set_tup_edges = [(i1,i2) for i1,i2 in li_li_edges] dict_res[(tf_id,tg_id)] = set_tup_edges return dict_res
def function(sample): pnm_params = { 'data_path': r"Z:\Robert_TOMCAT_3_netcdf4_archives\for_PNM", # 'data_path': r"A:\Robert_TOMCAT_3_netcdf4_archives\processed_1200_dry_seg_aniso_sep", 'sample': sample # 'sample': 'T3_100_7_III', # 'sample': 'T3_025_3_III', # 'sample': 'T3_300_8_III', } pnm = PNM(**pnm_params) graph = pnm.graph sourcesraw = np.unique(pnm.data['label_matrix'][:, :, 0])[1:] targetsraw = np.unique(pnm.data['label_matrix'][:, :, -1])[1:] sources = [] targets = [] for k in sourcesraw: if k in graph.nodes(): sources.append(k) for k in targetsraw: if k in graph.nodes(): targets.append(k) centrality = np.array(list(nx.betweenness_centrality(graph).values())) centrality2 = np.array( list( nx.betweenness_centrality_subset(graph, sources, targets, normalized=True).values())) centrality5 = np.array( list( nx.betweenness_centrality_source(graph, sources=sources).values())) waiting_times = np.zeros(len(centrality)) vx = pnm.data.attrs['voxel'] V = pnm.data['volume'].sum(dim='label') V0 = 0.95 * V.max() ref = V[V < V0].argmax() meanflux = (V0 * vx**3 / pnm.data['time'][ref]) # meanflux = V[-1]*vx**3/pnm.data['time'][-1] meanflux = meanflux.data i = 0 for node in graph.nodes(): wt = 0 nb = list(nx.neighbors(graph, node)) if len(nb) > 0: t0 = pnm.data['sig_fit_data'].sel(label=node, sig_fit_var='t0 [s]') t0nb = pnm.data['sig_fit_data'].sel(label=nb, sig_fit_var='t0 [s]') upstream_nb = np.where(t0nb < t0) if len(upstream_nb[0]) > 0: wt = t0 - t0nb[upstream_nb].max() waiting_times[i] = wt i += 1 return centrality, waiting_times, meanflux, centrality5, centrality2, sample
def all_tftg_candidates(nx_obj, tfs, tgs): tfs_common, tgs_common = set(tfs).intersection(nx_obj.nodes()), set(tgs).intersection(nx_obj.nodes()) dict_cent_allnodes=nx.betweenness_centrality_subset(nx_obj,tfs_common,tgs_common) set_nodes = set(pd.DataFrame.from_dict(dict_cent_allnodes,orient='index',columns=['paths']).loc[lambda x:x.paths !=0].index.to_list()) ########## nx_obj = nx_obj.subgraph(set_nodes.union(tfs).union(tgs)) ########### dict_tftgs = nx.to_dict_of_lists(nx_obj) dict_tftgs_filtered ={} for key in dict_tftgs: if len(dict_tftgs[key])==0: continue else: dict_tftgs_filtered[key] = dict_tftgs[key] return nx_obj, dict_tftgs_filtered
def test_box_and_path2(self): """Betweenness centrality: box and path multiple target""" G = networkx.Graph() G.add_edge(0, 1) G.add_edge(1, 2) G.add_edge(2, 3) G.add_edge(1, 20) G.add_edge(20, 3) G.add_edge(3, 4) b_answer = {0: 0, 1: 1.0, 2: 0.5, 20: 0.5, 3: 0.5, 4: 0} b = betweenness_centrality_subset(G, sources=[0], targets=[3, 4]) for n in sorted(G): assert_almost_equal(b[n], b_answer[n])
def prune(self, remove_singletons=True, trim_leaves=False, remove_placeholders=False, sources=None, targets=None): """Remove specific parts of the graph. Parameters ---------- remove_singletons : bool, optional Should singletons be removed? [default: True] trim_leaves : bool, optional Iteratively remove all nodes with degree one, effectively keeping only nodes that are in cycles? [default: False] remove_placeholders : bool, optional Should placeholder nodes be removed? [default: False] sources, targets : list, optional Lists of node names. If provided, nodes that are not on any path between ``sources`` and ``targets`` will be removed. [default: None] """ if remove_placeholders == True: self.remove_nodes_from(self.placeholders) if sources is not None and targets is not None: bc = networkx.betweenness_centrality_subset(self, sources=sources, targets=targets) remove_bc = [ key for key, value in bc.items() if value == 0 and not key in sources and not key in targets ] self.remove_nodes_from(remove_bc) if trim_leaves: degrees = dict(self.degree()) while 1 in degrees.values(): for key, value in degrees.items(): if (value == 1): self.remove_node(key) degrees = dict(self.degree()) if remove_singletons: degrees = dict(self.degree()) for key, value in degrees.items(): if (value == 0): self.remove_node(key)
def test_box_and_path(self): """Betweenness centrality: box and path""" G=networkx.Graph() G.add_edge(0,1) G.add_edge(0,2) G.add_edge(1,3) G.add_edge(2,3) G.add_edge(3,4) G.add_edge(4,5) b_answer={0:0,1:0.5,2:0.5,3:0.5,4:0,5:0} b=betweenness_centrality_subset(G, sources=[0], targets=[3,4], weight=None) for n in sorted(G): assert_almost_equal(b[n],b_answer[n])
def getNodeSpecBetweenness(): global outfile global data global sources global sinks weight = [] G=nx.from_numpy_matrix(data) for i in xrange(len(data)): for j in xrange(i+1,len(data)): if(data[i,j] != 0): weight.append(data[i,j]) G=nx.from_numpy_matrix(data) net=nx.betweenness_centrality_subset(G,sources=sources,targets=sinks,normalized=False,weight="weight") f=open(outfile, 'w') with open(outfile, 'w') as f: for key, value in net.items(): f.write('%s %s\n' % (key, value))
def test_diamond_multi_path(self): """Betweenness Centrality Subset: Diamond Multi Path""" G = nx.Graph() G.add_edges_from([ (1,2), (1,3), (1,4), (1,5), (1,10), (10,11), (11,12), (12,9), (2,6), (3,6), (4,6), (5,7), (7,8), (6,8), (8,9) ]) b = nx.betweenness_centrality_subset( G, sources=[1], targets=[9], weight=None ) expected_b = { 1: 0, 2: 1./10, 3: 1./10, 4: 1./10, 5: 1./10, 6: 3./10, 7:1./10, 8:4./10, 9:0, 10:1./10, 11:1./10, 12:1./10, } for n in sorted(G): assert_almost_equal(b[n], expected_b[n])
def nx_betweenness_centrality( graph: NetworkXGraph, nodes: mg.Optional[PythonNodeSet], normalize: bool, # include_endpoints: bool, ) -> PythonNodeMap: if nodes is None: sources = targets = graph.value.nodes else: sources = targets = nodes.value node_to_score_map = nx.betweenness_centrality_subset( graph.value, sources=sources, targets=targets, normalized=normalize, weight=graph.edge_weight_label, # endpoints=include_endpoints, ) return PythonNodeMap(node_to_score_map, )
def betweeness_centrality_subset(): nodes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] edges_sources = [[1, 2], [1, 3], [3, 4], [4, 5], [5, 6], [6, 7]] edges_targets = [[8, 9], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [10, 13], [9, 15], [8, 14]] edges_interconnections = [[4, 8], [6, 10], [7, 14] ] # Connection between source and target nodes edges = [] G = nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(edges_sources) G.add_edges_from(edges_targets) G.add_edges_from(edges_interconnections) # print(G.edges) result = nx.betweenness_centrality_subset(G, [1, 2, 3, 4, 5], [1, 13, 14, 15]) print(result) result = nx.betweenness_centrality_subset(G, [ 1, 2, 3, ], [13, 14, 15]) print(result) result = nx.edge_betweenness_centrality_subset(G, [1, 2, 3, 4, 5], [12, 13, 14, 15]) print(result) print('--------------------------') nodes = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15] edges_sources = [[1, 2], [1, 3], [3, 4], [4, 6], [6, 7]] # 5 removed here edges_targets = [[8, 9], [10, 11], [11, 13], [13, 14], [14, 15], [10, 13], [9, 15], [8, 14]] # 12 removed here edges_interconnections = [[4, 8], [6, 10], [7, 14] ] # Connection between source and target nodes edges = [] G = nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(edges_sources) G.add_edges_from(edges_targets) G.add_edges_from(edges_interconnections) # print(G.edges) result = nx.betweenness_centrality_subset(G, [1, 2, 3, 4, 5], [13, 14, 15]) print(result) result = nx.betweenness_centrality_subset(G, [1, 2, 3, 4], [13, 14, 15]) print(result) result = nx.edge_betweenness_centrality_subset(G, [1, 2, 3, 4, 5], [12, 13, 14, 15]) print(result) print('-------------------------') print(G.edges) G[1][2]['weight'] = 0.8 G[1][2]['weightre'] = 0.83 print(G[1][2])