def could_be_isomorphic(G1, G2): """Returns False if graphs are definitely not isomorphic. True does NOT guarantee isomorphism. Parameters ---------- G1, G2 : graphs The two graphs G1 and G2 must be the same type. Notes ----- Checks for matching degree, triangle, and number of cliques sequences. """ # Check global properties if G1.order() != G2.order(): return False # Check local properties d1 = G1.degree() t1 = nx.triangles(G1) c1 = nx.number_of_cliques(G1) props1 = [[d, t1[v], c1[v]] for v, d in d1] props1.sort() d2 = G2.degree() t2 = nx.triangles(G2) c2 = nx.number_of_cliques(G2) props2 = [[d, t2[v], c2[v]] for v, d in d2] props2.sort() if props1 != props2: return False # OK... return True
def could_be_isomorphic(G1,G2): """Returns False if graphs are definitely not isomorphic. True does NOT guarantee isomorphism. Parameters ---------- G1, G2 : graphs The two graphs G1 and G2 must be the same type. Notes ----- Checks for matching degree, triangle, and number of cliques sequences. """ # Check global properties if G1.order() != G2.order(): return False # Check local properties d1 = G1.degree() t1=nx.triangles(G1) c1=nx.number_of_cliques(G1) props1 = [[d, t1[v], c1[v]] for v, d in d1] props1.sort() d2=G2.degree() t2=nx.triangles(G2) c2=nx.number_of_cliques(G2) props2 = [[d, t2[v], c2[v]] for v, d in d2] props2.sort() if props1 != props2: return False # OK... return True
def graph_could_be_isomorphic(G1,G2): """ Returns False if graphs G1 and G2 are definitely not isomorphic. True does NOT garantee isomorphism. Checks for matching degree, triangle, and number of cliques sequences. """ # Check global properties if G1.order() != G2.order(): return False # Check local properties d1=G1.degree(with_labels=True) t1=networkx.triangles(G1,with_labels=True) c1=networkx.number_of_cliques(G1,with_labels=True) props1=[ [d1[v], t1[v], c1[v]] for v in d1 ] props1.sort() d2=G2.degree(with_labels=True) t2=networkx.triangles(G2,with_labels=True) c2=networkx.number_of_cliques(G2,with_labels=True) props2=[ [d2[v], t2[v], c2[v]] for v in d2 ] props2.sort() if props1 != props2: # print props1 # print props2 return False # OK... return True
def graphical_features(train_data, test_data): ''' Compute some structural features on the graph obtained from the questions ''' df = pd.concat([train_data[['qid1', 'qid2']], test_data[['qid1', 'qid2']]], axis = 0, ignore_index=True) g = nx.Graph() g.add_nodes_from(df.qid1) edges = list(df[["qid1", "qid2"]].to_records(index=False)) g.add_edges_from(edges) g.remove_edges_from(g.selfloop_edges()) print('Get kcore dict') kcore_dict = nx.core_number(g) print('Get centrality dict') centrality_dict = nx.degree_centrality(g) print('Get closeness dict') closeness_dict = nx.closeness_centrality(g) print('Get cliques dict') cliques_dict = nx.number_of_cliques(g) return np.array([(min(kcore_dict[qid1], kcore_dict[qid2]), max(kcore_dict[qid1], kcore_dict[qid2]), min(centrality_dict[qid1], centrality_dict[qid2]), max(centrality_dict[qid1], centrality_dict[qid2]), min(closeness_dict[qid1], closeness_dict[qid2]), max(closeness_dict[qid1], closeness_dict[qid2]), min(cliques_dict[qid1], cliques_dict[qid2]), max(cliques_dict[qid1], cliques_dict[qid2])) for qid1, qid2 in zip(train_data.qid1, train_data.qid2)]), \ np.array([(min(kcore_dict[qid1], kcore_dict[qid2]), max(kcore_dict[qid1], kcore_dict[qid2]), min(centrality_dict[qid1], centrality_dict[qid2]), max(centrality_dict[qid1], centrality_dict[qid2]), min(closeness_dict[qid1], closeness_dict[qid2]), max(closeness_dict[qid1], closeness_dict[qid2]), min(cliques_dict[qid1], cliques_dict[qid2]), max(cliques_dict[qid1], cliques_dict[qid2])) for qid1, qid2 in zip(test_data.qid1, test_data.qid2)])
def find_cliques(self): ''' Function finds the number of cliques to which each vertex belongs. Generates a separate list for each chain.''' self.cliques = [] for chain in self.chains: # for each chain generate a dictionary of the number of cliques # to which each atom in the chain belongs self.cliques.append(nx.number_of_cliques(chain))
def find_cliques(self): """ Function finds the number of cliques to which each vertex belongs. Generates a separate list for each chain.""" self.cliques = [] for chain in self.chains: # for each chain generate a dictionary of the number of cliques # to which each atom in the chain belongs self.cliques.append(nx.number_of_cliques(chain))
def nodes_number_of_cliques(self): """ Parameters ---------- Returns ------- NxGraph: Graph object Examples -------- >>> """ if self.is_directed: return nx.number_of_cliques(self._graph.to_undirected()) else: return nx.number_of_cliques(self._graph)
def hash_nxgraph(g: nx.Graph): t = nx.triangles(g) c = nx.number_of_cliques(g) ele = nx.get_node_attributes(g, 'symbol') dv = g.degree props = [(dv[v], t[v], c[v], ele[v]) for v in g] props.sort() s = str(props) return hashstr2int(s)
def calculate_undir_centralities(self, G, U, suffix): ''' Calculate centralities in undirected graph and add them as node attributes ''' nx.set_node_attributes(G, nx.degree_centrality(U), 'degree_%s' % suffix) nx.set_node_attributes(G, nx.node_clique_number(U), 'clique_number_%s' % suffix) nx.set_node_attributes(G, nx.number_of_cliques(U), 'num_of_cliques_%s' % suffix) return G
def props_for_hash(self): """ see https://stackoverflow.com/questions/46999771/ use with caution... """ t = nx.triangles(self.graph) c = nx.number_of_cliques(self.graph) ele = nx.get_node_attributes(self.graph, 'symbol') dv = self.graph.degree props = [(dv[v], t[v], c[v], ele[v]) for v in self.graph] props.sort() return props
def test_number_of_cliques(self): G = self.G assert nx.graph_number_of_cliques(G) == 5 assert nx.graph_number_of_cliques(G, cliques=self.cl) == 5 assert nx.number_of_cliques(G, 1) == 1 assert list(nx.number_of_cliques(G, [1]).values()) == [1] assert list(nx.number_of_cliques(G, [1, 2]).values()) == [1, 2] assert nx.number_of_cliques(G, [1, 2]) == {1: 1, 2: 2} assert nx.number_of_cliques(G, 2) == 2 assert (nx.number_of_cliques(G) == {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert (nx.number_of_cliques(G, nodes=list(G)) == {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert (nx.number_of_cliques(G, nodes=[2, 3, 4]) == {2: 2, 3: 1, 4: 2}) assert (nx.number_of_cliques(G, cliques=self.cl) == {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert (nx.number_of_cliques(G, list(G), cliques=self.cl) == {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1})
def test_number_of_cliques(self): G=self.G assert_equal(nx.graph_number_of_cliques(G),5) assert_equal(nx.graph_number_of_cliques(G,cliques=self.cl),5) assert_equal(nx.number_of_cliques(G,1),1) assert_equal(list(nx.number_of_cliques(G,[1]).values()),[1]) assert_equal(list(nx.number_of_cliques(G,[1,2]).values()),[1, 2]) assert_equal(nx.number_of_cliques(G,[1,2]),{1: 1, 2: 2}) assert_equal(nx.number_of_cliques(G,2),2) assert_equal(nx.number_of_cliques(G), {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert_equal(nx.number_of_cliques(G,nodes=G.nodes()), {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert_equal(nx.number_of_cliques(G,nodes=[2,3,4]), {2: 2, 3: 1, 4: 2}) assert_equal(nx.number_of_cliques(G,cliques=self.cl), {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}) assert_equal(nx.number_of_cliques(G,G.nodes(),cliques=self.cl), {1: 1, 2: 2, 3: 1, 4: 2, 5: 1, 6: 2, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1})
def cliques_strategy(G, num_seeds): ''' Picks the top nodes based on number of cliques per node Args: G -- the input graph num_seeds -- the number of seed nodes to select Returns: list of output nodes based on the cliques ''' centralities_dict = nx.number_of_cliques(G) sorted_centralities = nlargest(num_seeds, centralities_dict.items(), key=operator.itemgetter(1)) node_keys = [i[0] for i in sorted_centralities] return node_keys
def compute_node_measures(ntwk, calculate_cliques=False): """ These return node-based measures """ iflogger.info('Computing node measures:') measures = {} iflogger.info('...Computing degree...') measures['degree'] = np.array(list(ntwk.degree().values())) iflogger.info('...Computing load centrality...') measures['load_centrality'] = np.array( list(nx.load_centrality(ntwk).values())) iflogger.info('...Computing betweenness centrality...') measures['betweenness_centrality'] = np.array( list(nx.betweenness_centrality(ntwk).values())) iflogger.info('...Computing degree centrality...') measures['degree_centrality'] = np.array( list(nx.degree_centrality(ntwk).values())) iflogger.info('...Computing closeness centrality...') measures['closeness_centrality'] = np.array( list(nx.closeness_centrality(ntwk).values())) # iflogger.info('...Computing eigenvector centrality...') # measures['eigenvector_centrality'] = np.array(nx.eigenvector_centrality(ntwk, max_iter=100000).values()) iflogger.info('...Computing triangles...') measures['triangles'] = np.array(list(nx.triangles(ntwk).values())) iflogger.info('...Computing clustering...') measures['clustering'] = np.array(list(nx.clustering(ntwk).values())) iflogger.info('...Computing k-core number') measures['core_number'] = np.array(list(nx.core_number(ntwk).values())) iflogger.info('...Identifying network isolates...') isolate_list = nx.isolates(ntwk) binarized = np.zeros((ntwk.number_of_nodes(), 1)) for value in isolate_list: value = value - 1 # Zero indexing binarized[value] = 1 measures['isolates'] = binarized if calculate_cliques: iflogger.info('...Calculating node clique number') measures['node_clique_number'] = np.array( list(nx.node_clique_number(ntwk).values())) iflogger.info('...Computing number of cliques for each node...') measures['number_of_cliques'] = np.array( list(nx.number_of_cliques(ntwk).values())) return measures
print str(" ") print 'Ο αριθμός κλίκας (το μέγεθος της μεγαλύτερης κλίκας) του G είναι:', nx.graph_clique_number( G) # print 'The clique number (size of the largest clique) for G is:', nx.graph_clique_number(G) # print sorted(nx.connected_components(G), key = len, reverse=True) print str(" ") print 'Το λεξικό των κλικών που περιέχουν κάθε κόμβο είναι:' # print 'The dictionary of the lists of cliques containing each node:' print nx.cliques_containing_node(G) print str(" ") print 'Το λεξικό του πλήθους κλικών που περιέχουν κάθε κόμβο είναι:' # print 'The dictionary of the numbers of maximal cliques for each node:' print nx.number_of_cliques(G) print str(" ") print 'Το λεξικό του μεγέθους των μεγαλύτερων κλικών που περιέχουν κάθε κόμβο είναι:' # print 'The dictionary of the sizes of the largest maximal cliques containing each given node:' print nx.node_clique_number(G) print str(" ") maxclique = [ clq for clq in nx.find_cliques(G) if len(clq) == nx.graph_clique_number(G) ] nodes = [n for clq in maxclique for n in clq] H = G.subgraph(nodes) # print H.edges() #### ΣΧΕΔΙΑΣΜΟΣ ΚΛΙΛΩΝ ΜΕΣΑ ΣΕ ΠΕΡΙΒΑΛΛΟΜΕΝΕΣ ΧΡΩΜΑΤΙΣΜΕΝΕΣ ΠΕΡΙΟΧΕΣ
#!/usr/bin/env python # -*- coding: utf-8 -*- import networkx as nx # opciok: https://networkx.github.io/documentation/stable/reference/index.html G = nx.connected_caveman_graph(4, 7) print(nx.number_of_cliques(G)) for clique in nx.find_cliques(G): print(clique) print("\n") print(nx.degree_centrality(G)) print("\n") print(nx.edge_betweenness_centrality(G)) print("\n") degree_sequence = sorted(nx.degree(G).values(), reverse=True) print(degree_sequence)
# -*- coding: utf-8 -*- """ AFRS - Trabalho 4 Author: Gonçalo Peres Date: 2019/02/02 """ import networkx as nx g = nx.read_gml('dolphins.gml') clique = nx.number_of_cliques(g) print(clique)
@author: Administrator """ import networkx as nx import matplotlib.pyplot as plt from nx_graph_build import build_G import community #G = nx.read_gml(r"C:\Users\Administrator\Desktop\dolphins.gml") G = build_G() print(nx.number_of_nodes(G)) print(nx.number_of_edges(G)) #cliques 小圈子, nx.number_of_cliques(G, nodes = 'TR77') 返node所处的圈子位置。 #nx.number_of_cliques(G) 返回所有节点和所在的圈子,以{node:num} 字典的形式。 print(nx.number_of_cliques(G, nodes = 'TR77')) #list of k-cliques in the network. each element contains the nodes that consist the clique. klist = list(nx.community.k_clique_communities(G,3)) print(len(klist)) #小圈子中nx.community.k_clique_communities(G,k) k个点要求是相互有联系,既之前都有线相连, 多个小圈子组成的社区 #通过设置不同的k值,圈出的社区数量也会随之变化 #for k in range(3,6): # klist_new = list(nx.community.k_clique_communities(G,k)) # print(len(klist_new)) #去除在社区中的节点,留下不属于任何社区的节点 aa = list(G.nodes()) list_1 = [] for item in klist: list_1.extend(item)
print "Compute number of maximal ciiques" print "-------------------------------------" graphNumberOfCliques = nx.graph_number_of_cliques(G, cliques) print graphNumberOfCliques print "-------------------------------------" print "Compute size of largest maximal clique containing a given node" print "-------------------------------------" maximalCliqueSizePerNode = nx.node_clique_number(G) print maximalCliqueSizePerNode print "-------------------------------------" print "Compute number of maximal cliques for each node" print "-------------------------------------" noOfMaximalCliquesPerNode = nx.number_of_cliques(G) print noOfMaximalCliquesPerNode print "-------------------------------------" print "Compute list of cliques containing a given node" print "-------------------------------------" lcliques = nx.cliques_containing_node(G) print lcliques print "-------------------------------------" print "Writing data into global file" print "-------------------------------------" globalCliqueFile = 'data/globalCliqueFile.csv' mode = ''; if os.path.isfile(globalCliqueFile):
G.add_edges_from(edgeTuples) return G #Read in data nodesOne = pd.read_csv('data/got-s1-nodes.csv', low_memory=False) edgesOne = pd.read_csv('data/got-s1-edges.csv', low_memory=False) G = create_graph(nodesOne, edgesOne) nx.degree(G) nx.modularity_matrix(G) nx.density(G) list(nx.find_cliques(G)) nx.number_of_cliques(G) nx.clustering(G) nx.eigenvector_centrality(G) nx.number_of_isolates(G) nx.isolates(G) nx.pagerank(G) nx.shortest_path(G)
print lvl2 print str(" ") print "Ο αριθμός κλίκας (το μέγεθος της μεγαλύτερης κλίκας) του G είναι:", nx.graph_clique_number(G) # print 'The clique number (size of the largest clique) for G is:', nx.graph_clique_number(G) # print sorted(nx.connected_components(G), key = len, reverse=True) print str(" ") print "Το λεξικό των κλικών που περιέχουν κάθε κόμβο είναι:" # print 'The dictionary of the lists of cliques containing each node:' print nx.cliques_containing_node(G) print str(" ") print "Το λεξικό του πλήθους κλικών που περιέχουν κάθε κόμβο είναι:" # print 'The dictionary of the numbers of maximal cliques for each node:' print nx.number_of_cliques(G) print str(" ") print "Το λεξικό του μεγέθους των μεγαλύτερων κλικών που περιέχουν κάθε κόμβο είναι:" # print 'The dictionary of the sizes of the largest maximal cliques containing each given node:' print nx.node_clique_number(G) print str(" ") maxclique = [clq for clq in nx.find_cliques(G) if len(clq) == nx.graph_clique_number(G)] nodes = [n for clq in maxclique for n in clq] H = G.subgraph(nodes) # print H.edges() #### ΣΧΕΔΙΑΣΜΟΣ ΚΛΙΛΩΝ ΜΕΣΑ ΣΕ ΠΕΡΙΒΑΛΛΟΜΕΝΕΣ ΧΡΩΜΑΤΙΣΜΕΝΕΣ ΠΕΡΙΟΧΕΣ
def get_graph(Mat_D, Threshold, percentageConnections=False, complet=False): import scipy.io as sio import numpy as np import networkx as nx import pandas as pd import os Data = sio.loadmat(Mat_D) matX = Data['Correlation'] #[:tamn,:tamn] labels = Data['labels'] print(np.shape(matX)) print(np.shape(labels)) print(np.min(matX), np.max(matX)) if percentageConnections: if percentageConnections > 0 and percentageConnections < 1: for i in range(-100, 100): per = np.sum(matX > i / 100.) / np.size(matX) if per <= Threshold: Threshold = i / 100. break print(Threshold) else: print('The coefficient is outside rank') #Lista de conexion del grafo row, col = np.shape(matX) e = [] for i in range(1, row): for j in range(i): if complet: e.append((labels[i], labels[j], matX[i, j])) else: if matX[i, j] > Threshold: e.append((labels[i], labels[j], matX[i, j])) print(np.shape(e)[0], int(((row - 1) * row) / 2)) #Generar grafo G = nx.Graph() G.add_weighted_edges_from(e) labelNew = list(G.nodes) #Metricas por grafo (ponderados) Dpc = nx.degree_pearson_correlation_coefficient(G, weight='weight') cluster = nx.average_clustering(G, weight='weight') #No ponderados estra = nx.estrada_index(G) tnsity = nx.transitivity(G) conNo = nx.average_node_connectivity(G) ac = nx.degree_assortativity_coefficient(G) #Metricas por nodo tam = 15 BoolCenV = False BoolLoad = False alpha = 0.1 beta = 1.0 katxCN = nx.katz_centrality_numpy(G, alpha=alpha, beta=beta, weight='weight') bcen = nx.betweenness_centrality(G, weight='weight') av_nd = nx.average_neighbor_degree(G, weight='weight') ctr = nx.clustering(G, weight='weight') ranPaN = nx.pagerank_numpy(G, weight='weight') Gol_N = nx.hits_numpy(G) Dgc = nx.degree_centrality(G) cl_ce = nx.closeness_centrality(G) cluster_Sq = nx.square_clustering(G) centr = nx.core_number(G) cami = nx.node_clique_number(G) camiN = nx.number_of_cliques(G) trian = nx.triangles(G) colorG = nx.greedy_color(G) try: cenVNum = nx.eigenvector_centrality_numpy(G, weight='weight') tam = tam + 1 BoolCenV = True except TypeError: print( "La red es muy pequeña y no se puede calcular este parametro gil") except: print('NetworkXPointlessConcept: graph null') if Threshold > 0: carga_cen = nx.load_centrality(G, weight='weight') #Pesos positivos BoolLoad = True tam = tam + 1 #katxC=nx.katz_centrality(G, alpha=alpha, beta=beta, weight='weight') #cenV=nx.eigenvector_centrality(G,weight='weight') #cenV=nx.eigenvector_centrality(G,weight='weight') #Golp=nx.hits(G) #Gol_si=nx.hits_scipy(G) #ranPa=nx.pagerank(G, weight='weight') #ranPaS=nx.pagerank_scipy(G, weight='weight') matrix_datos = np.zeros((tam, np.shape(labelNew)[0])) tam = 15 print(np.shape(matrix_datos)) lim = np.shape(labelNew)[0] for i in range(lim): roi = labelNew[i] #print(roi) matrix_datos[0, i] = katxCN[roi] matrix_datos[1, i] = bcen[roi] matrix_datos[2, i] = av_nd[roi] matrix_datos[3, i] = ctr[roi] matrix_datos[4, i] = ranPaN[roi] matrix_datos[5, i] = Gol_N[0][roi] matrix_datos[6, i] = Gol_N[1][roi] matrix_datos[7, i] = Dgc[roi] matrix_datos[8, i] = cl_ce[roi] matrix_datos[9, i] = cluster_Sq[roi] matrix_datos[10, i] = centr[roi] matrix_datos[11, i] = cami[roi] matrix_datos[12, i] = camiN[roi] matrix_datos[13, i] = trian[roi] matrix_datos[14, i] = colorG[roi] if BoolCenV: matrix_datos[15, i] = cenVNum[roi] tam = tam + 1 if BoolLoad: matrix_datos[16, i] = carga_cen[roi] tam = tam + 1 #matrix_datos[0,i]=katxC[roi] #matrix_datos[2,i]=cenV[roi] #matrix_datos[7,i]=Golp[0][roi] #matrix_datos[9,i]=Gol_si[0][roi] #matrix_datos[10,i]=Golp[1][roi] #matrix_datos[12,i]=Gol_si[1][roi] #matrix_datos[22,i]=ranPa[roi] #matrix_datos[24,i]=ranPaS[roi] FuncName = [ 'degree_pearson_correlation_coefficient', 'average_clustering', 'estrada_index', 'transitivity', 'average_node_connectivity', 'degree_assortativity_coefficient', 'katz_centrality_numpy', 'betweenness_centrality', 'average_neighbor_degree', 'clustering', 'pagerank_numpy', 'hits_numpy0', 'hits_numpy1', 'degree_centrality', 'closeness_centrality', 'square_clustering', 'core_number', 'node_clique_number', 'number_of_cliques', 'triangles', 'greedy_color', 'eigenvector_centrality_numpy', 'load_centrality' ] frame = pd.DataFrame(matrix_datos) frame.columns = labelNew frame.index = FuncName[6:tam] Resul = os.getcwd() out_data = Resul + '/graph_metrics.csv' out_mat = Resul + '/graph_metrics_global.mat' frame.to_csv(out_data) sio.savemat( out_mat, { FuncName[0]: Dpc, FuncName[1]: cluster, FuncName[2]: estra, FuncName[3]: tnsity, FuncName[4]: conNo, FuncName[5]: ac }) return out_data, out_mat
print 'loading edges' for i in temp1: G.add_edge(i[0], i[1]) print 'loading nodes' for i in temp2: G.add_node(i[0]) print 'calc core number' cn = nx.core_number(G) print 'calc clique number' kn = nx.node_clique_number(G) print 'calc number of cliques' kn2 = nx.number_of_cliques(G) print 'calculating node measures' for u, e in G.nodes_iter(data=True): dr = str(nx.degree(G, u)) cl = str(nx.clustering(G, u)) #cc = str(nx.betweenness_centrality(G)[u]) ct = cn[u] knu = kn[u] kn2u = kn2[u] #ks = str(nx.k_shell(G)[u]) f3.write(u + " " + dr + " " + cl + " " + str(ct) + " " + str(knu) + " " + str(kn2u) + "\n") f3.close() print 'calc edge measures'
(i.to_undirected().number_of_edges() * 2 /i.to_undirected().number_of_nodes()) ** 2) print 'Average number of neighbors' print sum(nx.average_neighbor_degree(i.to_undirected()).values()) print 'Nodes' print nx.number_of_nodes(i.to_undirected()) print 'edges' print nx.number_of_edges(i.to_undirected()) print 'Density' print nx.density(trem_nets.to_undirected()) print 'Number of cliques' print len(nx.number_of_cliques(i.to_undirected())) print 'Average Degree' print 2.0 * (len(i.to_undirected().edges())) / len(i.to_undirected().nodes()) print 'Average Degree Assortativity' print nx.degree_assortativity_coefficient(i.to_undirected()) # things for only connected graphs ddi = max(nx.connected_component_subgraphs(ddi_nets.to_undirected()), key=len) print 'Network Diameter' nx.diameter(ddi.to_undirected()) print 'Shorest paths (sum)' sum(nx.all_pairs_shortest_path_length(ddi_owl.to_undirected()).values()[0].values())
for articles in db.view('_all_docs'): ##search quoter in autors j=articles['id'] if db[j]["Author"] == quoter: ##quoter is an author in database for quot in db[j]["Quoters"]: #search author in qouters of quoter if quot == Aut: H.add_node(quot) H.add_node(Aut) H.add_edge(Aut, quoter) nx.draw(H,pos=nx.spring_layout(H)) NumOfCliqes=nx.graph_clique_number(H) print ("Clique number of the graph : ") print (NumOfCliqes) # MaxCliques = nx.find_cliques(H) print ("All maximal cliques: ") print(list(MaxCliques)) ## node_clique_number=nx.node_clique_number(H) print ("Size of the largest maximal clique containing each given node") print (node_clique_number) number_of_cliques=nx.number_of_cliques(H) print ("Number of maximal cliques for each node.") print (number_of_cliques)