def close_enough(G, num_edge):
#return: true if the point is close enough to the original, false if not
G_new = sample_edges(G, num_edge)
real = nx.degree_pearson_correlation_coefficient(G)
current = nx.degree_pearson_correlation_coefficient(G_new)
if (current <= real * 1.1 and current >= real * 0.9):
return True
else:
return False
def degassortcoef(self):
'''
It returns degree assortativity coefficient path from each network
'''
dac = pd.DataFrame(np.nan,
index=self.indiv,
columns=['ave_cluster_coef'])
for k in self.indiv:
G = nx.from_numpy_matrix(self.nets[k].values)
G.edges(data=True)
dac.loc[k] = nx.degree_pearson_correlation_coefficient(
G, weight='weight')
print nx.degree_pearson_correlation_coefficient(G, weight='weight')
return dac
def create_graph(self): g = nx.Graph() duplicated_nodes_list = self.only_nodes.iloc[:,0].append(self.only_nodes.iloc[:,1]).reset_index(drop=True) nodes_list = duplicated_nodes_list.values.tolist() No_duplicate_nodes = set(nodes_list) # print(len(No_duplicate_nodes))#327 g.add_nodes_from(No_duplicate_nodes) g.add_edges_from(self.No_duplicate_links) # nx.draw(g,node_size = 1.5)#with_labels=True # plt.draw() # plt.show() link_density = nx.density(g) # print(link_density)#0.109 average_degree = nx.average_neighbor_degree(g) # numbers degreeede= [average_degree[key] for key in average_degree] # mean = statistics.mean(numbers) # var = statistics.variance(numbers) # print(var) degree_correlation = nx.degree_pearson_correlation_coefficient(g) # print(degree_correlation)#0.033175769936049336 average_clustering = nx.average_clustering(g) # print(average_clustering)#0.5035048191728447 average_hopcount = nx.average_shortest_path_length(g) # print(average_hopcount)#2.1594341569576554 diameter = nx.diameter(g) # print(diameter)#4 # A = nx.adjacency_matrix(g) A_eigenvalue = nx.adjacency_spectrum(g) # print(max(A_eigenvalue))#(41.231605032525835+0j) G_eigenvalue = nx.laplacian_spectrum(g) # print(sorted(G_eigenvalue))#1.9300488624481513 return g, nodes_list, No_duplicate_nodes, link_density, average_degree
def get_default_feature(self, graph: nx.Graph, direct):
result = []
result.append(len(graph.nodes))
result.append(nx.density(graph))
degrees = nx.degree(graph)
degrees = np.array([item[1]for item in degrees])
clusters = nx.clustering(graph)
clusters = np.array([clusters[item] for item in clusters.keys()])
# topologic = nx.topological_sort(graph)
result.append(degrees.mean())
result.append(degrees.max())
result.append(degrees.min())
result.append(degrees.var())
result.append(clusters.mean())
result.append(clusters.max())
result.append(clusters.var())
if direct:
# 计算有方向的时候的补充特征
pass
else:
# 计算无向的时候的补充特征
correlation = nx.degree_pearson_correlation_coefficient(
graph)
result.append(correlation if correlation is not np.nan else 0.0)
return list(result)
def compute_features(self):
# Adding basic node and edge numbers
self.add_feature(
"degree_assortativity_coeff",
lambda graph: nx.degree_assortativity_coefficient(graph),
"Similarity of connections in the graph with respect to the node degree",
InterpretabilityScore(4),
)
self.add_feature(
"degree_assortativity_coeff_pearson",
lambda graph: nx.degree_pearson_correlation_coefficient(graph),
"Similarity of connections in the graph with respect to the node degree",
InterpretabilityScore(4),
)
average_neighbor_degree = lambda graph: list(
assortativity.average_neighbor_degree(graph).values())
self.add_feature(
"degree assortativity",
average_neighbor_degree,
"average neighbor degree",
InterpretabilityScore(4),
statistics="centrality",
)
def print_graph_stats(self, G):
print('average clustering: ', nx.average_clustering(G))
degrees = [val for (node, val) in G.degree()]
print('average degree: ', sum(degrees) / float(len(G)))
print('density: ', nx.density(G))
print('assortativity coefficient (Pearson\'s rho): ',
nx.degree_pearson_correlation_coefficient(G))
print('(should be negative according to Gonzalez et al., 2007)')
import operator
x = nx.betweenness_centrality(G)
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
print('betweenness centrality', sorted_x)
x = nx.degree_centrality(G)
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
print('degree centrality:', sorted_x)
x = nx.eigenvector_centrality(G)
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
print('eigenvector centrality:', sorted_x)
x = nx.katz_centrality(G)
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
print('Katz centrality:', sorted_x)
x = nx.closeness_centrality(G)
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
print('closeness centrality:', sorted_x)
print('\n')
def correlation_vertex_degree(self, cvde=False):
"""
Computes the correlation of vertex degree.
The computation is done on the simplified graph.
Parameters
----------
cvde : float
Optional input: coefficient of variation of the degree.
If not provided, it is computed automatically internally.
Returns
-------
float
Correlation of Vertex Degree
Examples
--------
>>> cvd = correlation_vertex_degree()
"""
if not cvde:
_, cvde = self.mean_degree_and_CV()
# To avoid division by 0 when computing correlation coef
if cvde != 0:
cvd = nx.degree_pearson_correlation_coefficient(self.graph_simpl)
else:
cvd = 1
return cvd
def analyse_graph(G):
print(nx.info(G))
n_components = nx.number_connected_components(G)
print("Number of connected components:", n_components)
if n_components > 1:
component_sizes = [
len(c)
for c in sorted(nx.connected_components(G), key=len, reverse=True)
]
print("Connected component sizes:", component_sizes)
lcc_percent = 100 * component_sizes[0] / G.number_of_nodes()
print(f"LCC: {lcc_percent}%")
avg_c = nx.average_clustering(G)
print("Average clustering coefficient:", avg_c)
degree_assortativity = nx.degree_pearson_correlation_coefficient(G)
print("Degree assortativity:", degree_assortativity)
if nx.is_connected(G):
avg_d = nx.average_shortest_path_length(G)
print("Average distance:", avg_d)
else:
avg_distances = [
nx.average_shortest_path_length(C)
for C in (G.subgraph(c).copy() for c in nx.connected_components(G))
]
print("Average distances:", avg_distances)
avg_connectivity = nx.average_degree_connectivity(G)
print("Average degree connectivity:", avg_connectivity)
def assortativity(g, degree, weights=None):
'''
Returns the assortativity of the graph.
This tells whether nodes are preferentially connected together depending
on their degree.
Parameters
----------
g : :class:`~nngt.Graph`
Graph to analyze.
degree : str
The type of degree that should be considered.
weights : bool or str, optional (default: binary edges)
Whether edge weights should be considered; if ``None`` or ``False``
then use binary edges; if ``True``, uses the 'weight' edge attribute,
otherwise uses any valid edge attribute required.
References
----------
.. [nx-assortativity]
:nxdoc:`algorithms.assortativity.degree_assortativity_coefficient`
'''
w = _get_nx_weights(g, weights)
return nx.degree_pearson_correlation_coefficient(
g.graph, x=degree, y=degree, weight=w)
def compute_singlevalued_measures(ntwk, weighted=True, calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info("Computing single valued measures:")
measures = {}
iflogger.info("...Computing degree assortativity (pearson number) ...")
try:
measures["degree_pearsonr"] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures["degree_pearsonr"] = nx.degree_pearson_correlation_coefficient(ntwk)
iflogger.info("...Computing degree assortativity...")
try:
measures["degree_assortativity"] = nx.degree_assortativity(ntwk)
except AttributeError:
measures["degree_assortativity"] = nx.degree_assortativity_coefficient(ntwk)
iflogger.info("...Computing transitivity...")
measures["transitivity"] = nx.transitivity(ntwk)
iflogger.info("...Computing number of connected_components...")
measures["number_connected_components"] = nx.number_connected_components(ntwk)
iflogger.info("...Computing average clustering...")
measures["average_clustering"] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info("...Calculating average shortest path length...")
measures["average_shortest_path_length"] = nx.average_shortest_path_length(ntwk, weighted)
if calculate_cliques:
iflogger.info("...Computing graph clique number...")
measures["graph_clique_number"] = nx.graph_clique_number(ntwk) # out of memory error
return measures
def compute_graph(graph, nodePositions, mask):
"""Compute graph properties.
Parameters
----------
graph : original graph
nodePositions : node positions
mask : binary array of cellular region of interest
Returns
-------
properties : list of graph properties
"""
nodeNumber = graph.number_of_nodes()
edgeNumber = graph.number_of_edges()
connectedComponents = connected_components(graph)
connectedComponentsNumber = len(connectedComponents)
edgeCapacity = 1.0 * np.array([property['capa'] for node1, node2, property in graph.edges(data=True)])
bundling = np.nanmean(edgeCapacity)
assortativity = nx.degree_pearson_correlation_coefficient(graph, weight='capa')
shortestPathLength = path_lengths(graph)
reachability = np.nanmean(shortestPathLength)
shortestPathLengthSD = np.nanstd(shortestPathLength)
shortestPathLengthCV = 1.0 * shortestPathLengthSD / reachability
algebraicConnectivity = np.sort(nx.laplacian_spectrum(graph, weight='capa'))[1]
edgeAngles = edge_angles(graph, nodePositions, mask)
edgeAnglesMean = np.nanmean(edgeAngles)
edgeAnglesSD = np.nanstd(edgeAngles)
edgeAnglesCV = 1.0 * edgeAnglesSD / edgeAnglesMean
edgeCrossings = crossing_number(graph, nodePositions)
edgeCrossingsMean = np.nanmean(edgeCrossings)
properties = [nodeNumber, edgeNumber, connectedComponentsNumber, bundling, assortativity, reachability, shortestPathLengthCV, algebraicConnectivity, edgeAnglesCV, edgeCrossingsMean]
return(properties)
def metr_gr(graph):
deg = nx.degree_centrality(graph)
max_deg = sorted(deg, key=deg.get, reverse=True)
print('Max degree centrality:', ", ".join(max_deg[:5]))
bet = nx.betweenness_centrality(graph)
max_bet = sorted(bet, key=bet.get, reverse=True)
print('Max betweenness centrality:', ", ".join(max_bet[:5]))
clos = nx.closeness_centrality(graph)
max_clos = sorted(clos, key=clos.get, reverse=True)
print('Max closeness centrality:', ", ".join(max_clos[:5]))
eig = nx.eigenvector_centrality(graph)
max_eig = sorted(eig, key=eig.get, reverse=True)
print('Max eigencentrality:', ", ".join(max_eig[:5]))
print('Плотность:', nx.density(graph))
print('Радиус:', nx.radius(graph))
print('Диаметр:', nx.diameter(graph))
print('Коэффициент кластеризации:', nx.average_clustering(graph))
print('Коэффициент ассортативности:',
nx.degree_pearson_correlation_coefficient(graph))
return clos
def graph_stats(G, file=None):
"""
Prints stats about a graph
:param G: networkx Graph
:param file: the file to write the stats
:return:
"""
info = "Network info:\n" + nx.info(G)
print(info)
file.write(info + '\n')
dens = "Network density: " + str(nx.density(G))
print(dens)
file.write(dens + '\n')
con = "Network connected?: " + str(nx.is_connected(G))
print(con)
file.write(con + '\n')
# if nx.is_connected(G):
# diam = "Network diameter: " + str(nx.diameter(G))
# print(diam)
# f.write(diam)
avg_cl = 'Average clustering coeff: ' + str(nx.average_clustering(G))
print(avg_cl)
file.write(avg_cl + '\n')
trans = "Triadic closure: " + str(nx.transitivity(G))
print(trans)
file.write(trans + '\n')
pear = 'Degree Pearson corr coeff: ' + str(
nx.degree_pearson_correlation_coefficient(G))
print(pear)
file.write(pear + '\n')
def network_metrics(network, network_red, n_fibres, tag=''):
"""Analyse networkx Graph object"""
database = pd.Series(dtype=object)
database['No. Fibres'] = n_fibres
cross_links = np.array([degree[1] for degree in network.degree], dtype=int)
database[f"{tag} Network Cross-Link Density"] = ((cross_links > 2).sum() /
n_fibres)
try:
value = nx.degree_pearson_correlation_coefficient(network,
weight='r')**2
except Exception as err:
logger.debug(f'Network Degree calculation failed: {str(err)}')
value = None
database[f"{tag} Network Degree"] = value
try:
value = np.real(nx.adjacency_spectrum(network_red).max())
except Exception as err:
logger.debug(f'Network Eigenvalue calculation failed: {str(err)}')
value = None
database[f"{tag} Network Eigenvalue"] = value
try:
value = nx.algebraic_connectivity(network_red, weight='r')
except Exception as err:
logger.debug(f'Network Connectivity calculation failed: {str(err)}')
value = None
database[f"{tag} Network Connectivity"] = value
return database
def data_analysis(self, graph):
data_vec = [0] * 13
num_vertex = nx.number_of_nodes(graph)
data_vec[0] = nx.average_clustering(graph)
sq_values = list(nx.square_clustering(graph).values())
data_vec[1] = sum(sq_values) / len(sq_values)
g = nx.path_graph(num_vertex)
data_vec[2] = nx.average_shortest_path_length(
graph) / nx.average_shortest_path_length(g)
data_vec[3] = nx.degree_pearson_correlation_coefficient(graph)
if math.isnan(data_vec[3]) is True:
data_vec[3] = 0
data_vec[4] = nx.diameter(graph) / (num_vertex - 1)
data_vec[5] = nx.density(graph)
data_vec[6] = nx.edge_connectivity(graph) / (num_vertex - 1)
g = nx.star_graph(num_vertex - 1)
Freeman_degree_norm = self.freeman_centralization(
nx.degree_centrality(g))
Freeman_close_norm = self.freeman_centralization(
nx.closeness_centrality(g))
Freeman_between_norm = self.freeman_centralization(
nx.betweenness_centrality(g))
# need to change
Freeman_eigen_norm = self.freeman_centralization(
nx.eigenvector_centrality_numpy(g))
data_vec[7] = self.freeman_centralization(
nx.degree_centrality(graph)) / Freeman_degree_norm
data_vec[8] = self.freeman_centralization(
nx.closeness_centrality(graph)) / Freeman_close_norm
data_vec[9] = self.freeman_centralization(
nx.betweenness_centrality(graph)) / Freeman_between_norm
# warning, the way it normalized may not correct
data_vec[10] = self.freeman_centralization(
nx.eigenvector_centrality_numpy(graph)) / Freeman_eigen_norm
egvl_lap = nx.laplacian_spectrum(graph)
egvl_lap = np.sort(egvl_lap)
egvl_lap = np.delete(egvl_lap, 0, 0)
summ = 0
for mu in egvl_lap:
summ += (1 / mu)
summ = summ * num_vertex
data_vec[11] = (num_vertex - 1) / summ
# for simple graph(adj matrix is symmetric), eigenvalue must be real number.
egvl_adj = np.real(nx.adjacency_spectrum(graph))
data_vec[12] = max(egvl_adj) / (num_vertex - 1)
return data_vec
def assortativity(G):
"""次数相関(assortativity)
ref : http://www.logos.ic.i.u-tokyo.ac.jp/~chik/InfoTech12/08%20Masuda.pdf
:param G: graph
:return: float, assortativity
"""
# nx.degree_assorattivity_coefficientと同じだが，計算時間が早い
return nx.degree_pearson_correlation_coefficient(G)
def more_inf(g):
r = nx.radius(g)
d = nx.diameter(g)
ka = nx.degree_pearson_correlation_coefficient(g)
p = nx.density(g)
kc = nx.average_clustering(g)
nn = g.number_of_nodes()
ne = g.number_of_edges()
return r, d, p, ka, kc, nn, ne
def analyzeGraph(G):
s = ""
s += "Радиус графа: " + str(nx.radius(G)) + "<br/>"
s += "Диаметр графа: " + str(nx.diameter(G)) + "<br/>"
s += "Коэффициент ассортативности: " + str(
nx.degree_pearson_correlation_coefficient(G)) + "<br/>"
s += "Плотность графа: " + str(nx.density(G)) + "<br/>"
s += "Коэффициент кластеризации: " + str(
nx.average_clustering(G)) + "<br/>"
return s
def info_network(G):
from networkx.algorithms import bipartite
from decimal import Decimal
print G.number_of_nodes()
print G.number_of_edges()
print "average_neighbor_degree"
dict = nx.average_neighbor_degree(G)
list1 = dict.keys()
list2 = dict.values()
print list1
print list2
print "degree_assortativity_coefficient"
print nx.degree_assortativity_coefficient(G)
print "degree_pearson_correlation_coefficient"
print nx.degree_pearson_correlation_coefficient(G)
# print nx.k_nearest_neighbors(G)
print "STOP HERE"
print "bipartite.closeness_centrality(G,G.node)"
dict2 = bipartite.closeness_centrality(G, G.node)
list3 = dict2.values()
print list3
print "nx.degree_centrality(G)"
dict3 = nx.degree_centrality(G)
list4 = dict3.values()
print list4
print "nx.betweenness_centrality(G)"
dict4 = nx.betweenness_centrality(G)
list5 = dict4.values()
print list5
print "hits_numpy"
dict5 = nx.hits_numpy(G)
print dict5
def network_stats(G):
node_count = len(G)
edge_count = len(G.edges())
density = (2 * edge_count) / (node_count * (node_count - 1))
clustering = np.mean(list(nx.clustering(G).values()))
degree_dist = list(dict(G.degree()).values())
k_avg = np.mean(degree_dist)
k_std = np.std(degree_dist, ddof=1)
giant_component = max(nx.connected_components(G))
giant_component_percent = float(len(giant_component)) / float(node_count)
if min(degree_dist) < 1:
adjust = np.abs(min(degree_dist)) + 1
else:
adjust = 0
reweighted_dist = [val + adjust for val in degree_dist]
normed_dist = [
reweighted_dist.count(val) / node_count
for val in range(1, node_count + 1)
]
entropy = sp.entropy(normed_dist)
max_ent_dis = list(range(1, node_count + 1))
max_ent = sp.entropy(max_ent_dis)
entropy = entropy / max_ent
if k_std == 0: #if degrees equal
assortativity = 1
else:
assortativity = nx.degree_pearson_correlation_coefficient(G)
if np.isnan(assortativity):
assortativity = 0
disassortativity = assortativity * -1
stats = dict(
(('node_count', node_count), ('edge_count', edge_count),
('clustering', clustering), ('giant component',
giant_component_percent),
('disssortativity', disassortativity), ('k avg', k_avg),
('k std', k_std), ('entropy', entropy), ('density', density)))
return stats
def centrality_and_params_graph(g):
degree_counter = []
betweenness_counter = []
closeness_counter = []
eigen_counter = []
deg = nx.degree_centrality(g)
for nodeid in sorted(deg, key=deg.get, reverse=True):
degree_counter.append(nodeid)
biggest_deg = {key: value for key, value in deg.items() if value in
sorted(set(deg.values()), reverse=True)[:2]}
bet = nx.betweenness_centrality(g)
for nodeid in sorted(bet, key=bet.get, reverse=True):
betweenness_counter.append(nodeid)
biggest_bet = {key: value for key, value in bet.items() if value in
sorted(set(bet.values()), reverse=True)[:2]}
cls = nx.closeness_centrality(g)
for nodeid in sorted(cls, key=cls.get, reverse=True):
closeness_counter.append(nodeid)
biggest_cls = {key: value for key, value in cls.items() if value in
sorted(set(cls.values()), reverse=True)[:2]}
eig = nx.eigenvector_centrality(g)
for nodeid in sorted(eig, key=eig.get, reverse=True):
eigen_counter.append(nodeid)
biggest_eig = {key: value for key, value in eig.items() if value in
sorted(set(eig.values()), reverse=True)[:2]}
radius = nx.radius(g)
diameter = nx.diameter(g)
assort_coef = nx.degree_pearson_correlation_coefficient(g)
clustering = nx.average_clustering(g)
node_number = g.number_of_nodes()
edge_number = g.number_of_edges()
communities = community.greedy_modularity_communities(g)
dict_return = {'biggest_deg': biggest_deg, 'biggest_bet': biggest_bet,
'biggest_cls': biggest_cls, 'biggest_eig': biggest_eig,
'radius': radius, 'diameter': diameter,
'assort_coef': assort_coef,
'clustering': clustering, 'node_number': node_number,
'edge_number': edge_number,
'communities': communities}
print(dict_return)
return 0
def compute_singlevalued_measures(ntwk,
weighted=True,
calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info("Computing single valued measures:")
measures = {}
iflogger.info("...Computing degree assortativity (pearson number) ...")
try:
measures["degree_pearsonr"] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures[
"degree_pearsonr"] = nx.degree_pearson_correlation_coefficient(
ntwk)
iflogger.info("...Computing degree assortativity...")
try:
measures["degree_assortativity"] = nx.degree_assortativity(ntwk)
except AttributeError:
measures["degree_assortativity"] = nx.degree_assortativity_coefficient(
ntwk)
iflogger.info("...Computing transitivity...")
measures["transitivity"] = nx.transitivity(ntwk)
iflogger.info("...Computing number of connected_components...")
measures["number_connected_components"] = nx.number_connected_components(
ntwk)
iflogger.info("...Computing graph density...")
measures["graph_density"] = nx.density(ntwk)
iflogger.info("...Recording number of edges...")
measures["number_of_edges"] = nx.number_of_edges(ntwk)
iflogger.info("...Recording number of nodes...")
measures["number_of_nodes"] = nx.number_of_nodes(ntwk)
iflogger.info("...Computing average clustering...")
measures["average_clustering"] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info("...Calculating average shortest path length...")
measures[
"average_shortest_path_length"] = nx.average_shortest_path_length(
ntwk, weighted)
else:
iflogger.info("...Calculating average shortest path length...")
measures[
"average_shortest_path_length"] = nx.average_shortest_path_length(
nx.connected_component_subgraphs(ntwk)[0], weighted)
if calculate_cliques:
iflogger.info("...Computing graph clique number...")
measures["graph_clique_number"] = nx.graph_clique_number(
ntwk) # out of memory error
return measures
def compute_singlevalued_measures(ntwk, weighted=True,
calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info('Computing single valued measures:')
measures = {}
iflogger.info('...Computing degree assortativity (pearson number) ...')
try:
measures['degree_pearsonr'] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures[
'degree_pearsonr'] = nx.degree_pearson_correlation_coefficient(
ntwk)
iflogger.info('...Computing degree assortativity...')
try:
measures['degree_assortativity'] = nx.degree_assortativity(ntwk)
except AttributeError:
measures['degree_assortativity'] = nx.degree_assortativity_coefficient(
ntwk)
iflogger.info('...Computing transitivity...')
measures['transitivity'] = nx.transitivity(ntwk)
iflogger.info('...Computing number of connected_components...')
measures['number_connected_components'] = nx.number_connected_components(
ntwk)
iflogger.info('...Computing graph density...')
measures['graph_density'] = nx.density(ntwk)
iflogger.info('...Recording number of edges...')
measures['number_of_edges'] = nx.number_of_edges(ntwk)
iflogger.info('...Recording number of nodes...')
measures['number_of_nodes'] = nx.number_of_nodes(ntwk)
iflogger.info('...Computing average clustering...')
measures['average_clustering'] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info('...Calculating average shortest path length...')
measures[
'average_shortest_path_length'] = nx.average_shortest_path_length(
ntwk, weighted)
else:
iflogger.info('...Calculating average shortest path length...')
measures[
'average_shortest_path_length'] = nx.average_shortest_path_length(
nx.connected_component_subgraphs(ntwk)[0], weighted)
if calculate_cliques:
iflogger.info('...Computing graph clique number...')
measures['graph_clique_number'] = nx.graph_clique_number(
ntwk) # out of memory error
return measures
def describe_graph(G):
"""Graph description"""
# GRAPH DESCRIPTION
graph_desc = pd.Series()
# n. nodes
graph_desc["number_of_nodes"] = G.number_of_nodes()
# n. edges
graph_desc["number_of_edges"] = G.number_of_edges()
# n. of selfloops
graph_desc["number_of_selfloops"] = len(G.selfloop_edges())
# density
graph_desc["average_shortest_path_length"] = nx.average_shortest_path_length(G)
# connectivity
# graph_desc.append(pd.Series(nx.degree_assortativity_coefficient(G), name="degree_assortativity_coefficient"))
graph_desc["degree_pearson_correlation_coefficient"] = nx.degree_pearson_correlation_coefficient(G)
# NODE DESCRIPTION
node_desc = list()
# n. of neighbours
node_desc.append(pd.Series(G.degree(), name="degree"))
node_desc.append(pd.Series(nx.average_neighbor_degree(G), name="average_neighbor_degree"))
# n. of outgoing
outgoing = pd.Series(G.in_degree(), name="in_degree")
node_desc.append(outgoing)
# n. of incoming
incoming = pd.Series(G.out_degree(), name="out_degree")
node_desc.append(incoming)
# fold change out/in
ratio = np.log2(outgoing + 1) - np.log2(incoming + 1)
node_desc.append(pd.Series(ratio, name="out_in_degree_fold_change"))
# centrality
# degree based
node_desc.append(pd.Series(nx.degree_centrality(G), name="degree_centrality"))
node_desc.append(pd.Series(nx.in_degree_centrality(G), name="in_degree_centrality"))
node_desc.append(pd.Series(nx.out_degree_centrality(G), name="out_degree_centrality"))
# closest-path based
# node_desc.append(pd.Series(nx.closeness_centrality(G), name="closeness_centrality"))
# node_desc.append(pd.Series(nx.betweenness_centrality(G), name="betweenness_centrality"))
# # eigenvector-based
# node_desc.append(pd.Series(nx.eigenvector_centrality(G), name="eigenvector_centrality"))
# node_desc.append(pd.Series(nx.katz_centrality_numpy(G), name="katz_centrality"))
# # load-based
# node_desc.append(pd.Series(nx.load_centrality(G), name="load_centrality"))
return (graph_desc, pd.DataFrame(node_desc).T)
def stats(graph):
stats_dict = {}
stats_dict['N'] = graph.number_of_nodes()
print("Liczba węzłów: " + str(stats_dict['N']))
stats_dict['E'] = graph.number_of_edges()
print("Liczba krawędzi: " + str(stats_dict['E']))
stats_dict['knn'] = knn(graph)
print("Średni stopień najbliższego węzła: " + str(stats_dict['knn']))
stats_dict['corr'] = nx.degree_pearson_correlation_coefficient(graph)
print("Współczynnik korelacji: " + str(stats_dict['corr']))
stats_dict['wsp_gron'] = wspolczynnik_gronowania(graph)
print("Współczynnik gronowania: " + str(stats_dict['wsp_gron']))
# zdecydowaliśmy się na wykorzystanie funkcji z biblioteki nx, ponieważ działa zdecydowanie szybciej
stats_dict['avg_dist'] = nx.average_shortest_path_length(graph)
print("Średni dystans: " + str(stats_dict['avg_dist']))
def dia(G):
print('Диаметр графа, самый длинный путь' +
'от одной вершины до другой: ',
nx.diameter(G))
print('Коэффициент ассортативности (насколько вся сеть',
' завязана на основных "хабах": )',
nx.degree_pearson_correlation_coefficient(G))
print('Плотность графа, отношение рёбер и узлов: ',
nx.density(G))
print('вот какой коэффициент у нашего графа: ',
nx.average_clustering(G))
#print(nx.transitivity(G))
return clos
def feature(node, edge):
G = nx.MultiGraph()
G = G.to_directed()
G.add_nodes_from(node)
G.add_edges_from(edge)
f = np.zeros(10)
f[0] = len(G.nodes)
f[1] = len(G.edges)
f[2] = nx.density(G)
f[3] = nx.degree_pearson_correlation_coefficient(G)
f[4] = nx.algorithms.reciprocity(G)
f[5] = 0 #nx.transitivity(G)
f[6] = nx.is_weakly_connected(G)
f[7] = nx.number_weakly_connected_components(G)
f[8] = nx.is_strongly_connected(G)
f[9] = nx.number_strongly_connected_components(G)
return f
def graph_descriptor_extractor(self, network_path):
G = nx.read_pajek(network_path)
G_is_directed = nx.is_directed(G)
if G_is_directed:
G = nx.DiGraph(G)
else:
G = nx.Graph(G)
G_nodes = G.nodes()
G_edges = G.edges()
G_num_nodes = len(G_nodes)
"Descriptor a) number of nodes"
G_num_edges = len(G_edges)
"Descriptor b) number of edges"
sorted_degrees = sorted(nx.degree(G).values())
G_min_degree = sorted_degrees[0]
"Descriptor c.i) minimum"
G_max_degree = sorted_degrees[-1]
"Descriptor c.ii) maximum"
if G_is_directed:
G_avg_degree = G_num_edges / float(G_num_nodes)
"Descriptor c.iii) average"
else:
G_avg_degree = 2.0 * G_num_edges / float(G_num_nodes)
"Descriptor c.iii) average"
G_assortativity = nx.degree_pearson_correlation_coefficient(G)
"Descriptor e) Assortativity"
G_avg_clustering = nx.average_clustering(G)
"Descriptor d) Average clustering coefficient"
G_avg_path_length = nx.average_shortest_path_length(G)
"Descriptor f) Average path length"
G_diameter = nx.diameter(G)
"Descriptor g) Diameter"
return [
G_num_nodes, G_num_edges, G_min_degree, G_max_degree, G_avg_degree,
G_assortativity, G_avg_clustering, G_avg_path_length, G_diameter
]
def get_info(field):
d = {
'Количество узлов ':
field.number_of_nodes(),
'Количество рёбер ':
field.number_of_edges(),
'Плотность графа ':
nx.density(field),
'Диаметр ':
nx.diameter(field),
'Радиус ':
nx.radius(field),
'Коэффициент кластеризации ':
nx.average_clustering(field),
'Коэффициент ассортативности ':
nx.degree_pearson_correlation_coefficient(field)
}
return d
def graph_about():
print('number of nodes {}'.format(nx.number_of_nodes(G)))
print('number of edges {}'.format(nx.number_of_edges(G)))
print('radius {}'.format(nx.radius(G)))
print('diameter {}'.format(nx.diameter(G)))
print('average_clustering {}'.format(nx.average_clustering(G)))
print('transitivity {}'.format(nx.transitivity(G)))
print('density {}'.format(nx.density(G)))
print('degree_pearson_correlation_coefficient {}'.format(
nx.degree_pearson_correlation_coefficient(G)))
deg = nx.degree_centrality(G)
nodes = []
for node in sorted(deg, key=deg.get, reverse=True):
nodes.append(node)
#print('top central nodes: {}'.format(' '.join(nodes[:20])))
sub_G = G.subgraph(nodes[:30]) #визуализируем центральные узлы и их связи
visualize(sub_G, 'graph_top30.png')
visualize(G, 'graph_total.png')
def stats(self):
# include: number nodes; number edges; density; conectively; assortativity
num_nodes = self._FN.order()
num_edges = self._FN.size()
density = nx.density(self._FN)
connectivity = nx.node_connectivity(self._FN)
assortativity = nx.degree_pearson_correlation_coefficient(
self._FN, x='out', y='in', weight='weight')
stats = {}
stats['nodes'] = np.round(num_nodes, 0)
stats['edges'] = np.round(num_edges, 0)
stats['density'] = np.round(density, 2)
stats['connectivity'] = np.round(connectivity, 0)
stats['assortativity'] = np.round(assortativity, 2)
return pd.Series(stats, name='stats')
def graph_stats(G):
density = nx.density(G)
try:
corr = nx.degree_pearson_correlation_coefficient(G)
except:
corr = 0
avg_neighbor_degree = nx.average_neighbor_degree(G) #dict
k_nearest_neighbors = nx.k_nearest_neighbors(G) #dict
degree_centrality = nx.degree_centrality(G) #dict
info = nx.info(G)
return {
'density': density,
'corr': corr,
'avg_neighbor_degree': avg_neighbor_degree,
'k_nearest_neighbors': k_nearest_neighbors,
'degree_centrality': degree_centrality,
'info': info
}
def metric_signature(G):
deg_dist = np.array(list(G.degree()), dtype=int)[:, 1]
spls = nx.all_pairs_shortest_path_length(G)
spls = np.array(list(spls))[:, 1]
spl_dist = []
for n in spls:
spl_dist += [item[1] for item in n.items()]
coms = nx.algorithms.community.modularity_max.greedy_modularity_communities(
G)
com_dist = [len(l) for l in list(coms)]
return {
'nodes': nx.number_of_nodes(G),
'edges': nx.number_of_edges(G),
'assort': nx.degree_pearson_correlation_coefficient(G),
'avgcc': nx.average_clustering(G),
'module': nx.algorithms.community.quality.coverage(G, coms),
'deg_dist': np.array(sorted(deg_dist)),
'spl_dist': np.array(sorted(spl_dist)),
'com_dist': np.array(sorted(com_dist))
}
def assortativity(self):
result = {}
result[
'degree_assortativity_coefficient'] = nx.degree_assortativity_coefficient(
self.graph)
if self.directed == 'undirected':
result[
'degree_pearson_correlation_coefficient'] = nx.degree_pearson_correlation_coefficient(
self.graph)
result['average_neighbor_degree'] = nx.average_neighbor_degree(
self.graph)
result['average_degree_connectivity'] = nx.average_degree_connectivity(
self.graph)
result['k_nearest_neighbors'] = nx.k_nearest_neighbors(self.graph)
fname_assort = self.DIR + '/assortativity.json'
with open(fname_assort, "w") as f:
json.dump(result, f, cls=SetEncoder, indent=2)
print(fname_assort)
# print G.node for row in csv.reader(csvfile): G.add_edges_from([(row[0],row[1])],weight=row[2]) print "average_neighbor_degree" print nx.average_neighbor_degree(G) print "degree_assortativity_coefficient" print nx.degree_assortativity_coefficient(G) print "degree_pearson_correlation_coefficient" print nx.degree_pearson_correlation_coefficient(G) #print nx.k_nearest_neighbors(G) print "bipartite.closeness_centrality" print bipartite.closeness_centrality(G,G.node) print "degree_centrality" print nx.degree_centrality(G) print "betweenness_centrality" print nx.betweenness_centrality(G) print "k_nearest_neighbors" print nx.k_nearest_neighbors(G)
def _ComputeCorrelationCoefficient(self, graph):
return networkx.degree_pearson_correlation_coefficient(graph)
return (indegreeSeq) def getOutDegreeSeq(G): outdegreeSeq = sorted([G.out_degree(u) for u in G.nodes()], reverse=True) return (outdegreeSeq) if __name__=="__main__": Gorig = nx.read_edgelist(realNetworkFileName, create_using=nx.DiGraph(), nodetype=int) Gregen = nx.read_edgelist(regeneratedFileName, create_using=nx.DiGraph(), nodetype=int) print "Real network loaded with N =", Gorig.number_of_nodes(), "M=", Gorig.number_of_edges() print "Regenerated Network loaded with N =", Gregen.number_of_nodes(), "M =", Gregen.number_of_edges() print "" indegreeSequenceOrig = getInDegreeSeq(Gorig) indegreeSequenceRegen = getInDegreeSeq(Gregen) outdegreeSequenceOrig = getOutDegreeSeq(Gorig) outdegreeSequenceRegen = getOutDegreeSeq(Gregen) avInDegree = [np.mean(indegreeSequenceOrig), np.mean(indegreeSequenceRegen)] trans = [nx.transitivity(Gorig), nx.transitivity(Gregen)] avShortedPathLength = [nx.average_shortest_path_length(Gorig), nx.average_shortest_path_length(Gregen)] degreePearson = [nx.degree_pearson_correlation_coefficient(Gorig), nx.degree_pearson_correlation_coefficient(Gregen)] print "average in-degree", avInDegree print "transitivity", trans print "average shortest path", avShortedPathLength print "degree pearson", degreePearson
def creationVecteur (G):
v={}
# Adding nodes
nn = nx.number_of_nodes(G)
v["numNodes"]=nn
# Adding edges
ne = nx.number_of_edges(G)
v["numEdges"]=ne
# Adding cyclomatic number
c=nx.number_connected_components(G)
cyclo = ne-nn+c
v["numCycles"]=cyclo
# Adding link density
if nn==1:
linkdensity="?"
else:
linkdensity = 2*ne/((nn-1)*nn)
v["linkDensity"]=linkdensity
# Adding average degree
avgdegree = 2*ne/nn
v["avgDegree"]=avgdegree
# Adding number of leaves
nl = numberLeaves(G)
v["numLeafs"]=nl
# Adding histogram of the nodes degree
v["histDegree0"]=0
v["histDegree1"]=0
v["histDegree2"]=0
v["histDegree3"]=0
v["histDegree4"]=0
histDegree=nx.degree_histogram(G)
v["histDegree0"]=histDegree[0]
if len(histDegree)>1:
v["histDegree1"]=histDegree[1]
if len(histDegree)>2:
v["histDegree2"]=histDegree[2]
if len(histDegree)>3:
v["histDegree3"]=histDegree[3]
if len(histDegree)>4:
v["histDegree4"]=histDegree[4]
# Adding sMetric
v["sMetric"]= metric(G)
# Adding graph energy
energ = graphEnergy (G)
v["graphEnergy"]=energ
# Adding average of the average neighboring degrees of all nodes
av = averageNeighDegree(G)
v["averageNeighDegree"]=av
# Adding average of closeness over all nodes
v["averageCloseness"]=average_closeness(G)
# Adding pearson coefficient for the degree sequence of all edges of the graph
pearson = nx.degree_pearson_correlation_coefficient(G)
if np.isnan(pearson):
pearson = 0
v["pearson"]=pearson
# Adding rich club metric for all nodes with a degree larger than 1
rc=richClub(G)
v["richClub"]=rc
# Adding algebraic connectivity, i.e. the second smallest eigenvalue of the Laplacian
algConnect = nx.laplacian_spectrum(G)
algConnect = list(algConnect)
algConnect = sorted(algConnect)
v["algConnect"]=algConnect[1]
# Adding diameter of the graph
if nx.is_connected(G):
diam = nx.diameter(G)
else:
diam="?"
v["diameter"]=diam
# Adding average shortest path
if nx.is_connected(G):
avgShortestPath=nx.average_shortest_path_length(G)
else:
avgShortestPath="?"
v["avgShortPath"]=avgShortestPath
# Adding graph radius
if nx.is_connected(G):
rad = nx.radius(G)
else:
rad="?"
v["graphRadius"]=rad
return v
def main(argv):
mode=argv[1]
path="net.net"
G=nx.read_pajek(path)
G=nx.Graph(G)
#-------------1--------------------------
Nnodes = G.number_of_nodes()
Nedges = G.number_of_edges()
degree=list(G.degree().values())
meandeg=0
for x in degree:
meandeg+=x
meandeg=meandeg/float(Nnodes)
if mode=="1":
print "number of nodes: ", Nnodes
print "number of links: ",Nedges
print "average degree: ", meandeg
plt.title("degree distribution")
plt.hist(degree)
#------------------------------------------------
#------------------2---------------------------
clustering=list(nx.clustering(G).values())
ave_cluster=nx.average_clustering(G)
if mode=="2":
print "average clustering: ",ave_cluster
print "-------------------------"
print "-----ER-Network--------------"
print "average degree: ", 2*Nedges/float(Nnodes)
print "-------------------------"
plt.title("clustering distribution")
plt.bar(np.linspace(0,18,19),clustering)
cluster_degree=[]
i=0
for x in degree:
if x > 1:
cluster_degree.append(x)
else:
clustering.pop(i)
i+=1
if mode == "3":
plt.title("degree over clustering coefficient")
plt.plot(clustering,cluster_degree,'o')
#-----------------4---------------------
neighbours=list(nx.k_nearest_neighbors(G).values())
if mode=="4":
print("average neares neighbour degree: ",sum(neighbours)/float(Nnodes))
#------------------5---------------------------
r=nx.degree_pearson_correlation_coefficient(G)
if mode=="5":
print("r: ",r)
#-------------------6-------------------------
eig_cent=list(nx.eigenvector_centrality(G).values())
eig_top=sorted(range(len(eig_cent)), key=lambda i:eig_cent[i])[-7:]
deg_top=sorted(range(len(degree)), key=lambda i:degree[i])[-7:]
if mode=="6":
print("degree top 7:",deg_top)
print("eigenvector centrality top 7: ", eig_top)
#-----------------7--------------------
pagerank_1=list(nx.pagerank(G,alpha=0.1).values())
pagerank_2=list(nx.pagerank(G,alpha=0.85).values())
pagerank_3=list(nx.pagerank(G,alpha=0.99).values())
if mode=="7":
plt.plot(range(Nnodes),pagerank_1,'r')
plt.plot(range(Nnodes),pagerank_2,'g')
plt.plot(range(Nnodes),pagerank_3,'y')
if mode=="8":
Gcc=sorted(nx.connected_component_subgraphs(G), key = len, reverse=True)[0]
pos=nx.spring_layout(Gcc)
nx.draw_networkx_nodes(Gcc,pos,node_size=20)
nx.draw_networkx_edges(Gcc,pos,alpha=0.4)
plt.show()
else: newGraph = nx.Graph() newGraph.add_nodes_from(graph) for edge in graph.edges(): newGraph.add_edge( edge[0], edge[1] ) graph = newGraph print "Checking Network Type *****************************************************\n\n" graphType = graph.is_directed() print "Calculating Pearson Correlation Coefficient on Degree-Degree Associativity \n\n" if graphType: degreeAssoc = nx.degree_pearson_correlation_coefficient(graph,x='in',y='out') else: degreeAssoc = nx.degree_pearson_correlation_coefficient(graph) print "Creating Adjacency Matrix Plots *******************************************\n\n" plt.hold(True) for edge in graph.edges_iter(): plt.plot(edge[0],edge[1], 'bo') plt.title( graphName + " Adjacency Matrix Plot" ) plt.show() plt.hold(False) print "Creating Network plot *****************************************************\n\n" if graphName == 'Dolphin Social' or graphName == 'Karate Social' or graphName == 'Political Books':
def test_degree_assortativity_multigraph(self):
r=nx.degree_pearson_correlation_coefficient(self.M)
npt.assert_almost_equal(r,-1.0/7.0,decimal=4)
def test_degree_assortativity_directed(self):
r=nx.degree_pearson_correlation_coefficient(self.D)
npt.assert_almost_equal(r,-0.57735,decimal=4)
"""
Plot distribution of counts for session lengths
"""
# plt.hist(user_df.session_length, list(range(1, 200)), weights=user_df.user_cnt); plt.show()
G = session_transition_graph(log)
assert(G.number_of_nodes() == 14457)
assert(G.number_of_edges() == 27315)
"""
Plot graph of user sessions parcours
"""
# pos = nx.spring_layout(G); nx.draw_networkx(G, pos, with_labels=False, node_size=1); plt.show()
print("degree_assortativity_coefficient %2.2f" % nx.degree_assortativity_coefficient(G))
print("degree_pearson_correlation_coefficient %2.2f" % nx.degree_pearson_correlation_coefficient(G))
assert(not nx.is_connected(G))
assert(nx.number_connected_components(G) == 171)
counter = Counter([c.number_of_edges() for c in nx.connected_component_subgraphs(G)])
print(counter)
# Counter({1: 141, 2: 19, 3: 4, 5: 2, 6: 2, 4: 1, 27085: 1, 13: 1})
large_graphs = [c for c in nx.connected_component_subgraphs(G) if c.number_of_edges() > 20]
largest_graph = large_graphs[0]
#nx.write_gexf(largest_graph, './model/user_sessions.gexf')
colors = ['r' if 'label' in d and d['label'] == 1 else 'b' for n, d in largest_graph.nodes_iter(data=True)]
sizes = [50 if 'label' in d and d['label'] == 1 else 1 for n, d in largest_graph.nodes_iter(data=True)]
#pos = nx.spring_layout(largest_graph); nx.draw_networkx(largest_graph, pos, with_labels=False, colors=colors, node_size=sizes); plt.show()
def neighbour_assortativity(calculate):
nodes_degree = G.degree()
degrees = set(map(lambda n: nodes_degree[n], nodes_degree))
result = {}
for degree in degrees:
neighbors_d = neighbors_degree([node for node, node_degree in nodes_degree.items() if node_degree == degree])
if len(neighbors_d) == 0:
calculation = 0
else:
calculation = calculate(neighbors_d)
result.update({degree: calculation})
return result
print("Pearson: " + str(nx.degree_pearson_correlation_coefficient(G)))
print('')
# Filtracja odstających wierzchołków
G.remove_nodes_from([k for k, v in G.degree().items() if v > 500])
print("Filtracja grafu")
print("")
print("Pearson: " + str(nx.degree_pearson_correlation_coefficient(G)))
print('')
# Wyświetl wykres średniej stopnia sąsiedztwa
val = neighbour_assortativity(statistics.mean)
plt.plot(list(map(lambda i: i[0], val.items())), list(map(lambda i: i[1], val.items())), 'ro', numpy.arange(0, 100),
numpy.arange(0, 100))
plt.axis([0, 150, 0, 40])
def calculatePearsonCorrelationCoefficient(self):
return nx.degree_pearson_correlation_coefficient(self.amazonGraph)
def test_degree_assortativity_undirected(self):
r=nx.degree_pearson_correlation_coefficient(self.P4)
npt.assert_almost_equal(r,-1.0/2,decimal=4)
