我们从Python开源项目中，提取了以下25个代码示例，用于说明如何使用networkx.to_numpy_matrix()。
def ConsensusCluster(self, data, subsamples, subsample_fraction, norm_var, kvalues): """ Performs consensus clustering algorithms here!!! """ return partition = dict() stuff = [] nb_clusters = 0 # this is the number of cluster the dataset is supposed to be partitioned into distances = nx.to_numpy_matrix(data) for i in kvalues: clusterid, error, nfound = KMeans(distances, nclusters= i, npass=300) uniq_ids = list(set(clusterid)) new_ids = [ uniq_ids.index(val) for val in clusterid] for i,value in enumerate(new_ids): partition[i] = value stuff.append(partition)
def graphlet_kernel(graphs, num_samples): N = len(graphs) Phi = np.zeros((N,2**15)) P = generate_permutation_matrix() for i in range(len(graphs)): n = graphs[i].number_of_nodes() if n >= 6: A = nx.to_numpy_matrix(graphs[i]) A = np.asarray(A, dtype=np.uint8) for j in range(num_samples): r = np.random.permutation(n) window = A[np.ix_(r[:6],r[:6])] Phi[i, graphlet_type(window)] += 1 Phi[i,:] /= num_samples K = np.dot(Phi,np.dot(P,np.transpose(Phi))) return K
def Floyd_Warshall(G): D = nx.to_numpy_matrix(G) m, n = D.shape for i in range(0, n): for j in range(0, n): if i != j and D[i, j] == 0: D[i, j] = float('inf') yield np.array(D), (0, 0, 0) for k in range(0, n): for i in range(0, n): for j in range(0, n): if D[i, j] > D[i, k] + D[k, j]: yield np.array(D), (i, j, k) D[i, j] = D[i, k] + D[k, j] yield np.array(D), (0, 0, 0)
def Transitive_Closure(G): D = nx.to_numpy_matrix(G).astype(bool) m, n = D.shape for k in range(0, n): for i in range(0, n): for j in range(0, n): if not D[i, j]: yield np.array(D), (i, j, k) D[i, j] = D[i, k] and D[k, j] yield np.array(D), (0, 0, 0)
def draw_adjacency_matrix(G, node_order=None, partitions=[], colors=[]): """ - G is a networkx graph - node_order (optional) is a list of nodes, where each node in G appears exactly once - partitions is a list of node lists, where each node in G appears in exactly one node list - colors is a list of strings indicating what color each partition should be If partitions is specified, the same number of colors needs to be specified. """ adjacency_matrix = nx.to_numpy_matrix(G, dtype=np.bool, nodelist=node_order) # Plot adjacency matrix in toned-down black and white fig = plt.figure(figsize=(8, 8)) # in inches plt.imshow(adjacency_matrix, cmap="Paired", interpolation="none") # The rest is just if you have sorted nodes by a partition and want to # highlight the module boundaries assert len(partitions) == len(colors) ax = plt.gca() for partition, color in zip(partitions, colors): current_idx = 0 for module in partition: ax.add_patch(patches.Rectangle((current_idx, current_idx), len(module), # Width len(module), # Height facecolor="none", edgecolor=color, linewidth="1")) current_idx += len(module) plt.show()
def draw(self): """ Draws the plot to screen. Note to self: Do NOT call super(MatrixPlot, self).draw(); the underlying logic for drawing here is completely different from other plots, and as such necessitates a different implementation. """ matrix = nx.to_numpy_matrix(self.graph, nodelist=self.nodes) self.ax.matshow(matrix, cmap=self.cmap)
def __init__(self, dfa): # type: (DFA) -> None """ Class for maintaining state path weights inside a dfa. This is a renormalized version of l_{p,n} in section 2 of the Bernardi & Giménez paper, computed using matrix powers. See: https://en.wikipedia.org/wiki/Adjacency_matrix#Matrix_powers Note that ``path_weights[state, n]`` is the proportion of paths of length n from state to _some_ final/accepting state. `dfa` MUST have consecutive integer states, with 0 as the start state, though this is not validated. """ self.longest_path_length = 0 self.graph = dfa.as_multidigraph self.sink = len(dfa.nodes()) for state in dfa.nodes(): if dfa.node[state]['accepting']: self.graph.add_edge(state, self.sink) self.matrix = nx.to_numpy_matrix(self.graph, nodelist=self.graph.nodes()) vect = np.zeros(self.matrix.shape[0]) vect[-1] = 1.0 # Grabs the neighborhood of the sink node (last column). self.vects = [self.normalize_vector(self.matrix.dot(vect)).T]
def computeKcliques(self,Number_of_clusters,data): partition = dict() nb_clusters = Number_of_clusters # this is the number of cluster the dataset is supposed to be partitioned into distances = nx.to_numpy_matrix(data) clusterid = nx.k_clique_communities(data) # print "k_Cliques",clusterid # uniq_ids = list(set(clusterid)) # new_ids = [ uniq_ids.index(val) for val in clusterid] # for i,value in enumerate(new_ids): # partition[i] = value return partition
def computeKmeans(self,Number_of_clusters,data, iterations = 100): partition = dict() nb_clusters = Number_of_clusters # this is the number of cluster the dataset is supposed to be partitioned into distances = nx.to_numpy_matrix(data) clusterid, error, nfound = KMeans(distances, nclusters= nb_clusters, npass=300) uniq_ids = list(set(clusterid)) new_ids = [ uniq_ids.index(val) for val in clusterid] for i,value in enumerate(new_ids): partition[i] = value return partition
def HierarchicalClustering(self,data): distances = nx.to_numpy_matrix(data) hierarchy = linkage(distances) print hierarchy,"HIERRATCJY" Z = dendrogram(hierarchy) print Z return hierarchy
def computeKmeansCustom(self,Number_of_clusters,data, iterations = 100): distances = nx.to_numpy_matrix(data) clusters,medoids = self.cluster(distances,Number_of_clusters) new_ids = [ uniq_ids.index(val) for val in clusterid]
def create_adjacency(graph): A = nx.to_numpy_matrix(graph, dtype=int) return A
def modularity(graph): # convert to numpy adjacency matrix A = nx.to_numpy_matrix(graph) # compute adjacency matrix A's degree centrality degree_centrality = np.sum(A, axis=0, dtype=int) m = np.sum(degree_centrality, dtype=int) / 2 # compute matrix B B = np.zeros(A.shape, dtype=float) for i in range(len(A)): for j in range(len(A)): B[i, j] = A[i, j] - (degree_centrality[0, i] * degree_centrality[0, j]) / float(2 * m) # compute A's eigenvector w, v = LA.eig(B) wmax = np.argmax(w) s = np.zeros((len(A), 1), dtype=float) for i in range(len(A)): if v[i, wmax] < 0: s[i, 0] = -1 else: s[i, 0] = 1 Q = s.T.dot(B.dot(s)) / float(4 * m) return Q[0, 0], s
def karate(path): """Load Zachary's Karate Club [@zachary1977information]. It is a social network of friendships between 34 members of a karate club at a US university from 1970 to 1972. During the study a conflict between instructor 'Mr. Hi' and administrator 'Officer' led the club to split into two. Half of the members formed a new club around 'Mr. Hi'; other members found a new instructor or quit karate. Args: path: str. Path to directory which either stores file or otherwise file will be downloaded and extracted there. Filename is `karate.gml`. Returns: Tuple of adjacency matrix as a np.darray `x_train` with 34 rows and 34 columns and np.darray `y_train` of class memberships (0 for 'Mr.Hi' and 1 for 'Officer'). """ import networkx as nx path = os.path.expanduser(path) filename = 'karate.gml' if not os.path.exists(os.path.join(path, filename)): url = 'http://www-personal.umich.edu/~mejn/netdata/karate.zip' maybe_download_and_extract(path, url) x_train = nx.read_gml(os.path.join(path, filename)) x_train = nx.to_numpy_matrix(x_train).astype(int) labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21] y_train = np.array([0 if i in labels else 1 for i in range(x_train.shape[0])], dtype=np.int) return x_train, y_train
def edge_transform(self, g): e = {} for n1, n2, d in g.edges_iter(data=True): e_t = [] e_t += [1] e[(n1, n2)] = e_t return nx.to_numpy_matrix(g), e
def edge_transform(self, g): e = {} for n1, n2, d in g.edges_iter(data=True): e_t = [] e_t += [float(x) for x in list(d.values())] e[(n1, n2)] = e_t return nx.to_numpy_matrix(g), e
def edge_transform(self, g): e = {} for n1, n2, d in g.edges_iter(data=True): e_t = [] e_t.append(d['label']) e[(n1, n2)] = e_t return nx.to_numpy_matrix(g), e
def evaluateStaticGraphReconstruction(digraph, graph_embedding, X_stat, node_l=None, file_suffix=None, sample_ratio_e=None, is_undirected=True, is_weighted=False): node_num = digraph.number_of_nodes() # evaluation if sample_ratio_e: eval_edge_pairs = evaluation_util.getRandomEdgePairs( node_num, sample_ratio_e, is_undirected ) else: eval_edge_pairs = None if file_suffix is None: estimated_adj = graph_embedding.get_reconstructed_adj(X_stat, node_l) else: estimated_adj = graph_embedding.get_reconstructed_adj( X_stat, file_suffix, node_l ) predicted_edge_list = evaluation_util.getEdgeListFromAdjMtx( estimated_adj, is_undirected=is_undirected, edge_pairs=eval_edge_pairs ) MAP = metrics.computeMAP(predicted_edge_list, digraph) prec_curv, _ = metrics.computePrecisionCurve(predicted_edge_list, digraph) # If weighted, compute the error in reconstructed weights of observed edges if is_weighted: digraph_adj = nx.to_numpy_matrix(digraph) estimated_adj[digraph_adj == 0] = 0 err = np.linalg.norm(digraph_adj - estimated_adj) err_baseline = np.linalg.norm(digraph_adj) else: err = None err_baseline = None return (MAP, prec_curv, err, err_baseline)
def learn_embedding(self, graph=None, edge_f=None, is_weighted=False, no_python=False): if not graph and not edge_f: raise Exception('graph/edge_f needed') if not graph: graph = graph_util.loadGraphFromEdgeListTxt(edge_f) t1 = time() # A = nx.to_scipy_sparse_matrix(graph) # I = sp.eye(graph.number_of_nodes()) # M_g = I - self._beta*A # M_l = self._beta*A A = nx.to_numpy_matrix(graph) M_g = np.eye(graph.number_of_nodes()) - self._beta * A M_l = self._beta * A S = np.dot(np.linalg.inv(M_g), M_l) u, s, vt = lg.svds(S, k=self._d // 2) X1 = np.dot(u, np.diag(np.sqrt(s))) X2 = np.dot(vt.T, np.diag(np.sqrt(s))) t2 = time() self._X = np.concatenate((X1, X2), axis=1) p_d_p_t = np.dot(u, np.dot(np.diag(s), vt)) eig_err = np.linalg.norm(p_d_p_t - S) print('SVD error (low rank): %f' % eig_err) return self._X, (t2 - t1)
def directed_modularity_matrix(G, nodelist=None): """ INCLUDED FOR TESTING PURPOSES - Not implemented yet. Return the directed modularity matrix of G. The modularity matrix is the matrix B = A - <A>, where A is the adjacency matrix and <A> is the expected adjacency matrix, assuming that the graph is described by the configuration model. More specifically, the element B_ij of B is defined as B_ij = A_ij - k_i(out) k_j(in)/m where k_i(in) is the in degree of node i, and k_j(out) is the out degree of node j, with m the number of edges in the graph. Parameters ---------- G : DiGraph A NetworkX DiGraph nodelist : list, optional The rows and columns are ordered according to the nodes in nodelist. If nodelist is None, then the ordering is produced by G.nodes(). Returns ------- B : Numpy matrix The modularity matrix of G. Notes ----- NetworkX defines the element A_ij of the adjacency matrix as 1 if there is a link going from node i to node j. Leicht and Newman use the opposite definition. This explains the different expression for B_ij. See Also -------- to_numpy_matrix adjacency_matrix laplacian_matrix modularity_matrix References ---------- .. [1] E. A. Leicht, M. E. J. Newman, "Community structure in directed networks", Phys. Rev Lett., vol. 100, no. 11, p. 118703, 2008. """ if nodelist is None: nodelist = G.nodes() A = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, format='csr') k_in = A.sum(axis=0) k_out = A.sum(axis=1) m = G.number_of_edges() # Expected adjacency matrix X = k_out * k_in / m return A - X
def Find_InterModular_Edge_correlativity(self): # Induced graph is the data structure responsible for the adjacency matrix of the community self.Matrix = nx.to_numpy_matrix(self.induced_graph) # Matrix Before calculating the correlation strength # finding out the lower half values of the matrix, can discard other values as computationally intensive self.Matrix = np.tril(self.Matrix,-1) i=0 Sum = 0 j=0 SumTemp = 0 Edges = 0 nodes1 = [item for item in self.Graphwidget.scene().items() if isinstance(item, Node)] # ite1rateing over the indices for community in set(self.partition.values()): i= i + 1 j=0 for community2 in set(self.partition.values()): j= j + 1 # Not Calculating the communities which are communities to itself if community == community2: continue # Calculating the correlation strength only with the lower half of the adjacency matrix if i <= j: continue # list_nodes1 and list_nodes2 indicate which nodes are actually present in these communties list_nodes1 = [nodes for nodes in self.partition.keys() if self.partition[nodes] == community] list_nodes2 = [nodes for nodes in self.partition.keys() if self.partition[nodes] == community2] # Re-initializing the SumTemp = 0 Edges = 0 for node1 in nodes1: if node1.counter-1 in list_nodes1: for node2 in nodes1: if node2.counter-1 in list_nodes2: if node1.counter-1 == node2.counter-1: continue if self.Graphwidget.Graph_data().ThresholdData[node1.counter-1][node2.counter-1] > 0: Edges = Edges + 1 if Edges != 0: Sum=float("{0:.2f}".format(self.Matrix[i-1,j-1]/Edges)) self.Matrix[i-1,j-1] = Sum self.induced_graph = nx.from_numpy_matrix(self.Matrix)
def participation_coefficient(self,G, weighted_edges=False): """"Compute participation coefficient for nodes. Parameters ---------- G: graph A networkx graph weighted_edges : bool, optional If True use edge weights Returns ------- node : dictionary Dictionary of nodes with participation coefficient as the value Notes ----- The participation coefficient is calculated with respect to a community affiliation vector. This function uses the community affiliations as determined by the Louvain modularity algorithm (http://perso.crans.org/aynaud/communities/). """ partition = cm.best_partition(G) partition_list = [] for count in range(len(partition)): partition_list.append(partition[count]) n = G.number_of_nodes() Ko = [] for node in range(n): node_str = np.sum([G[node][x]['weight'] for x in G[node].keys()]) Ko.append(node_str) Ko = np.array(Ko) G_mat_weighted = np.array(nx.to_numpy_matrix(G)) G_mat = (G_mat_weighted != 0) * 1 D = np.diag(partition_list) Gc = np.dot(G_mat, D) Kc2 = np.zeros(n) for i in range(np.max(partition_list) + 1): Kc2 = Kc2 + (np.sum(G_mat_weighted * (Gc == i),1) ** 2) P = np.ones(n) - (Kc2/(Ko **2)) D = dict() for i in range(len(P)): D[i]=P[i] return D
def prepareClsuterData(self, graph, Timestep, syllable): print "Cluster Time ",Timestep, "Syllable:",syllable self.Timestep = Timestep distances = copy.deepcopy(nx.to_numpy_matrix(graph)) samples = [x for x in xrange(len(distances))] self.ParsedData = ConsensusClster.DataModel.ParseNormal(distances, samples) idlist = [ x.sample_id for x in self.ParsedData.samples ] if len(dict.fromkeys(idlist)) != len(idlist): raise ValueError, 'One or more Sample IDs are not unique!\n\n\nHere is the data'+str(len(dict.fromkeys(idlist)))+'len'+str(len(idlist)) if not self.pca_only: self._postprocess() kwds = [] self.GlobalCDF = dict() self.partition1 = dict() self.deltaArea = dict() self.area = dict() self.newKValues = [2,3,4,5,6,7] for i in self.newKValues: self.partition1[i] = self.run_cluster(i, self.subsamples, self.subsample_fraction, self.norm_var, kwds) k = self.createDeltaArea(self.kvalues) if Timestep == 62: ChangeInDeltaArea = "ConsensusData/DeltaAreaChange"+str(self.graphWidget.Syllable)+str(4)+"Heatmap.tsv" AllClusterData = "ConsensusData/AllClusterings"+str(self.graphWidget.Syllable)+str(4)+"Heatmap.tsv" with open(ChangeInDeltaArea, 'w') as outfile: kValues = 'day' #K-values timeSteps = 'hour' #hour value = 'value' outfile.write("{}\t{}\t{}\n".format(timeSteps,kValues,value)) for i,j in self.DeltaAreaTimestep.iteritems(): KDict = j # print i, KDict for k,value in KDict.iteritems(): outfile.write("{}\t{}\t{}\n".format(i,k,value)) outfile.close() with open(AllClusterData, 'w') as outfile: pickle.dump(self.FinalPartiction, outfile) print AllClusterData, "is the file name for all data", "look at the K value data and choose Wisely:)" if k == 1: partition = dict() for i in range(len(distances)): partition[i] = 0 self.partition1[1] = partition self.FinalPartiction[self.Timestep] = self.partition1 return self.partition1[k]
def qm9_edges(g, e_representation='raw_distance'): remove_edges = [] e={} for n1, n2, d in g.edges_iter(data=True): e_t = [] # Raw distance function if e_representation == 'chem_graph': if d['b_type'] is None: remove_edges += [(n1, n2)] else: e_t += [i+1 for i, x in enumerate([rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.DOUBLE, rdkit.Chem.rdchem.BondType.TRIPLE, rdkit.Chem.rdchem.BondType.AROMATIC]) if x == d['b_type']] elif e_representation == 'distance_bin': if d['b_type'] is None: step = (6-2)/8.0 start = 2 b = 9 for i in range(0, 9): if d['distance'] < (start+i*step): b = i break e_t.append(b+5) else: e_t += [i+1 for i, x in enumerate([rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.DOUBLE, rdkit.Chem.rdchem.BondType.TRIPLE, rdkit.Chem.rdchem.BondType.AROMATIC]) if x == d['b_type']] elif e_representation == 'raw_distance': if d['b_type'] is None: remove_edges += [(n1, n2)] else: e_t.append(d['distance']) e_t += [int(d['b_type'] == x) for x in [rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.DOUBLE, rdkit.Chem.rdchem.BondType.TRIPLE, rdkit.Chem.rdchem.BondType.AROMATIC]] else: print('Incorrect Edge representation transform') quit() if e_t: e[(n1, n2)] = e_t for edg in remove_edges: g.remove_edge(*edg) return nx.to_numpy_matrix(g), e
