def base_experiment_compare(graph, P, W): print('#' * 10) for i in range(10): t = ComputeCoverTime(graph) print('Number of Options', i) print('CoverTime ', t) lb = nx.algebraic_connectivity(nx.to_networkx_graph(graph)) print('lambda ', lb) print() avg_dist = average_shortest_distance(graph, W) graph_alg, options_alg = AverageShortestOptions(graph, P, 1) lb_alg = nx.algebraic_connectivity(nx.to_networkx_graph(graph_alg)) avg_dist_alg = average_shortest_distance(graph_alg, W) graph_brute, options_brute = BruteOptions(graph, P, 1) lb_brute = nx.algebraic_connectivity(nx.to_networkx_graph(graph_brute)) avg_dist_brute = average_shortest_distance(graph_brute, W) print('avg_shortest_dist: ', "alg:", avg_dist_alg, "brute:", avg_dist_brute) #print('lambda: ',"alg:", lb_alg,"brute:",lb_brute) print(options_alg, options_brute) graph = graph_alg
def compare_to_brute_exp(graph, P, W, num_options, show_graphs=False): avg_dist = average_shortest_distance(graph, W) ASPDM_list = [avg_dist] Brute_list = [avg_dist] graph_alg_orig = graph.copy() graph_brute = graph.copy() for i in range(num_options): print(i, "/", num_options, "\t\t", end="\r") graph_alg, options_alg = AverageShortestOptions(graph_alg_orig, P, i) avg_dist_alg = average_shortest_distance(graph_alg, W) graph_brute, options_brute = BruteOptions(graph_brute, P, 1) avg_dist_brute = average_shortest_distance(graph_brute, W) if show_graphs: fig, (ax1, ax2, ax3) = plt.subplots(1, 3) nx.draw(nx.to_networkx_graph(graph), ax=ax1) nx.draw(nx.to_networkx_graph(graph_alg), ax=ax2) nx.draw(nx.to_networkx_graph(graph_brute), ax=ax3) plt.show() if ASPDM_list[-1] == avg_dist_alg and Brute_list[-1] == avg_dist_brute: ASPDM_list.append(avg_dist_alg) Brute_list.append(avg_dist_brute) break ASPDM_list.append(avg_dist_alg) Brute_list.append(avg_dist_brute) return ASPDM_list, Brute_list, graph_alg, graph_brute
def plot_tree(self, weights=None, title=None): import networkx as nx import matplotlib as mpl import matplotlib.pyplot as plt plt.figure() if weights is None: G = nx.to_networkx_graph(self.ssm) nx.draw_networkx(G) else: nnodes = self.ssm.shape[0] w_a = np.zeros(nnodes) for idx in weights['RECIDX'].unique(): ct = weights[weights.RECIDX == idx].shape[0] try: w_a[self.idx_d[idx]] = float(ct) / float(nnodes) except Exception as e: import pdb pdb.Pdb().set_trace() G = nx.to_networkx_graph(self.ssm) nx.draw_networkx(G, node_color=w_a, cmap=plt.get_cmap('plasma'), vmin=0.0, vmax=1.0) if title is not None: plt.title(title) plt.show()
def load_data(prefix='./example_data/', file_name='YelpChi.mat', relations=['net_rur'], normalize=True, load_walks=False, train_size=0.8): adjs, feats, truelabels, train_idx, test_idx = load_mat_full( prefix, file_name, relations, train_size) gs = [nx.to_networkx_graph(adj) for adj in adjs] id_map = {int(i): i for i in range(len(truelabels))} class_map = {int(i): truelabels[i] for i in range(len(truelabels))} walks = [] adj_main = np.sum( adjs ) # change the index to specify which adj matrix to use for aggregation G = nx.to_networkx_graph(adj_main) gs = [graph_process(g, feats, truelabels, test_idx) for g in gs] G = graph_process(G, feats, truelabels, test_idx) if normalize and not feats is None: from sklearn.preprocessing import StandardScaler train_ids = np.array([id_map[n] for n in G.nodes()]) train_feats = feats[train_ids] scaler = StandardScaler() scaler.fit(train_feats) feats = scaler.transform(feats) if load_walks: with open(prefix + "-walks.txt") as fp: for line in fp: walks.append(map(conversion, line.split())) return G, feats, id_map, walks, class_map, gs
def test_graph_india(): A1 = np.loadtxt("adj_allVillageRelationships_vilno_1.csv", delimiter=",") A2 = np.loadtxt("adj_allVillageRelationships_vilno_2.csv", delimiter=",") G1 = nx.to_networkx_graph(A1) G2 = nx.to_networkx_graph(A2) basic_net_stats(G1) basic_net_stats(G2) plot_degree_distribution(G1) plot_degree_distribution(G2) plt.show()
def betweenness_central(net_mat, normalized=True): net_mat = np.matrix(net_mat) graph = nx.to_networkx_graph(net_mat) bc = nx.betweenness_centrality( graph, normalized=normalized) # dictionary where key = node bc = np.array([bc[i] for i in range(len(bc))]) return bc
def identity_conversion(self, G, A, create_using): GG = nx.from_numpy_matrix(A, create_using=create_using) self.assert_equal(G, GG) GW = nx.to_networkx_graph(A, create_using=create_using) self.assert_equal(G, GW) GI = create_using.__class__(A) self.assert_equal(G, GI)
def test_add4_random(self): cell_complex = models.CellComplex2D(0, 10, 10) np.random.seed(3) planes = simulator.random_planes(num_planes=4, max_distance=9, c=0) for p in planes: cell_complex.insert_partition(p) H = cell_complex.cell_graph() G = nx.to_networkx_graph({ 0: [1, 2, 4], 1: [0, 6], 2: [0, 3, 6], 3: [2, 4, 7, 8], 4: [0, 3, 5], 5: [4, 8], 6: [1, 2, 7], 7: [6, 3], 8: [3, 5] }) self.assertTrue(nx.is_isomorphic(G, H)) cell_complex.draw(scene_graph=H)
def convert(A): # Create networkx graph from numpy adjacency matrix. g = nx.to_networkx_graph(A) return g
def test_non_multigraph_input(self, dod, mgi, edges): G = self.Graph(dod, multigraph_input=mgi) assert list(G.edges(keys=True, data=True)) == edges G = nx.to_networkx_graph(dod, create_using=self.Graph, multigraph_input=mgi) assert list(G.edges(keys=True, data=True)) == edges
def draw_graph(G_arr, row, col, pos, fname='Results/figures'): '''draw a numpy of graphs [num_graph,num_nodes,num_nodes], with coordinates''' plt.switch_backend('agg') for j in range(0, G_arr.shape[0], row + col): plt.figure() right = min(j + row + col, G_arr.shape[0]) for i, id in enumerate(range(j, right)): plt.subplot(row, col, i + 1) plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) plt.axis("off") G = nx.to_networkx_graph(data=G_arr[id]) nx.draw_networkx_nodes(G, pos[id], node_size=1.5, node_color='#336699', alpha=1, linewidths=0.2, font_size=1.5) nx.draw_networkx_edges(G, pos[id], alpha=0.6, width=0.2) # plt.axis('off') # plt.title('Complete Graph of Odd-degree Nodes') # plt.show() plt.tight_layout() plt.savefig(fname + str(j) + '.png', dpi=800) plt.close()
def draw(unet, partition=None, ax=None, cmap="Spectral"): if ax is None: ax = plt.gca() netx = nx.to_networkx_graph(unet.edge_dict) if partition is not None: col = np.linspace(0, 1, num=unet.number_of_communities) node_color = np.array([ col[i] for node in range(unet.number_of_nodes) for i, comm in enumerate(partition) if node in comm ]) else: node_color = "#1f78b4" nx.draw(netx, ax=ax, width=0.1, node_size=20, node_color=node_color, cmap=cmap)
def identity_conversion(self, G, A, create_using): GG = nx.from_scipy_sparse_matrix(A, create_using=create_using) self.assert_equal(G, GG) GW = nx.to_networkx_graph(A, create_using=create_using) self.assert_equal(G, GW) GI = create_using.__class__(A) self.assert_equal(G, GI) ACSR = A.tocsr() GI = create_using.__class__(ACSR) self.assert_equal(G, GI) ACOO = A.tocoo() GI = create_using.__class__(ACOO) self.assert_equal(G, GI) ACSC = A.tocsc() GI = create_using.__class__(ACSC) self.assert_equal(G, GI) AD = A.todense() GI = create_using.__class__(AD) self.assert_equal(G, GI) AA = A.toarray() GI = create_using.__class__(AA) self.assert_equal(G, GI)
def t_delta_partition(t_delta_matrix,sm,verbose=False): import community; g=nx.to_networkx_graph(t_delta_matrix+t_delta_matrix.T - np.diag(t_delta_matrix.diagonal()) ,create_using=nx.Graph()); if verbose==True: plt.figure, plt.pcolor(np.array(nx.to_numpy_matrix(g))), plt.colorbar(); plt.show() return community.best_partition(g);
def get_test_edges(adj): adj = adj - sp.dia_matrix((adj.diagonal()[np.newaxis, :], [0]), shape=adj.shape) adj.eliminate_zeros() edges_all = sparse_to_tuple(adj)[0].tolist() edge_count = len(edges_all) / 2.0 num_test = int(np.floor(edge_count / 10.)) num_val = int(np.floor(edge_count / 20.)) G = nx.to_networkx_graph(adj) test_edges = pick_edges(G, num_test) test_edges_false = pick_false_edges(G, num_test) G.remove_edges_from(test_edges) val_edges = pick_edges(G, num_val) val_edges_false = pick_false_edges(G, num_val) G.remove_edges_from(val_edges) adj_train = nx.to_scipy_sparse_matrix(G) train_edges = sparse_to_tuple(adj_train)[0].tolist() def ismember(a, b): seta = set([tuple(x) for x in a]) setb = set([tuple(x) for x in b]) return len(seta & setb) > 0 assert not ismember(test_edges_false, edges_all) assert not ismember(val_edges_false, val_edges + train_edges) assert not ismember(val_edges, train_edges) assert not ismember(test_edges, train_edges) assert not ismember(val_edges, test_edges) assert ismember(val_edges, val_edges) return adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false
def degree_dist(g): if isinstance(g,np.ndarray): g=nx.to_networkx_graph(g) # if matrix is passed, convert to networkx d=dict(g.degree()).values() vals=list(set(d)) counts=[d.count(i) for i in vals] return list(zip(vals, counts))
def createMST(self): ''' Using the networkX library create a MST from the adjacency Matrix, this was unused after initial investigation ''' graph = nx.to_networkx_graph(self.adjacencyMatrix) # initialise graph self.mst = nx.minimum_spanning_tree(graph)
def _randomize(net, density=None): n_nodes = len(net.nodes()) density = density or 1.0 / n_nodes max_attempts = 50 for attempt in xrange(max_attempts): # create an random adjacency matrix with given density adjmat = N.random.rand(n_nodes, n_nodes) adjmat[adjmat >= (1.0 - density)] = 1 adjmat[adjmat < 1] = 0 # add required edges for src, dest in required_edges: adjmat[src][dest] = 1 # remove prohibited edges for src, dest in prohibited_edges: adjmat[src][dest] = 0 # remove self-loop edges (those along the diagonal) adjmat = N.invert(N.identity(n_nodes).astype(bool)) * adjmat # set the adjaceny matrix and check for acyclicity net = nx.to_networkx_graph(adjmat, create_using=Network()) if net.is_acyclic(): return net # got here without finding a single acyclic network. # so try with a less dense network return _randomize(density / 2)
def average_shortest_distance(A, W): D_dict = nx.all_pairs_shortest_path_length(nx.to_networkx_graph(A)) sum = 0 for source in D_dict: for target in range(len(A)): sum += source[1][target] * W[source[0], target] return sum / np.sum(W)
def get_qoe(source, target, network, algorithm): G = nx.to_networkx_graph( network, create_using=None, multigraph_input=False) return { "dijkstra": nx.dijkstra_path_length(G, source, target), "bellman_ford": nx.bellman_ford_path_length(G, source, target) }[algorithm]
def _randomize(net, density=None): n_nodes = len(net.nodes()) density = density or 1.0/n_nodes max_attempts = 50 for attempt in xrange(max_attempts): # create an random adjacency matrix with given density adjmat = N.random.rand(n_nodes, n_nodes) adjmat[adjmat >= (1.0-density)] = 1 adjmat[adjmat < 1] = 0 # add required edges for src,dest in required_edges: adjmat[src][dest] = 1 # remove prohibited edges for src,dest in prohibited_edges: adjmat[src][dest] = 0 # remove self-loop edges (those along the diagonal) adjmat = N.invert(N.identity(n_nodes).astype(bool))*adjmat # set the adjaceny matrix and check for acyclicity net = nx.to_networkx_graph(adjmat, create_using=Network()) if net.is_acyclic(): return net # got here without finding a single acyclic network. # so try with a less dense network return _randomize(density/2)
def degree_dist(g): if isinstance(g, np.ndarray): g = nx.to_networkx_graph(g) # if matrix is passed, convert to networkx d = g.degree().values() vals = list(set(d)) counts = [d.count(i) for i in vals] return zip(vals, counts)
def test_exceptions(self): # _prep_create_using G = {"a": "a"} H = nx.to_networkx_graph(G) assert_graphs_equal(H, nx.Graph([('a', 'a')])) assert_raises(TypeError, to_networkx_graph, G, create_using=0.0) # NX graph class G(object): adj = None assert_raises(nx.NetworkXError, to_networkx_graph, G) # pygraphviz agraph class G(object): is_strict = None assert_raises(nx.NetworkXError, to_networkx_graph, G) # Dict of [dicts, lists] G = {"a": 0} assert_raises(TypeError, to_networkx_graph, G) # list or generator of edges class G(object): next = None assert_raises(nx.NetworkXError, to_networkx_graph, G) # no match assert_raises(nx.NetworkXError, to_networkx_graph, "a")
def identity_conversion(self, G, A, create_using): GG = nx.from_scipy_sparse_matrix(A, create_using=create_using) assert nx.is_isomorphic(G, GG) GW = nx.to_networkx_graph(A, create_using=create_using) assert nx.is_isomorphic(G, GW) GI = nx.empty_graph(0, create_using).__class__(A) assert nx.is_isomorphic(G, GI) ACSR = A.tocsr() GI = nx.empty_graph(0, create_using).__class__(ACSR) assert nx.is_isomorphic(G, GI) ACOO = A.tocoo() GI = nx.empty_graph(0, create_using).__class__(ACOO) assert nx.is_isomorphic(G, GI) ACSC = A.tocsc() GI = nx.empty_graph(0, create_using).__class__(ACSC) assert nx.is_isomorphic(G, GI) AD = A.todense() GI = nx.empty_graph(0, create_using).__class__(AD) assert nx.is_isomorphic(G, GI) AA = A.toarray() GI = nx.empty_graph(0, create_using).__class__(AA) assert nx.is_isomorphic(G, GI)
def to_normalize(J, netx=False): if netx: J = nx.to_numpy_array(J) max_J = np.max(J) min_J = np.min(J) if max_J >= 0 and max_J <= 1 and min_J >= 0 and min_J <= 1: if netx: return nx.to_networkx_graph(J) else: return J else: if netx: return nx.to_networkx_graph(J / max_J) else: return J / max_J
def get_qoe(source, target, network, algorithm): G = nx.to_networkx_graph(network, create_using=None, multigraph_input=False) try: return nx.bellman_ford_path_length(G, source, target) except: return -1
def compare_to_brute_multiple_exp(N, num_options, num_trials, show_graphs=False): P = np.array( [np.random.permutation(np.arange(N))[:2] for i in range(N * N)]) # P = [] # [[P.append((i,j)) for i in range(N)] for j in range(N)] # P = np.array(P) W = get_weight_matrix(N, P) A = [] B = [] for i in range(num_trials): print("trial ", (i + 1), " of ", num_trials) #Gnx = nx.barabasi_albert_graph(n=N,m=1) Gnx = nx.fast_gnp_random_graph(n=N, p=.2) graph = nx.to_numpy_matrix(Gnx).astype(dtype='int') ASPDM_list, Brute_list, graph_alg, graph_brute = compare_to_brute_exp( graph, P, W, num_options) A.append(ASPDM_list) B.append(Brute_list) if show_graphs: fig, (ax1, ax2, ax3) = plt.subplots(1, 3) nx.draw(nx.to_networkx_graph(graph), ax=ax1) nx.draw(nx.to_networkx_graph(graph_alg), ax=ax2) nx.draw(nx.to_networkx_graph(graph_brute), ax=ax3) plt.show() # A = np.array(A) # B = np.array(B) # X = np.arange(A.shape[1]) # plt.fill_between(X,np.max(A,axis=0),np.min(A,axis=0),alpha=.5) # plt.fill_between(X,np.max(B,axis=0),np.min(B,axis=0),alpha=.5) fig = plt.figure() [plt.plot(data, color='orange') for data in A] [plt.plot(data, color='blue') for data in B] plt.xlabel('number of options') plt.ylabel('average shortest distance') plt.title('ASPDM-orange Brute-Blue') fig.show() plt.show()
def geoGraph(n, d, epsilon): """ Create a geometric graph: n points in d-dimensional space, nodes are connected if closer than epsilon""" points = np.random.random((n,d)) pl2 = np.array([np.linalg.norm(points, axis=1)])**2 eucDist = (pl2.T @ np.ones((1,n))) + (np.ones((n,1)) @ pl2) - (2 * points @ points.T) A = ((eucDist + np.eye(n)) < epsilon).astype(int) return nx.to_networkx_graph(A)
def draw_sentence_graph(m, sentences=None): g = nx.to_networkx_graph(m) weights = [g[u][v]['weight'] * 3 for u, v in g.edges()] if sentences is not None: labels = {i: s for i, s in zip(g.nodes(), sentences)} else: labels = {i: i + 1 for i in g.nodes()} return nx.draw(g, labels=labels, with_labels=True, width=weights)
def identity_conversion(self, G, A, create_using): assert(A.sum() > 0) GG = nx.from_numpy_array(A, create_using=create_using) self.assert_equal(G, GG) GW = nx.to_networkx_graph(A, create_using=create_using) self.assert_equal(G, GW) GI = nx.empty_graph(0, create_using).__class__(A) self.assert_equal(G, GI)
def identity_conversion(self, G, A, create_using): assert (A.sum() > 0) GG = nx.from_numpy_array(A, create_using=create_using) self.assert_equal(G, GG) GW = nx.to_networkx_graph(A, create_using=create_using) self.assert_equal(G, GW) GI = nx.empty_graph(0, create_using).__class__(A) self.assert_equal(G, GI)
def get_default_graph(get_edges): num_nodes = 100 x = [random.random() for i in range(num_nodes)] y = [random.random() for i in range(num_nodes)] x = np.array(x) y = np.array(y) # Make a graph with num_nodes nodes and zero edges # Plot the nodes using x,y as the node positions graph = nx.Graph() for i in range(num_nodes): node_name = str(i) graph.add_node(node_name) # Now add some edges - use Delaunay tesselation # to produce a planar graph. Delaunay tesselation covers the # convex hull of a set of points with triangular simplices (in 2D) points = np.column_stack((x, y)) dl = Delaunay(points) tri = dl.simplices if get_edges: edges = np.zeros((2, 6 * len(tri)), dtype=int) data = np.ones(6 * len(points)) j = 0 for i in range(len(tri)): edges[0][j] = tri[i][0] edges[1][j] = tri[i][1] j += 1 edges[0][j] = tri[i][1] edges[1][j] = tri[i][0] j += 1 edges[0][j] = tri[i][0] edges[1][j] = tri[i][2] j += 1 edges[0][j] = tri[i][2] edges[1][j] = tri[i][0] j += 1 edges[0][j] = tri[i][1] edges[1][j] = tri[i][2] j += 1 edges[0][j] = tri[i][2] edges[1][j] = tri[i][1] j += 1 data = np.ones(6 * len(tri)) adjacency_matrix = sp.sparse.csc_matrix( (data, (edges[0, :], edges[1, :]))) for i in range(adjacency_matrix.nnz): adjacency_matrix.data[i] = 1.0 graph = nx.to_networkx_graph(adjacency_matrix) return graph
def generate_microstate_hb_network(self, conformer_ids=None, labels=None): """ Parameters ---------- conformer_ids : TYPE Description """ if conformer_ids is None: G = nx.to_networkx_graph(self.hb_matrix) return G else: G = nx.to_networkx_graph(self.hb_matrix[conformer_ids, :][:, conformer_ids]) if labels is None: nx.relabel_nodes(G, dict(list(zip(G.nodes(), conformer_ids))), copy=False) else: assert len(labels) == len(conformer_ids), "Please make sure number of nodes and labels are equal." nx.relabel_nodes(G, dict(list(zip(G.nodes(), labels))), copy=False) return G
def geoGraph(n, d, epsilon): """ Create a geometric graph: n points in d-dimensional space, nodes are connected if closer than epsilon""" points = np.random.random((n, d)) pl2 = np.array([np.linalg.norm(points, axis=1)])**2 eucDist = (pl2.T @ np.ones((1, n))) + (np.ones( (n, 1)) @ pl2) - (2 * points @ points.T) A = ((eucDist + np.eye(n)) < epsilon).astype(int) return nx.to_networkx_graph(A)
def display_graphic_graph(adjacency_list: Dict[str, List[str]], sequence: List[int]): for vertex in adjacency_list: print(vertex, " -> ", adjacency_list[vertex]) G = nx.to_networkx_graph(adjacency_list) nx.draw(G, with_labels=True, font_weight='bold') plt.show() plt.title(f'{sequence}')
def StickyGraph(n, deg): """input: n, degree sequence.""" assert(n == len(deg)) deg = np.array(deg) / np.sqrt(np.sum(deg)) A = np.zeros((n,n),dtype=int) for i,j in itertools.combinations(range(n),2): if (i != j) and (np.random.random() < deg[i]*deg[j]): A[i,j] = 1 A[j,i] = 1 return nx.to_networkx_graph(A)
def geoGraphP(n, d, p): """ Create a geometric graph: n points in d-dimensional space, fraction p node pairs are connected""" points = np.random.random((n,d)) pl2 = np.array([np.linalg.norm(points, axis=1)])**2 eucDist = (pl2.T @ np.ones((1,n))) + (np.ones((n,1)) @ pl2) - (2 * points @ points.T) dists = np.sort(np.ravel(eucDist)) epsilon = dists[n + np.floor((n**2-n) * p).astype(int)] A = ((eucDist + dists[-1] * np.eye(n)) < epsilon).astype(int) return nx.to_networkx_graph(A)
def hits_algo(adj_matrix,hub_score): # INPUT: Initial hub_score, authorities score and adjacency matrix. # OUTPUT: Converged print "Running HITS algorithm..." graph = nx.to_networkx_graph(adj_matrix) # print graph nstart = dict([(i, hub_score[i]) for i in xrange(len(hub_score))]) # print nstart # return nx.hits(graph) return nx.hits(graph,nstart=nstart)
def convertIDToGraph(id,motifSize): binary = bin(id); adj = np.zeros(motifSize*motifSize) for x in xrange(motifSize*motifSize): if binary[-x] == 'b': break adj[-x] = int(binary[-x]) adj.shape = (motifSize,motifSize) graph = nx.to_networkx_graph(adj,create_using=nx.DiGraph()) nx.draw_circular(graph) #plt.savefig("result/id-"+str(id)+"size-"+str(motifSize)) plt.show()
def __init__(self, term_term_matrix, threshold=10): self.graph = {} for term_a in term_term_matrix: for term_b in term_term_matrix: if term_term_matrix[term_a][term_b] >= threshold: tmp = self.graph.get(term_a, []) tmp.append(term_b) self.graph[term_a] = tmp if term_a not in self.graph: self.graph[term_a] = [] self.nx_graph = nx.to_networkx_graph(self.graph)
def convert_matrix_to_digraph(matrix): """ Converts a python's matrix into a networkx's digraph. Args: matrix : MATRIX[[INT, INT, ...], [INT, INT, ...], ...] This matrix is the representation of the genes Returns: nx.DiGraph() The converted matrix into a digraph """ genes = np.asmatrix(matrix) di_graph = nx.to_networkx_graph(genes, create_using=nx.DiGraph()) return di_graph
def test_graph_generator(): A1 = np.loadtxt("adj_allVillageRelationships_vilno_1.csv", delimiter=",") A2 = np.loadtxt("adj_allVillageRelationships_vilno_2.csv", delimiter=",") G1 = nx.to_networkx_graph(A1) G2 = nx.to_networkx_graph(A2) gen1 = nx.connected_component_subgraphs(G1) G1_LCC = max(gen1, key=len) print(len(G1_LCC)) print(G1.number_of_nodes()) print(G1_LCC.number_of_nodes()) print(G1_LCC.number_of_nodes()/G1.number_of_nodes()) # g1 = gen1.__next__() # print(g1) # basic_net_stats(G1) # basic_net_stats(g1) gen2 = nx.connected_component_subgraphs(G2) G2_LCC = max(gen2, key=len) print(len(G2_LCC)) print(G2.number_of_nodes()) print(G2_LCC.number_of_nodes()) print(G2_LCC.number_of_nodes()/G2.number_of_nodes()) plt.figure() nx.draw(G2_LCC, with_labels=False) plt.show()
def drawG(g,Xs=[],labels={},save=False,display=True): if type(g) == np.ndarray: g=nx.to_networkx_graph(g) nx.relabel_nodes(g, labels, copy=False) #pos=nx.spring_layout(g, scale=5.0) pos = nx.graphviz_layout(g, prog="fdp") nx.draw_networkx(g,pos,node_size=1000) # for node in range(numnodes): # if the above doesn't work # plt.annotate(str(node), xy=pos[node]) # here's a workaround if Xs != []: plt.title(Xs) plt.axis('off') if save==True: plt.savefig('temp.png') # need to parameterize if display==True: plt.show()
def convertIDToGraph(id,motifSize,save=False): """Plot graph with id and motifSize""" binary = bin(id); adj = np.zeros(motifSize*motifSize) for x in xrange(motifSize*motifSize): x+=1 if binary[-x] == 'b': break adj[-x] = int(binary[-x]) adj.shape = (motifSize,motifSize) graph = nx.to_networkx_graph(adj,create_using=nx.DiGraph()) nx.draw_circular(graph) if save: plt.savefig("result/id-"+str(id)+"size-"+str(motifSize)) else: plt.show() plt.clf()
def test_from_edgelist(self): # Pandas DataFrame g = nx.cycle_graph(10) G = nx.Graph() G.add_nodes_from(g) G.add_weighted_edges_from((u, v, u) for u, v in g.edges()) edgelist = nx.to_edgelist(G) source = [s for s, t, d in edgelist] target = [t for s, t, d in edgelist] weight = [d['weight'] for s, t, d in edgelist] edges = pd.DataFrame({'source': source, 'target': target, 'weight': weight}) GG = nx.from_pandas_edgelist(edges, edge_attr='weight') assert_nodes_equal(G.nodes(), GG.nodes()) assert_edges_equal(G.edges(), GG.edges()) GW = nx.to_networkx_graph(edges, create_using=nx.Graph()) assert_nodes_equal(G.nodes(), GW.nodes()) assert_edges_equal(G.edges(), GW.edges())
def convertIDToGraph(mid, motifSize, save=False): """Draw graph with id and motifSize""" binary = bin(mid); adj = np.zeros(motifSize*motifSize) l = 0 for x in xrange(1,motifSize*motifSize+1): if binary[-x+l] == 'b': break if (x-1) % (motifSize+1) == 0: l += 1 else: adj[-x] = int(binary[-x+l]) adj.shape = (motifSize,motifSize) graph = nx.to_networkx_graph(adj,create_using=nx.DiGraph()) nx.draw_circular(graph) if save: plt.savefig("result/id-"+str(id)+"size-"+str(motifSize)) else: plt.show() plt.clf()
def __str__(self,ID=''): # Matrix convertion to NetworkX graph: gx = networkx.to_networkx_graph(data=self.g) # Parameters deg = self.get_degrees() size_deg = [(10+(90*(i-min(deg)))/float(max(deg))) for i in deg] # size_deg = [(100*i/float(max(deg))) for i in deg] numlabels = False edgecolor = 'grey' nodecmap = pyplot.cm.rainbow # # Draw the graph with Matplotlib # networkx.draw(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot1.png") # pyplot.clf() # # Draw the graph with Matplotlib # networkx.draw_networkx(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot2-networkx.png") # pyplot.clf() # Draw the graph with a circular layout. # networkx.draw_circular(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot3-circular.png") # pyplot.clf() # # Draw the graph with a random layout. # networkx.draw_random(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot4-random.png") # pyplot.clf() # Draw the graph with a spectral layout. # networkx.draw_spectral(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot5-spectral.png") # pyplot.clf() # Draw the graph with a spring layout. networkx.draw_spring(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) pyplot.savefig(ID+"NetworkX_plot6-spring.png") pyplot.clf() # # Draw the graph with a shell layout. # networkx.draw_shell(gx, with_labels=numlabels, node_size=size_deg, linewidths=0, width=0.5, alpha=1, cmap=nodecmap, node_color=deg, edge_color=edgecolor) # pyplot.savefig(ID+"NetworkX_plot7-shell.png") # pyplot.clf() # pyplot.draw() # pyplot.show() return "\nNetwork display saved.\n"
def textrank(document): """ Performs the whole process of sentence comparison by similarity and scores sentence according to their importance within the document. We first vectorize documents with a bag-of-words (Count Vectorizer), then normalize the sentence vectors with tf-idf. Then, we construct graph adjacency matrix where edge weights are similarity values using one of our similarity functions. With that graph where vertices are sentences, we use networkx' built-in PageRank algorithm to score the sentences and return a list of tuples (sentence, score, document) ordered by score. """ if isinstance(document, basestring): # if the document is not tokenized sentences = sent_tokenize_func(document) else: # if the sentences are already tokenized sentences = document # vectorizer vectorizer = CountVectorizer() # vectorize individual sentences counting up the word occurences matrix = vectorizer.fit_transform(sentences) # normalize counts normalized = normalize_func(matrix) # creates a similarity graph matrix similarity_graph = similarity_func(normalized) # converts matrix to a networkx' graph struct nx_graph = nx.to_networkx_graph(similarity_graph) # use PageRank to score vertices in the graph scores = nx.pagerank(nx_graph) # return vertices ordered by score return sorted((TextRank(score=scores[i], sentence=sentence, document=i) for i, sentence in enumerate(sentences)), reverse=True)
def test_change_times(self): ns = tn.NetworkSequence() # complete graph on 4 vertices - could have used the networkx generator too t1 = np.array([[1,3,1,1],[3,1,1,1],[1,1,1,1],[1,1,1,1]]) g = nx.to_networkx_graph(t1) ns.add_network(0, g) ns.add_network(10, g) ns.add_network(5, g) ns.add_network(25, g) ns.add_network(3, g) times = ns.get_list_of_change_times() ns.get_graph_matrix_for_time(8) ns.get_graph_matrix_for_time(12) ns.get_graph_matrix_for_time(0) ns.get_graph_matrix_for_time(50) ns.get_graph_matrix_for_time(1) self.assertTrue(True)
log.append(starttime) while converge < max_converge: graphs, bestval=rw.graphSearch(graphs,numkeep,Xs,numnodes,maxlen,jeff,expected_irts) log.append(bestval) if bestval == oldbestval: converge += 1 else: bestgraphs.append(graphs[0]) if len(bestgraphs) > 5: bestgraphs.pop(0) converge = 0 oldbestval = bestval graphs=rw.genFromSeeds(graphs,numperseed,edgestotweak) gs=[nx.to_networkx_graph(i) for i in bestgraphs] # record endtime endtime=str(datetime.now()) log.append(endtime) for i, j in enumerate(gs): nx.relabel_nodes(j, items, copy=False) nx.write_dot(j,subj+"_"+str(i)+".dot") # write iterations and start/end time to log with open(subj+'_log.txt','w') as f: for item in log: print>>f, item with open(subj+'_lists.csv','w') as f:
for i in xrange(len(data)): j = reddits.index(data[i][0]) url_dict[j] = str(data[i][1]) size_dict[j] = int(data[i][2]) if data[i][3] == 1: NSFW_dict[j] = 'NSFW' else: NSFW_dict[j] = 'SFW' title_dict[j] = str(data[i][5]) sql.close() sql.status labels = dict() for i in xrange(len(reddits)): labels[i] = reddits[i] G = nx.to_networkx_graph(A) nx.set_node_attributes(G,'Subreddit Name',labels) nx.set_node_attributes(G,'size',size_dict) nx.set_node_attributes(G,'url',url_dict) nx.set_node_attributes(G,'NSFW',NSFW_dict) nx.set_node_attributes(G,'header title',headertitle_dict) nx.set_node_attributes(G,'title',title_dict) #nx.set_node_attributes(G,'Descriptions',desc_dict) nx.write_gexf(G, "test.gexf")
import networkx as net import process_tweets retweets=process_tweets.g len(retweets) retweets.remove_edges_from(retweets.selfloop_edges()) undir=net.to_networkx_graph(retweets) core=net.k_core(undir) len(core) net.draw(core)
for i in range(0,iterations): sampleoutput += currentchar currentNodeTransitions = [x for x in itertools.izip(alphabets,P[alphabets.index(currentchar),:])] currentchar = weighted_choice(currentNodeTransitions) return sampleoutput ################################################# #filesList = ['Sherlock.txt','HuckleberryFinn.txt','Contos.txt','license.txt','Charnet2.py'] filesList = ['abc.txt'] #onlyfiles = [ f for f in listdir('./Data') if isfile(join(mypath,f)) ] for f in filesList: chars = createCharsfromFile(f) alphabets = createAlphabetsfromChars(chars) transMat = createTransitionMatrix(chars,alphabets) P = (transMat.T/np.sum(transMat.T,axis=0)).T # figure(f) # plt.imshow(Pthresh, cmap = cm.Greys_r, interpolation = None) sampleoutput = randomwalk(P,alphabets,1000,alphabets[0]) fo = open(f + 'out.txt','w') fo.write(sampleoutput) fo.close() #a=[i+'->'+j for i,j in itertools.product(alphabets,alphabets)] G=nx.to_networkx_graph(P,create_using=nx.DiGraph()) nx.write_graphml(G,"charnet2.graphml") nx.write_gml(G,"charnet2.gml")
def network_properties(command, root_path): subj_props = command['data_parameters'] command = command['network_parameters'] # U-INVITE won't work with perseverations if command['network_method'] == "U-INVITE": removePerseverations=True else: removePerseverations=False if subj_props['factor_type'] == "subject": ids = str(subj_props['subject']) group = False elif subj_props['factor_type'] == "group": ids = str(subj_props['group']) # without str() causes unicode issues for "all" :( group = True filedata = snafu.readX(ids, subj_props['fullpath'], category=subj_props['category'], spellfile=label_to_filepath(subj_props['spellfile'], root_path, "spellfiles"), removePerseverations=removePerseverations, group=group) filedata.nonhierarchical() Xs = filedata.Xs items = filedata.items irts = filedata.irts numnodes = filedata.numnodes toydata=snafu.DataModel({ 'numx': len(Xs), 'trim': 1, 'jump': float(command['jump_probability']), 'jumptype': command['jump_type'], 'priming': float(command['priming_probability']), 'startX': command['first_item']}) fitinfo=snafu.Fitinfo({ 'prior_method': "zeroinflatedbetabinomial", 'prior_a': 1, 'prior_b': 2, 'zibb_p': 0.5, 'startGraph': command['starting_graph'], 'goni_size': int(command['goni_windowsize']), 'goni_threshold': int(command['goni_threshold']), 'followtype': "avg", 'prune_limit': 100, 'triangle_limit': 100, 'other_limit': 100}) if command['prior']=="None": prior=None elif command['prior']=="USF": usf_file_path = "/snet/USF_animal_subset.snet" filename = root_path + usf_file_path usf_graph, usf_items = snafu.read_graph(filename) usf_numnodes = len(usf_items) priordict = snafu.genGraphPrior([usf_graph], [usf_items], fitinfo=fitinfo) prior = (priordict, usf_items) if command['network_method']=="RW": bestgraph = snafu.noHidden(Xs, numnodes) elif command['network_method']=="Goni": bestgraph = snafu.goni(Xs, numnodes, td=toydata, valid=0, fitinfo=fitinfo) elif command['network_method']=="Chan": bestgraph = snafu.chan(Xs, numnodes) elif command['network_method']=="Kenett": bestgraph = snafu.kenett(Xs, numnodes) elif command['network_method']=="FirstEdge": bestgraph = snafu.firstEdge(Xs, numnodes) elif command['network_method']=="U-INVITE": bestgraph, ll = snafu.uinvite(Xs, toydata, numnodes, fitinfo=fitinfo, debug=False, prior=prior) nxg = nx.to_networkx_graph(bestgraph) nxg_json = jsonGraph(nxg, items) return graph_properties(nxg,nxg_json)
def drawDot(g, filename, labels={}): if type(g) == np.ndarray: g=nx.to_networkx_graph(g) if labels != {}: nx.relabel_nodes(g, labels, copy=False) nx.drawing.write_dot(g, filename)
for i in xrange(n_clu): fp = open(filepath+"\\a"+str(i)+".dat","w") mat = [[] for row in range(len(a_clusters[i]))] row = 0 for j in a_clusters[i]: for k in a_clusters[i]: mat[row].append(int(AAM[j][k])) fp.write(str(int(AAM[j][k]))) fp.write(" ") fp.write("\n") row = row + 1 fp.close() m = np.array(mat) G = nx.to_networkx_graph(m, None, False) a_cl_coeff[i] = nx.average_clustering(G, None, None, True) print("cluster file "+str(i)+" for network A written") b_clusters = [[] for row in range(n_clu)] j = 0 #nodes in each cluster a for i in b_labels: j = j + 1 b_clusters[i].append(j-1) print("identified node in each cluster of network B") #write clusters b