def computeFeatures(self, G, features_nx, features_nk):
if("effective_graph_resistance" in features_nx or "nb_spanning_trees" in features_nx or "algebraic_connectivity" in features_nx):
if(self.params["verbose"]):
print("Computing laplacian_eigenvalues")
s = time.time()
self.eigenvalues["laplacian"] = np.real(nx.laplacian_spectrum(G))
if(self.params["verbose"]):
print("Finish laplacian_eigenvalues (%s)" % (timeFormat(time.time()-s)))
if("largest_eigenvalue" in features_nx or "symmetry_ratio" in features_nx or "natural_connectivity" in features_nx):
if(self.params["verbose"]):
print("Computing adjacency_eigenvalues")
s = time.time()
self.eigenvalues["adjacency"] = np.real(nx.adjacency_spectrum(G))
if(self.params["verbose"]):
print("Finish adjacency_eigenvalues (%s)" % (timeFormat(time.time()-s)))
if("weighted_spectrum_3" in features_nx or "weighted_spectrum_4" in features_nx):
if(self.params["verbose"]):
print("Computing normalized_laplacian_eigenvalues")
s = time.time()
self.eigenvalues["normalized_laplacian"] = np.real(nx.normalized_laplacian_spectrum(G))
if(self.params["verbose"]):
print("Finish normalized_laplacian_eigenvalues (%s)" % (timeFormat(time.time()-s)))
return(NodesFeatures.computeFeatures(self, G, features_nx, features_nk))
def detect(self):
"""detect the source with Dynamic Importance.
Returns:
@rtype:int
the detected source centrality
"""
self.reset_centrality()
adjacent_matrix = nx.adjacency_matrix(self.subgraph,
weight='weight').toarray()
eigenvalues = nx.adjacency_spectrum(self.subgraph, weight='weight')
eigenvalue_max = max(eigenvalues)
i = 0
for u in nx.nodes(self.subgraph):
adjacent_matrix_new = np.delete(adjacent_matrix, i,
0) # remove the row for node u
adjacent_matrix_new = np.delete(adjacent_matrix_new, i,
1) # remove the column for node u
eigenvalue_max_new = max(numpy.linalg.eigvals(adjacent_matrix_new))
nx.set_node_attributes(
self.subgraph, 'centrality',
{u: abs(eigenvalue_max - eigenvalue_max_new) / eigenvalue_max})
i += 1
return self.sort_nodes_by_centrality()
def largest_eigenvalue(G, nodes, eigenvalues=None):
adjacency_eigenvalues = None
if(not eigenvalues is None):
adjacency_eigenvalues = eigenvalues["adjacency"]
if(adjacency_eigenvalues is None):
adjacency_eigenvalues = np.real(nx.adjacency_spectrum(G))
return(np.float64(max(adjacency_eigenvalues)))
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 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 spectrum(self) -> np.ndarray:
"""Calculate and cache adjacency spectrum
(sorted in decreasing order).
"""
_spectrum = nx.adjacency_spectrum(self.G)
idx = _spectrum.argsort()[::-1]
return np.real(_spectrum[idx])
def graphEnergy (G):
energy=0
adjSpectre = nx.adjacency_spectrum(G)
for elt in adjSpectre:
if type(elt)!=complex:
energy+=abs(elt)
return energy
def main():
"""Interrograte the g560 graph.
"""
# g560 = make_symmetrical("/Users/rjs/dev/g560/embeddings/Gewirtz_graph_embeddings_4.svg")
# print("g560 (a.k.a GP-graph)")
g560 = make()
print("=====================")
print()
print("Number of nodes :", len(g560))
print("Number of edges :", len(g560.edges))
print("Diameter :", diameter(g560))
print("Radius :", radius(g560))
print("Average shortest path length :", average_shortest_path_length(g560))
#code.interact(local=locals())
eccentricities = Counter(eccentricity(g560).values())
print("Eccentricities")
for e in sorted(eccentricities):
print(" {} for {} nodes".format(e, eccentricities[e]))
print("Adjacency spectrum :", adjacency_spectrum(g560))
text_matrix = '\n'.join(''.join(" X"[g560.has_edge(u, v)] for v in g560.nodes) for u in g560.nodes)
print(text_matrix)
return 0
def graphEnergy(G):
energy = 0
adjSpectre = nx.adjacency_spectrum(G)
for elt in adjSpectre:
if type(elt) != complex:
energy += abs(elt)
return energy
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 natural_connectivity(G, nodes, eigenvalues=None):
adjacency_eigenvalues = None
if(not eigenvalues is None):
adjacency_eigenvalues = eigenvalues["adjacency"]
if(adjacency_eigenvalues is None):
adjacency_eigenvalues = np.real(nx.adjacency_spectrum(G))
nc = np.log(np.mean(np.exp(adjacency_eigenvalues)))
return(np.float64(nc))
def symmetry_ratio(G, nodes, eigenvalues=None):
adjacency_eigenvalues = None
if(not eigenvalues is None):
adjacency_eigenvalues = eigenvalues["adjacency"]
if(adjacency_eigenvalues is None):
adjacency_eigenvalues = np.real(nx.adjacency_spectrum(G))
r = len(np.unique(adjacency_eigenvalues))/(diameter(G, nodes)+1)
return(np.float64(r))
def sorted_adjacency_spectrum(
G: Union[nx.Graph, nx.MultiDiGraph]) -> np.ndarray:
"""Calculate adjacency spectrum of G
(sorted in decreasing order).
"""
_spectrum = nx.adjacency_spectrum(G)
idx = _spectrum.argsort()[::-1]
return np.real(_spectrum[idx])
def spectrum(aGraph):
spectrum = nx.adjacency_spectrum(aGraph)
l = len(spectrum)
freq = {}
for eigenvalue in spectrum:
freq[eigenvalue] = 0
for eigenvalue in spectrum:
freq[eigenvalue] += 1. / l
return freq
def AdjSpectrum(G):
"""
Calculate the eigenvalues of the adjacency matrix of a network
:param G: [networkx graph object] this is a networkx graph object
:return: [list] Returns a list of the real part of the eigenvalues of the adjacency matrix of G
"""
eig_temp = nx.adjacency_spectrum(G)
eig = [x.real for x in eig_temp]
return eig
def katz_strategy(graph, num_seeds, num_rounds):
highest_katz = []
lam_max = max(nx.adjacency_spectrum(graph))
node_values = nx.katz_centrality_numpy(graph, 1 / int(lam_max))
top_katz = sorted(node_values.items(),
key=operator.itemgetter(1),
reverse=True)[:num_seeds]
highest_katz = [i[0] for i in top_katz]
return (highest_katz * num_rounds)
def dynamical_importance(G):
"""Compute dynamical importance for G.
Ref: Restrepo, Ott, Hunt. Phys. Rev. Lett. 97, 094102 (2006)
"""
# spectrum of the original graph
eigvals = nx.adjacency_spectrum(G)
lambda0 = eigvals[0]
# Now, loop over all nodes in G, and for each, make a copy of G, remove
# that node, and compute the change in lambda.
nnod = G.number_of_nodes()
dyimp = np.empty(nnod,float)
for n in range(nnod):
gn = G.copy()
gn.remove_node(n)
lambda_n = nx.adjacency_spectrum(gn)[0]
dyimp[n] = lambda0 - lambda_n
# Final normalization
dyimp /= lambda0
return dyimp
def adj_eigenvalues(self):
"""
Returns the eigenvalues of the Adjacency matrix
:return:
"""
CP.print_none('Calculating eigenvalues of Adjacency Matrix')
adj_eigenvalues = nx.adjacency_spectrum(self.graph)
self.stats['adj_eigenvalues'] = adj_eigenvalues
return adj_eigenvalues
def dynamical_importance(graph):
"""Compute dynamical importance for graph.
Ref: Restrepo, Ott, Hunt. Phys. Rev. Lett. 97, 094102 (2006)
"""
# spectrum of the original graph
eigvals = nx.adjacency_spectrum(graph)
lambda0 = eigvals[0]
# Now, loop over all nodes in graph, and for each, make a copy of graph, remove
# that node, and compute the change in lambda.
nnod = graph.number_of_nodes()
dyimp = np.empty(nnod, float)
for n in range(nnod):
gn = graph.copy()
gn.remove_node(n)
lambda_n = nx.adjacency_spectrum(gn)[0]
dyimp[n] = lambda0 - lambda_n
# Final normalization
dyimp /= lambda0
return dyimp
def ct_stats():
# import the correlation network
H = bnx.build_nx()
close_ct_d = nx.closeness_centrality(H, distance="weight")
between_ct_d = nx.betweenness_centrality(H, weight="weight")
degree_ct_d = nx.degree_centrality(H)
katz_ct_d = nx.katz_centrality(
H,
weight="weight",
alpha=1 / (max(nx.adjacency_spectrum(H)) + 1),
beta=close_ct_d,
)
degree_ct_s = pd.Series(degree_ct_d).round(3)
close_ct_s = pd.Series(close_ct_d).round(3)
between_ct_s = pd.Series(between_ct_d).round(3)
katz_ct_s = pd.Series(katz_ct_d).round(3).astype("float")
close_ct_s.reset_index()
degree_ct_s.reset_index()
between_ct_s.reset_index()
katz_ct_s.reset_index()
degree_ct_df = (pd.DataFrame({
"stock_rank_1": degree_ct_s.index,
"degree": degree_ct_s.values
}).sort_values(by="degree", ascending=True).reset_index().drop("index",
axis=1))
close_ct_df = (pd.DataFrame({
"stock_rank_2": close_ct_s.index,
"closeness": close_ct_s.values
}).sort_values(by="closeness", ascending=True).reset_index().drop("index",
axis=1))
between_ct_df = (pd.DataFrame({
"stock_rank_3": between_ct_s.index,
"between": between_ct_s.values
}).sort_values(by="between", ascending=True).reset_index().drop("index",
axis=1))
katz_ct_df = (pd.DataFrame({
"stock_rank_4": katz_ct_s.index,
"katz": katz_ct_s.values
}).sort_values(by="katz", ascending=True).reset_index().drop("index",
axis=1))
df1 = degree_ct_df.join(close_ct_df)
df2 = df1.join(between_ct_df)
ct_df = df2.join(katz_ct_df)
return print(ct_df)
def create(degree, nodes):
# Returns a pair of PING
if degree > nodes - 1:
print("Error: Degree must be at most (nodes-1)")
return 0
if nodes % 2 != 0:
print("Error: Nodes must be a multiple of 2")
return 0
# node_list = range(nodes)
node_list = list(range(nodes))
# print(node_list)
while (True):
random.shuffle(node_list)
# Generate first PING graph
seed = 1
g1 = nx.random_regular_graph(degree, nodes, seed=seed)
g2 = copy.deepcopy(g1)
# for new_node in [nodes + 1, nodes + 2]:
g1.add_node(nodes + 1)
g2.add_node(nodes + 1)
for connect_to_node in node_list[:int(nodes / 2)]:
g1.add_edge(nodes + 1, connect_to_node)
for connect_to_node in node_list[int(nodes / 2):]:
g2.add_edge(nodes + 1, connect_to_node)
isomorphic = nx.is_isomorphic(g1, g2)
cospectral_dist = abs(
cosine(nx.adjacency_spectrum(g1), nx.adjacency_spectrum(g2)))
if not isomorphic and cospectral_dist < 0.01:
return g1, g2
if nx.is_isomorphic(g1, g2):
print(
"Error: Cannot create a PING for this combination of degree and nodes"
)
return 0
return g1, g2
def plot_spectral_adj(graph, filename, label, outpath):
""" plot spectral distribution of adjacency matrix"""
if not graph:
graph = nx.read_edgelist(filename)
spectrals = nx.adjacency_spectrum(graph)
spectrals_unique = np.unique(spectrals, return_counts=True)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.bar(spectrals_unique[0], spectrals_unique[1])
ax.set_title('spectral distribution of adjacency matrix')
ax.set_xlabel('eigenvalue')
ax.set_ylabel('frequency')
plt.savefig(outpath + label + '-spectral-adj.svg')
def preprocess_transition_probs(self):
'''
Preprocessing of transition probabilities for guiding the random walks.
'''
G = self.G
is_directed = self.is_directed
# Compute eigenvector centrality
#centrality = nx.eigenvector_centrality_numpy(G, weight='weight')
#perron = max(nx.adjacency_spectrum(G, 'weight'))
centrality = nx.eigenvector_centrality_numpy(G)
perron = max(nx.adjacency_spectrum(G))
#nx.draw(G)
alias_nodes = {}
for node in G.nodes():
#(centrality[nbr] / centrality[node])
#unnormalized_probs = [np.exp(-G[node][nbr]['weight'])*(centrality[nbr] / centrality[node])/perron for nbr in sorted(G.neighbors(node))]
#unnormalized_probs = [G[node][nbr]['weight']*(centrality[nbr] / centrality[node])/perron for nbr in sorted(G.neighbors(node))]
#unnormalized_probs = [(centrality[nbr] / centrality[node]) / perron for nbr in sorted(G.neighbors(node))]
unnormalized_probs = [
G[node][nbr]['weight'] for nbr in sorted(G.neighbors(node))
]
norm_const = sum(unnormalized_probs)
normalized_probs = [
float(u_prob) / norm_const for u_prob in unnormalized_probs
]
alias_nodes[node] = alias_setup(normalized_probs)
alias_edges = {}
triads = {}
# Add self-loops as edges
#for node in G.nodes():
# G.add_edge(node,node, weight=1.0)
if is_directed:
for edge in G.edges():
alias_edges[edge] = self.get_alias_edge(
edge[0], edge[1], centrality, perron)
else:
for edge in G.edges():
alias_edges[edge] = self.get_alias_edge(
edge[0], edge[1], centrality, perron)
alias_edges[(edge[1], edge[0])] = self.get_alias_edge(
edge[1], edge[0], centrality, perron)
self.alias_nodes = alias_nodes
self.alias_edges = alias_edges
return
def spectral_gap(self):
""" Spectral gap. Difference in the first and second eigenvalue of
the adj matrix
Returns
-------
spectral_gap : float
Spectral gap
"""
eig = nx.adjacency_spectrum(self)
spectral_gap = eig[0] - eig[1]
return spectral_gap.real
def get_center(self, tempGraph):
import math
# Kaza中心性
# G = nx.path_graph(4)
maxnumber = max(nx.adjacency_spectrum(tempGraph))
print(maxnumber)
phi = (1 + math.sqrt(5)) / 2.0 # largest eigenvalue of adj matrix
centrality = nx.katz_centrality(tempGraph, 1 / maxnumber - 0.01)
katz_centrality = sorted(centrality.items(),
key=lambda x: x[1],
reverse=True)
print('katz_centrality', katz_centrality)
self.center = katz_centrality[0][0]
def RBS(G, α=0.95, K=20):
'''Nx2K Feature Matrix with in & out paths of length `K` for every node. Column convergence is weighted by α.'''
A = nx.adjacency_matrix(G)
λ = np.max(nx.adjacency_spectrum(G))
β = np.real(α / λ)
n = len(G.nodes)
X = np.zeros((n, 2 * K))
for l in range(K):
# is it efficient to elevate the matrix to its power everytime?
X[:, l] = ((β * np.transpose(A))**(l + 1)).toarray().sum(axis=1)
X[:, l + K] = ((β * A)**(l + 1)).toarray().sum(axis=1)
return X
def create(degree, nodes):
# Returns a pair of PING
if degree > nodes - 1:
print "Error: Degree must be at most (nodes-1)"
return 0
if nodes % 2 != 0:
print "Error: Nodes must be a multiple of 2"
return 0
node_list = range(nodes)
# TODO: Find a better way to find a PING graph. Avoid using factorial or while(True)
# for _ in xrange(factorial(nodes)):
while (True):
random.shuffle(node_list)
# Generate first PING graph
seed = 1
g1 = nx.random_regular_graph(degree, nodes, seed=seed)
g2 = copy.deepcopy(g1)
# for new_node in [nodes + 1, nodes + 2]:
g1.add_node(nodes + 1)
g2.add_node(nodes + 1)
for connect_to_node in node_list[:nodes / 2]:
g1.add_edge(nodes + 1, connect_to_node)
for connect_to_node in node_list[nodes / 2:]:
g2.add_edge(nodes + 1, connect_to_node)
isomorphic = nx.is_isomorphic(g1, g2)
cospectral_dist = abs(
cosine(nx.adjacency_spectrum(g1), nx.adjacency_spectrum(g2)))
if not isomorphic and cospectral_dist < 0.01:
return g1, g2
if nx.is_isomorphic(g1, g2):
print "Error: Cannot create a PING for this combination of degree and nodes"
return 0
return g1, g2
def spectral_gap(self):
"""
Spectral gap. Difference in the first and second eigenvalue of
the adjacency matrix
Returns
-------
Spectral gap (float)
"""
eig = nx.adjacency_spectrum(self.to_undirected())
spectral_gap = abs(eig[0] - eig[1])
return spectral_gap.real
def getStatsA(graph):
getMean = lambda container: reduce(lambda i,j: i+j, container)/float(len(container))
getVariance = lambda container,mean: getMean(map(lambda x: pow(float(x)-mean, 2), container))
degreeNodes = graph.degree(graph.nodes()).values()
numOfNodes = len(graph.nodes())
numOfEdges = len(graph.edges())
graphDensity = 2*numOfEdges/float(numOfNodes*(numOfNodes-1))
averageDegree = getMean(degreeNodes)
varianceDegree = getVariance(degreeNodes, averageDegree)
print("Exercise 1:")
print("Number of nodes: ", str(numOfNodes))
print("Number of edges: ", str(numOfEdges))
print("Link density: ", str(graphDensity))
print("Average degree: ", str(averageDegree))
print("Variance degree: ", str(varianceDegree))
print("Exercise 2:")
assortativity = nx.degree_assortativity_coefficient(graph)
print("Exercise 3:")
print("Assortativity: ", str(assortativity), "Positive value indications that there is a correlation between nodes of similar degree," \
+ " while negative values indicate that there is a correlation between nodes of different degree.")
clusteringCoefficient = nx.average_clustering(graph)
print("Exercise 4:")
print("Average clustering coefficient: ", str(clusteringCoefficient))
averageHopCount = nx.average_shortest_path_length(graph)
diameter = nx.diameter(graph)
print("Exercise 5:")
print("Average hop count: ", str(averageHopCount))
print("Diameter:", str(diameter))
print("Exercise 6:")
adjacencySpectrum = sorted(nx.adjacency_spectrum(graph))
print("Exercise 7:")
print("Spectral radius (largest eigenvalue of the adjacency matrix):", str(adjacencySpectrum[-1]))
laplacianSpectrum = sorted(nx.laplacian_spectrum(graph))
print("Exercise 8:")
print("Algebraic connectivity (second largest eigenvalue of the laplacian matrix):", str(laplacianSpectrum[-2]))
def compute_features(G,checks=False):
""" Computes features of the graph. """
n = G.order()
nmeval = max(nx.adjacency_spectrum(G)) / n
comps = nx.number_connected_components(G)
mis = len(nx.maximal_independent_set(G)) / n
density = nx.density(G)
cc = nx.average_clustering(G)
tris = sum(nx.triangles(G).values()) / n
fracdeg1 = sum([len(G.neighbors(u)) == 1 for u in G]) / n
fracdeg0 = sum([len(G.neighbors(u)) == 0 for u in G]) / n
Gcc_list = list(nx.connected_component_subgraphs(G))
Gcc = Gcc_list[0]
ngcc = Gcc.order()
mgcc = Gcc.size()
return (nmeval,comps,mis,density,cc,tris,fracdeg1,fracdeg0,ngcc,mgcc)
def spectral_gap(G):
"""
Spectral gap
Difference in the first and second eigenvalue of the adjacency matrix
Parameters
----------
G: networkx MultiDiGraph
Graph
Returns
-------
Spectral gap (float)
"""
uG = G.to_undirected() # uses an undirected graph
eig = nx.adjacency_spectrum(uG)
spectral_gap = abs(eig[0] - eig[1])
return spectral_gap.real
def adjSpec(graphDic):
"""
for each base graph, we take all of its samples and canculate for each one its eigenvalue of its adjacency matrix
draws a graph were :
the vertical axis is the graphs (according their Ts),
the horizontal axis there are the eigenvalues.
each graph (usually) has more than one eigenvalue, which are represented by dots
:param graphDic: dictionary of a base graph with the samples ( key: T, value:graph )
:return:nothing. draws .
"""
t_list = np.array([])
eigenval_list = np.array([])
#for each t all its eigenvalues (eg) in a parallel list
for T in graphDic.keys():
for ev in np.nditer(nx.adjacency_spectrum(graphDic[T])):
t_list = np.append(t_list, T)
eigenval_list = np.append(eigenval_list, ev)
#draw
plt.plot(t_list, eigenval_list, 'ro')
plt.show
return 1
def do_centrality():
df = pd.read_table('../HumanNet_all_uniq.tsv',
sep='\t',
header=None,
names=['src', 'dest'],
index_col=None)
G = construct_graph(df, directed=False)
print "constructed graph..."
#all_nodes = nx.nodes(G)
#in_degree, out_degree, closeness, between = centrality(G)
#central_df = pd.DataFrame(index=all_nodes)
#central_df['closeness'] = pd.Series(closeness)
#central_df['between'] = pd.Series(between)
# largest eigenvalue of the adjacency matrix
central_df = pd.read_table('../HumanNet_centrality.tsv',
sep='\t',
header=0,
index_col=0)
max_eigenval = max(nx.adjacency_spectrum(G))
print "max eigen value", max_eigenval
central_df['katz'] = pd.Series(
nx.katz_centrality_numpy(G, alpha=1 / (max_eigenval.real + 1)))
central_df.to_csv('../HumanNet_centrality_updated.tsv', sep='\t')
def ComputeAdjacencyMatrixEigenvalues(self):
self.adjacencySpectrum = np.array(nx.adjacency_spectrum(self.G)).real
self.adjacencySpectrum.sort()
print "degree_assortativity_coefficient",'\t\t', nx.degree_assortativity_coefficient(graphs[g]) print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g]) #print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g]) print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g])) print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g])) print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False)) print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False)) #print "spectral_bipartivity",'\t\t', bipartite.spectral_bipartivity(graphs[g]) #print "node betweeness normalized",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=True,endpoints=False)) #print "edge betweeness normalized",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=True)) #print "node closeness_vitality",'\t\t\t', get_avg(nx.closeness_vitality(graphs[g])) #print "communicability_centrality",'\t\t', get_avg(nx.communicability_centrality(graphs[g])) #print "communicability_betweenness_centrality",'\t\t', get_avg(nx.communicability_betweenness_centrality(graphs[g])) #print "transitivity",'\t\t\t', round(nx.transitivity(graphs[g]),4) #print "laplacian_spectrum",'\t\t\n:', nx.laplacian_spectrum(graphs[g]) print "adjacency_spectrum",'\t\tMin 5 :', get_min(nx.adjacency_spectrum(graphs[g])) , "\t\tMax 5 :",get_max(nx.adjacency_spectrum(graphs[g])) print "laplacian_spectrum",'\t\tMin 5 :', get_min(nx.laplacian_spectrum(graphs[g])) , "\t\tMax 5 :",get_max(nx.laplacian_spectrum(graphs[g])) #print "normalized_laplacian_spectrum",'\t\tMin 5 :', get_min(numpy.real(normalized_laplacian_spectrum(graphs[g]))) , "\t\tMax 5 :",get_max(normalized_laplacian_spectrum(graphs[g])) #print "adjacency_spectrum",'\t\t\n', nx.adjacency_spectrum(graphs[g]) #print "laplacian_spectrum",'\t\t\n', nx.laplacian_spectrum(graphs[g]) #print "normalized_laplacian_spectrum",'\t\t\n', normalized_laplacian_spectrum(graphs[g]) ####print "adjacency_spectrum",'\t\t\n', numpy.around(numpy.real(nx.adjacency_spectrum(graphs[g])), decimals=4) ####print "laplacian_spectrum",'\t\t\n', numpy.around(numpy.real(nx.laplacian_spectrum(graphs[g])), decimals=4) ####print "normalized_laplacian_spectrum",'\t\t\n', numpy.around(numpy.real(normalized_laplacian_spectrum(graphs[g])), decimals=4) #statistics.pdf_to_textfile(numpy.real(numpy.around(nx.adjacency_spectrum(graphs[g]), decimals=2)).tolist(),g+"_adj_pdf.txt") # Write to a file #statistics.to_textfile(numpy.real(numpy.around(nx.adjacency_spectrum(graphs[g]), decimals=2)).tolist(),g+"_adj_pdf.txt") #statistics.pdf_to_textfile(numpy.real(numpy.around(nx.laplacian_spectrum(graphs[g]), decimals=2)).tolist(),g+"_pdf.txt") #statistics.cdf_to_textfile(numpy.real(numpy.around(nx.laplacian_spectrum(graphs[g]), decimals=2)).tolist(),g+"_cdf.txt") #statistics.pdf_to_textfile(numpy.real(numpy.around(normalized_laplacian_spectrum(graphs[g]), decimals=4)).tolist(),g+"_pdf.txt") #statistics.cdf_to_textfile(numpy.real(numpy.around(normalized_laplacian_spectrum(graphs[g]), decimals=4)).tolist(),g+"_cdf.txt")
def _compute(self, graph):
s = nx.adjacency_spectrum(graph)
return s
def test_adjacency_spectrum(self):
"Adjacency eigenvalues"
evals=numpy.array([-numpy.sqrt(2), 0, numpy.sqrt(2)])
e=sorted(nx.adjacency_spectrum(self.P))
assert_almost_equal(e,evals)
import scipy.sparse
import time
import sys
import os
attr_list = [ #Average degree
lambda g : np.mean([e for e in g.degree().values()]),
# Average eccentricity
lambda g : np.mean([i for i in nx.eccentricity(g).values()]),
# Average closeness centrality
lambda g : np.mean([e for e in nx.closeness_centrality(g).values()]),
# Percentage of isolated points (i.e., degree(v) = 1)
lambda g : float(len(np.where(np.array(nx.degree(g).values())==1)[0]))/g.order(),
# Spectral radius (i.e., largest AM eigenvalue)
lambda g : np.abs(nx.adjacency_spectrum(g))[0],
# Spectral trace (i.e., sum of abs. eigenvalues)
lambda g : np.sum(np.abs(nx.adjacency_spectrum(g))),
# Label entropy, as defined in [2]
lambda g : label_entropy([e[1]['type'] for e in g.nodes(data=True)]),
# Mixing coefficient of attributes
lambda g : np.linalg.det(nx.attribute_mixing_matrix(g,'type')),
# Avg. #vertics with eccentricity == radius (i.e., central points)
lambda g : np.mean(float(len(nx.center(g)))/g.order()),
# Link impurity, as defined in [2]
lambda g : link_impurity(g),
# Diameter := max(eccentricity)
lambda g : nx.diameter(g),
# Radius := min(eccentricity)
lambda g : nx.radius(g)]
def adja_spect(net):
return spectrum(nx.adjacency_spectrum(net),'adjacency')
