def calc_graph_measures(data_matrix, thresh=0):
from networkx import eccentricity
from networkx.algorithms.efficiency import global_efficiency
from networkx.algorithms.shortest_paths.generic import average_shortest_path_length
from networkx.algorithms.centrality import betweenness_centrality
from networkx.algorithms.cluster import average_clustering
from networkx.algorithms.community.modularity_max import greedy_modularity_communities
from networkx.algorithms.community.quality import performance
def _avg_values(results):
values = []
if isinstance(results, dict):
for k in results:
values.append(results[k])
elif isinstance(results, list):
for tup in results:
values.append(tup[1])
return np.mean(values)
below_thresh_indices = np.abs(data_matrix) < thresh
data_matrix[below_thresh_indices] = 0
if isinstance(data_matrix, np.ndarray):
graph = networkx.convert_matrix.from_numpy_matrix(np.real(data_matrix))
if isinstance(data_matrix, pd.DataFrame):
graph = networkx.convert_matrix.from_pandas_adjacency(data_matrix)
degree = list(graph.degree)
global_eff = global_efficiency(graph)
b_central = betweenness_centrality(graph)
modularity = performance(graph, greedy_modularity_communities(graph))
try:
ecc = eccentricity(graph)
except networkx.exception.NetworkXError:
ecc = [(0, 0)]
try:
clust = average_clustering(graph)
except networkx.exception.NetworkXError:
clust = 0
try:
char_path = average_shortest_path_length(graph)
except networkx.exception.NetworkXError:
char_path = 0
graph_dict = {'degree': _avg_values(degree),
'eccentricity': _avg_values(ecc),
'global_efficiency': global_eff,
'characteristic_path_length': char_path,
'betweenness_centrality': _avg_values(b_central),
'clustering_coefficient': clust,
'modularity': modularity}
return graph_dict
def network_structure_calculations(sn):
g = sn.g
_transitivity = transitivity(g)
_average_clustering = average_clustering(g)
size_biggest_component = -1
connected_components = 0
ave_short_path_biggest = -1
for sg in nx.connected_component_subgraphs(g, False):
connected_components += 1
if len(sg) > size_biggest_component:
size_biggest_component = len(sg)
ave_short_path_biggest = average_shortest_path_length(sg)
return (_transitivity,_average_clustering,
connected_components, size_biggest_component,
ave_short_path_biggest)
def backbone_summary(bb_network, timepoint_mob, alpha):
og_network = od_graph(timepoint_mob)
bb_journeys = ['_'.join(t) for t in bb_network.edges()]
og_journeys = ['_'.join(t) for t in og_network.edges()]
n_bb_edges = len(bb_journeys)
n_og_edges = len(og_journeys)
og_flow = timepoint_mob['n_crisis'].sum()
bb_flow = timepoint_mob.loc[
[x in bb_journeys for x in timepoint_mob['journey']],
'n_crisis'].sum()
return ({
'alpha':
alpha,
'n_og_edges':
n_og_edges,
'n_bb_edges':
n_bb_edges,
'edge_ratio':
n_bb_edges / n_og_edges,
'og_flow':
og_flow,
'bb_flow':
bb_flow,
'flow_ratio':
bb_flow / og_flow,
'date':
timepoint_mob['date'].unique()[0],
'clustering_coefficient':
average_clustering(bb_network),
'degree_sequence':
sorted([d for n, d in bb_network.degree()], reverse=True)
})
def getAverageClusteringCoefficient(self) -> float:
"""
"""
return average_clustering(self.graph)
def ver_medidas(G):
print(function.info(G))
"""
Numero minimo de nodos que deben ser removidos para desconectar G
"""
print("Numero minimo de nodos que deben ser removidos para desconectar G :"+str(approximation.node_connectivity(G)))
"""
average clustering coefficient of G.
"""
print("average clustering coefficient of G: "+str(approximation.average_clustering(G)))
"""
Densidad de un Grafo
"""
print("Densidad de G: "+str(function.density(G)))
"""
Assortativity measures the similarity of connections in
the graph with respect to the node degree.
Valores positivos de r indican que existe una correlacion entre nodos
con grado similar, mientras que un valor negativo indica
correlaciones entre nodos de diferente grado
"""
print("degree assortativity:"+str(assortativity.degree_assortativity_coefficient(G)))
"""
Assortativity measures the similarity of connections
in the graph with respect to the given attribute.
"""
print("assortativity for node attributes: "+str(assortativity.attribute_assortativity_coefficient(G,"crime")))
"""
Grado promedio vecindad
"""
plt.plot(assortativity.average_neighbor_degree(G).values())
plt.title("Grado promedio vecindad")
plt.xlabel("Nodo")
plt.ylabel("Grado")
plt.show();
"""
Grado de Centralidad de cada nodo
"""
plt.plot(centrality.degree_centrality(G).values())
plt.title("Grado de centralidad")
plt.xlabel("Nodo")
plt.ylabel("Centralidad")
plt.show();
"""
Calcular el coeficiente de agrupamiento para nodos
"""
plt.plot(cluster.clustering(G).values())
plt.title("coeficiente de agrupamiento")
plt.xlabel("Nodo")
plt.show();
"""
Media coeficiente de Agrupamiento
"""
print("Coeficiente de agrupamiento de G:"+str(cluster.average_clustering(G)))
"""
Centro del grafo
El centro de un grafo G es el subgrafo inducido por el
conjunto de vertices de excentricidad minima.
La excentricidad de v in V se define como la
distancia maxima desde v a cualquier otro vertice del
grafo G siguiendo caminos de longitud minima.
"""
print("Centro de G:"+ str(distance_measures.center(G)))
"""
Diametro de un grafo
The diameter is the maximum eccentricity.
"""
print("Diametro de G:"+str(distance_measures.diameter(G)))
"""
Excentricidad de cada Nodo
The eccentricity of a node v is the maximum distance
from v to all other nodes in G.
"""
plt.plot(distance_measures.eccentricity(G).values())
plt.title("Excentricidad de cada Nodo")
plt.xlabel("Nodo")
plt.show();
"""
Periferia
The periphery is the set of nodes with eccentricity equal to the diameter.
"""
print("Periferia de G:")
print(distance_measures.periphery(G))
"""
Radio
The radius is the minimum eccentricity.
"""
print("Radio de G:"+str(distance_measures.radius(G)))
"""
PageRank calcula una clasificacion de los nodos
en el grafico G en funcion de la estructura de
los enlaces entrantes. Originalmente fue disenado
como un algoritmo para clasificar paginas web.
"""
plt.plot(link_analysis.pagerank_alg.pagerank(G).values())
plt.title("Puntaje de cada Nodo")
plt.xlabel("Nodo")
plt.show();
"""
Coeficiente de Small World.
A graph is commonly classified as small-world if sigma>1.
"""
print("Coeficiente de Small World: " + str(smallworld.sigma(G)))
"""
The small-world coefficient (omega) ranges between -1 and 1.
Values close to 0 means the G features small-world characteristics.
Values close to -1 means G has a lattice shape whereas values close
to 1 means G is a random graph.
"""
print("Omega coeficiente: "+str(smallworld.omega(G)))
def page_rank(g):
# return gt_stats.vertex_hist(g, gt.pagerank(g))
return gt.pagerank(g).get_array()
def variance(g):
degree_hist = gt_stats.vertex_hist(g, 'total')[0] / g.num_vertices()
second_m = np.sum(degree_hist * (np.arange(len(degree_hist)) ** 2))
return second_m - avg_degree(g) ** 2
if __name__ == '__main__':
nx_g = barabasi_albert_graph(int(1e3), 2)
nx_apl = average_shortest_path_length(nx_g)
nx_ad = 2 * nx_g.number_of_edges() / nx_g.number_of_nodes()
nx_gcc = transitivity(nx_g)
nx_lcc = average_clustering(nx_g)
nx_md = len(degree_histogram(nx_g)) - 1
nx_drogc = max(connected_component_subgraphs(nx_g), key=len).number_of_nodes() / nx_g.number_of_nodes()
second_m = np.sum(np.array(degree_histogram(nx_g)) * (np.arange(len(degree_histogram(nx_g))) ** 2))
nx_v = math.sqrt(second_m - nx_ad ** 2)
nx_ap = degree_pearson_correlation_coefficient(nx_g)
nx_aknn = np.flip(np.array(
[it[1] for it in sorted(
average_degree_connectivity(nx_g).items(), reverse=True
)]
))
nx_dh = np.array(degree_histogram(nx_g)) / nx_g.number_of_nodes()
nx_cdh = np.flip(np.flip(
(np.array(degree_histogram(nx_g)) / nx_g.number_of_nodes())
, 0
def average_clustering(graph: nx.Graph, approximate=True):
# only for undirected graphs
if approximate:
return approximation.average_clustering(graph)
return cluster.average_clustering(graph)
def compute_directed_graph_metrics(G):
assert type(G) is nx.DiGraph
n_edges = len(G.edges)
# in & out degree stats
in_degrees = np.array([n for _, n in G.in_degree()])
out_degrees = np.array([n for _, n in G.out_degree()])
in_degrees_k_freq = np.unique(in_degrees, return_counts=True)[1]
out_degrees_k_freq = np.unique(out_degrees, return_counts=True)[1]
out_in_degrees_corr = numeric_attribute_correlation(
G, dict(G.out_degree), dict(G.in_degree))
# dyad metrics
dyad_freq = dyadic_census(G)
dyad_metrics = compute_dyad_metrics(dyad_freq)
# reciprocity
reciprocity = None
if n_edges > 0:
# based on networkx definition
reciprocity = 2 * dyad_freq["2"] / (dyad_freq["1"] +
2 * dyad_freq["2"])
# clustering
global_clustering = transitivity(G)
local_clustering_mean = average_clustering(G)
# fraction of connected node pairs (any path len)
f_connected_node_pairs = fraction_of_connected_node_pairs(G)
# centralization
cent_metrics = centralization_metrics(G, prefix="_di")
metrics = {
"n_edges_di":
len(G.edges),
"density_di":
density(G),
"reciprocity":
reciprocity,
# in_degree
"in_degrees_mean":
safe(np.mean, in_degrees),
"in_degrees_var":
safe(np.var, in_degrees),
"in_degrees_hidx":
safe(h_index, in_degrees),
"in_degrees_gini":
safe(gini, in_degrees + eps),
"in_degrees_f0":
safe(np.mean, (in_degrees == 0)),
"in_degrees_pk_ent":
entropy(in_degrees_k_freq),
"in_degrees_pk_gini":
gini(in_degrees_k_freq),
# out_degree
"out_degrees_mean":
safe(np.mean, out_degrees),
"out_degrees_var":
safe(np.var, out_degrees),
"out_degrees_hidx":
safe(h_index, out_degrees),
"out_degrees_gini":
safe(gini, out_degrees + eps),
"out_degrees_f0":
safe(np.mean, (out_degrees == 0)),
"out_degrees_pk_ent":
entropy(out_degrees_k_freq),
"out_degrees_pk_gini":
gini(out_degrees_k_freq),
# degree assortativity
"out_in_degrees_corr":
out_in_degrees_corr,
# dyad metric
**dyad_metrics,
# fraction of connected node pairs with path of any length
"f_connected_node_pairs_di":
f_connected_node_pairs,
# clustering coefficients
"global_clustering_di":
global_clustering,
"local_clustering_mean_di":
local_clustering_mean,
# centralization
**cent_metrics
}
return metrics
def compute_undirected_graph_metrics(G):
assert type(G) is nx.Graph
# degrees stats
degrees = np.array([i for _, i in G.degree])
degrees_k_freq = np.unique(degrees, return_counts=True)[1]
degrees_corr = numeric_attribute_correlation(G, dict(G.degree),
dict(G.degree))
# clustering
global_clustering = transitivity(G)
local_clustering_mean = average_clustering(G)
# fraction of connected node pairs (any path len)
f_connected_node_pairs = fraction_of_connected_node_pairs(G)
# centralization
cent_metrics = centralization_metrics(G, prefix="_ud")
# modularity
modularity_metrics = compute_modularity_metrics(G)
# largest CC
CC1_nodes = max(connected_components(G), key=len)
CC1 = G.subgraph(CC1_nodes).copy()
f_CC1_nodes = len(CC1) / len(G)
# algebraic_connectivity of the largest CC
algebraic_connectivity_CC1 = None
if len(CC1) > 2:
try:
algebraic_connectivity_CC1 = algebraic_connectivity(CC1, seed=0)
except:
algebraic_connectivity_CC1 = None
# connected components
CC = connected_components(G)
CC_sizes = np.array([len(cc_i) for cc_i in CC])
CC_metrics = {}
for k in CC_k_thresholds:
CC_metrics[f"n_CC_{k}"] = np.sum(CC_sizes >= k)
# k-core
k_core_metrics = {}
G_core_number = core_number(G)
for k in k_core_ks:
k_core_subgraph = k_core(G, k=k, core_number=G_core_number)
k_core_metrics[f"core_{k}_n_nodes"] = len(k_core_subgraph.nodes)
k_core_metrics[f"core_{k}_n_edges"] = len(k_core_subgraph.edges)
k_core_metrics[f"core_{k}_density"] = density(k_core_subgraph)
k_core_metrics[f"core_{k}_n_CC"] = len(
list(connected_components(k_core_subgraph)))
# k-truss
k_truss_metrics = {}
for k in k_truss_ks:
k_truss_subgraph = k_truss(G, k=k)
k_truss_metrics[f"truss_{k}_n_nodes"] = len(k_truss_subgraph.nodes)
k_truss_metrics[f"truss_{k}_n_edges"] = len(k_truss_subgraph.edges)
k_truss_metrics[f"truss_{k}_density"] = density(k_truss_subgraph)
k_truss_metrics[f"truss_{k}_n_CC"] = len(
list(connected_components(k_truss_subgraph)))
metrics = {
"n_edges_ud":
len(G.edges()),
"density_ud":
density(G),
# degree stats
"degrees_mean":
safe(np.mean, degrees),
"degrees_var":
safe(np.var, degrees),
"degrees_hidx":
safe(h_index, degrees),
"degrees_gini":
safe(gini, degrees + eps),
"degrees_f0":
safe(np.mean, (degrees == 0)),
"degrees_corr":
degrees_corr,
"degrees_pk_ent":
entropy(degrees_k_freq),
"degrees_pk_gini":
gini(degrees_k_freq),
# fraction of connected node pairs with path of any length
"f_connected_node_pairs_ud":
f_connected_node_pairs,
# clustering coefficients
"global_clustering_ud":
global_clustering,
"local_clustering_mean_ud":
local_clustering_mean,
# centralization
**cent_metrics,
# modularity
**modularity_metrics,
# fraction of nodes in the largest CC
"f_CC1_nodes":
f_CC1_nodes,
# algebraic connectivity of the largest CC
"algebraic_connectivity_CC1":
algebraic_connectivity_CC1,
# connected components
**CC_metrics,
# k-core
**k_core_metrics,
# k-truss
**k_truss_metrics
}
return metrics
def cc(self ): return average_clustering( self._network )
