def __init__(self, g, features, n_machines, radius, activation, device):
super().__init__()
adj = nx.adj_matrix(g)
p = my.adj2p(sp.sparse.triu(adj))
adj = tf.cast(my.sparse_sp2tf(adj), tf.float32)
deg = tf.expand_dims(tf.sparse_reduce_sum(adj, 1), 1)
lg = nx.line_graph(g)
adj_lg = tf.cast(my.sparse_sp2tf(nx.adj_matrix(lg)), tf.float32)
deg_lg = tf.expand_dims(tf.sparse_reduce_sum(adj_lg, 1), 1)
for i, (m, n) in enumerate(zip(features[:-1], features[1:])):
setattr(
self, 'layer%d' % i,
GNNLayer(m, n, adj, deg, adj_lg, deg_lg, p, radius,
activation))
self.n_layers = i + 1
self.dense = tf.keras.layers.Dense(input_shape=(n, ), units=n_machines)
self.device = device
with tf.device(device):
x = deg
x -= tf.reduce_mean(x)
x /= tf.sqrt(tf.reduce_mean(tf.square(x)))
y = deg_lg
y -= tf.reduce_mean(y)
y /= tf.sqrt(tf.reduce_mean(tf.square(y)))
self.x, self.y = x, y
def features(G,G1):
A = nx.adj_matrix(G)
n = len(A)
A1 = nx.adj_matrix(G1)
D = A1[:n,:n]-A
pos = 0
neg = 0
iz = range(n)
jz = range(n)
shuffle(iz)
shuffle(jz)
for i in iz:
for j in jz:
if D[i,j] == 1:
pos +=1
train += [ [dot(A.A[i] , A.A[j]) / norm(A.A[i])* norm(A.A[j]),M[i,j],FF[i,j]]]
target += [D[i,j]]
elif neg < c:
neg +=1
train += [[dot(A.A[i] , A.A[j]) / norm(A.A[i])* norm(A.A[j]),M[i,j],FF[i,j]]]
target += [D[i,j]]
return train, target
def load_data(dataset_dir, dataset):
feats = np.load(dataset_dir + f"/{dataset}-feats.npy")
npz_path = Path(f'{dataset_dir}/{dataset}.npz')
if dataset in ['cora', 'citeseer', 'pubmed']:
# if not npz_path.exists():
G = json_graph.node_link_graph(
json.load(open(dataset_dir + "/{}-G.json".format(dataset))))
original_adj = nx.adj_matrix(G)
# sparse.save_npz(str(npz_path), original_adj)
labels = json.load(
open(dataset_dir + "/{}-class_map.json".format(dataset)))
train_ids = [
n for n in G.nodes()
if not G.nodes[n]['val'] and not G.nodes[n]['test']
]
test_ids = [n for n in G.nodes() if G.nodes[n]['test']]
train_labels = [labels[str(i)] for i in train_ids]
test_labels = [labels[str(i)] for i in test_ids]
labels = list(labels.values())
elif dataset in ['reddit', 'Amazon2M']:
if not npz_path.exists():
G = read_gpickle(dataset_dir + f'/{dataset}.gpickle')
original_adj = nx.adj_matrix(G)
sparse.save_npz(str(npz_path), original_adj)
else:
original_adj = sparse.load_npz(str(npz_path))
train_ids = np.load(dataset_dir + f'/{dataset}_train_data.npy')
test_ids = np.load(dataset_dir + f'/{dataset}_test_data.npy')
labels = np.load(dataset_dir + f'/{dataset}_labels.npy')
train_labels = labels[train_ids]
test_labels = labels[test_ids]
return original_adj, labels, train_ids, test_ids, train_labels, test_labels, feats
def compare(self, g1, g2, alpha, verbose=False):
"""Compute the kernel value (similarity) between two graphs.
Parameters
----------
g1 : networkx.Graph
First graph.
g2 : networkx.Graph
Second graph.
alpha : interger < 1
A rule of thumb for setting it is to take the largest power of 10
which is samller than 1/d^2, being d the largest degree in the
dataset of graphs.
Returns
-------
k : The similarity value between g1 and g2.
"""
am1 = nx.adj_matrix(g1)
am2 = nx.adj_matrix(g2)
x = np.zeros((len(am1),len(am2)))
A = self.smt_filter(x,am1,am2,alpha)
b = np.ones(len(am1)*len(am2))
tol = 1e-6
maxit = 20
pcg(A,b,x,tol,maxit)
return np.sum(x)
def hill_climbing(data, graph, **kwargs):
"""Hill Climbing optimization: a greedy exploration algorithm."""
nodelist = list(data.columns)
data = scale(data.as_matrix()).astype('float32')
tested_candidates = [nx.adj_matrix(graph, nodelist=nodelist, weight=None)]
best_score = parallel_graph_evaluation(data, tested_candidates[0].todense(), ** kwargs)
best_candidate = graph
can_improve = True
while can_improve:
can_improve = False
for (i, j) in best_candidate.edges():
test_graph = deepcopy(best_candidate)
test_graph.add_edge(j, i, weight=test_graph[i][j]['weight'])
test_graph.remove_edge(i, j)
tadjmat = nx.adj_matrix(test_graph, nodelist=nodelist, weight=None)
if (nx.is_directed_acyclic_graph(test_graph) and not any([(tadjmat != cand).nnz ==
0 for cand in tested_candidates])):
tested_candidates.append(tadjmat)
score = parallel_graph_evaluation(data, tadjmat.todense(), **kwargs)
if score < best_score:
can_improve = True
best_candidate = test_graph
best_score = score
break
return best_candidate
def hill_climbing(data, graph, **kwargs):
"""Hill Climbing optimization: a greedy exploration algorithm."""
if isinstance(data, th.utils.data.Dataset):
nodelist = data.get_names()
elif isinstance(data, pd.DataFrame):
nodelist = list(data.columns)
else:
raise TypeError('Data type not understood')
tested_candidates = [nx.adj_matrix(graph, nodelist=nodelist, weight=None)]
best_score = parallel_graph_evaluation(data,
tested_candidates[0].todense(),
**kwargs)
best_candidate = graph
can_improve = True
while can_improve:
can_improve = False
for (i, j) in best_candidate.edges():
test_graph = deepcopy(best_candidate)
test_graph.add_edge(j, i, weight=test_graph[i][j]['weight'])
test_graph.remove_edge(i, j)
tadjmat = nx.adj_matrix(test_graph, nodelist=nodelist, weight=None)
if (nx.is_directed_acyclic_graph(test_graph)
and not any([(tadjmat != cand).nnz == 0
for cand in tested_candidates])):
tested_candidates.append(tadjmat)
score = parallel_graph_evaluation(data, tadjmat.todense(),
**kwargs)
if score < best_score:
can_improve = True
best_candidate = test_graph
best_score = score
break
return best_candidate
def exploratory_hill_climbing(data,
graph,
proba=0.1,
decay=0.95,
max_trials=20,
**kwargs):
"""Hill climbing with a bit more exploration."""
tested_candidates = [nx.adj_matrix(graph, weight=None)]
best_score = parallel_graph_evaluation(data, graph, **kwargs)
best_candidate = graph
can_improve = True
while can_improve:
can_improve = False
for (i, j) in best_candidate.edges():
test_graph = deepcopy(best_candidate)
test_graph.remove_edge(i, j)
test_graph.add_edge(j, i)
tadjmat = nx.adj_matrix(test_graph, weight=None)
if (nx.is_directed_acyclic_graph(test_graph)
and tadjmat not in tested_candidates):
tested_candidates.append(tadjmat)
score = parallel_graph_evaluation(data, test_graph, **kwargs)
if score < best_score:
can_improve = True
best_candidate = test_graph
best_score = score
break
return best_candidate
def weighted_lambda_adjacency_diff(net1, net2, weighted='weight'):
"""
"""
net1_eigs = np.linalg.eigvalsh(
nx.adj_matrix(net1, weight=weighted).toarray())
net2_eigs = np.linalg.eigvalsh(
nx.adj_matrix(net2, weight=weighted).toarray())
return lambda_diff(net1_eigs, net2_eigs)
def GenerateGossipMatrix(NoAgents,Topology):
if(Topology == "Grid"):
Graph_Adj = nx.adj_matrix(nx.grid_graph([int(np.sqrt(NoAgents)),int(np.sqrt(NoAgents))],periodic=True)).toarray()
elif(Topology=="Cycle"):
Graph_Adj = nx.adj_matrix(nx.grid_graph([NoAgents],periodic=True)).toarray()
elif(Topology=="Expander"):
Graph_Adj = nx.adj_matrix(nx.margulis_gabber_galil_graph(int(np.sqrt(NoAgents)))).toarray()
Graph_Gossip = np.identity(NoAgents) - (np.diag(Graph_Adj.sum(axis=0)) - Graph_Adj )/(Graph_Adj.sum(axis=0).max() + 1)
if( np.sum(Graph_Gossip.sum(0) != 1.) > 0 or np.sum(Graph_Gossip.sum(1) != 1.) ):
print("Gossip Matrix not doubly stochastic! ")
return(Graph_Gossip)
def weighted_lambda_normalized_adjacency_diff(net1, net2, weighted='weight'):
adj1 = nx.adj_matrix(net1, weight=weighted).toarray()
d1 = np.diag(1 / np.sqrt(adj1.sum(axis=1)))
adj1 = d1.dot(adj1).dot(d1)
adj1[np.isnan(adj1)] = 0
adj2 = nx.adj_matrix(net2, weight=weighted).toarray()
d2 = np.diag(1 / np.sqrt(adj2.sum(axis=1)))
adj2 = d2.dot(adj2).dot(d2)
adj2[np.isnan(adj2)] = 0
net1_eigs = np.linalg.eigvalsh(adj1)
net2_eigs = np.linalg.eigvalsh(adj2)
return lambda_diff(net1_eigs, net2_eigs)
def magic_formula(gdict, wdict):
g = next(iter(gdict.values()))
a_shape = nx.adj_matrix(g).shape
ones = np.ones(shape=a_shape)
prob_no_contact = ones
for name, g in gdict.items():
a = nx.adj_matrix(g)
a = wdict[name] * a
prob_no_contact = np.multiply(prob_no_contact, (ones - a))
# probability of contact (whatever layer)
return 1 - prob_no_contact
def test_adjacency_matrix(self):
"Conversion to adjacency matrix"
npt.assert_equal(nx.adj_matrix(self.G).todense(), self.A)
npt.assert_equal(nx.adj_matrix(self.MG).todense(), self.A)
npt.assert_equal(nx.adj_matrix(self.MG2).todense(), self.MG2A)
npt.assert_equal(nx.adj_matrix(self.G, nodelist=[0, 1]).todense(), self.A[:2, :2])
npt.assert_equal(nx.adj_matrix(self.WG).todense(), self.WA)
npt.assert_equal(nx.adj_matrix(self.WG, weight=None).todense(), self.A)
npt.assert_equal(nx.adj_matrix(self.MG2, weight=None).todense(), self.MG2A)
npt.assert_equal(nx.adj_matrix(self.WG, weight='other').todense(), 0.6 * self.WA)
npt.assert_equal(nx.adj_matrix(self.no_edges_G, nodelist=[1, 3]).todense(), self.no_edges_A)
def test_adjacency_matrix(self):
"Conversion to adjacency matrix"
assert_equal(nx.adj_matrix(self.G).todense(), self.A)
assert_equal(nx.adj_matrix(self.MG).todense(), self.A)
assert_equal(nx.adj_matrix(self.MG2).todense(), self.MG2A)
assert_equal(nx.adj_matrix(self.G, nodelist=[0, 1]).todense(), self.A[:2, :2])
assert_equal(nx.adj_matrix(self.WG).todense(), self.WA)
assert_equal(nx.adj_matrix(self.WG, weight=None).todense(), self.A)
assert_equal(nx.adj_matrix(self.MG2, weight=None).todense(), self.MG2A)
assert_equal(nx.adj_matrix(self.WG, weight='other').todense(), 0.6 * self.WA)
assert_equal(nx.adj_matrix(self.no_edges_G, nodelist=[1, 3]).todense(), self.no_edges_A)
def get_sample(metrictype):
g = nx.erdos_renyi_graph(V, 0.2)
## node rank on the basis of egr/weighted spectrum
if metrictype == 'egr':
ranks = self.get_egrnoderank(g)
elif metrictype == 'weightedspectrum':
ranks = self.get_wghtspectnoderank(g)
# ranks = np.array([2 if ind >= int(0.75*V) else 1 if (ind > int(0.25*V)) and (ind < int(0.75*V)) else 0 for ind in temp_ranks])
ranks = (ranks - min(ranks)) / (max(ranks) - min(ranks))
# ranks = np.array([1/(1+np.exp(-1*ind)) for ind in temp_ranks])
# input node feature with degree
degfeat = (np.sum(nx.adj_matrix(g).todense(), axis=1))
x = np.reshape(np.arange(V), (V, 1))
Idenfeat = enc.fit_transform(x).toarray()
feat = np.concatenate((Idenfeat, degfeat), axis=1)
# return temp_input, ranks, feat, g
return ranks, feat, g
def test_from_numpy_matrix_type(self):
A = np.matrix([[1]])
G = nx.from_numpy_matrix(A)
assert_equal(type(G[0][0]['weight']), int)
A = np.matrix([[1]]).astype(np.float)
G = nx.from_numpy_matrix(A)
assert_equal(type(G[0][0]['weight']), float)
A = np.matrix([[1]]).astype(np.str)
G = nx.from_numpy_matrix(A)
assert_equal(type(G[0][0]['weight']), str)
A = np.matrix([[1]]).astype(np.bool)
G = nx.from_numpy_matrix(A)
assert_equal(type(G[0][0]['weight']), bool)
A = np.matrix([[1]]).astype(np.complex)
G = nx.from_numpy_matrix(A)
assert_equal(type(G[0][0]['weight']), complex)
A = np.matrix([[1]]).astype(np.object)
assert_raises(TypeError, nx.from_numpy_matrix, A)
G = nx.cycle_graph(3)
A = nx.adj_matrix(G).todense()
H = nx.from_numpy_matrix(A)
assert_true(all(type(m) == int and type(n) == int for m, n in H.edges()))
H = nx.from_numpy_array(A)
assert_true(all(type(m) == int and type(n) == int for m, n in H.edges()))
def main(argv):
graph_fn="./data/7.txt"
G = nx.Graph() #let's create the graph first
buildG(G, graph_fn)
print G.nodes()
print G.number_of_nodes()
n = G.number_of_nodes() #|V|
A = nx.adj_matrix(G) #adjacenct matrix
m_ = 0.0 #the weighted version for number of edges
for i in range(0,n):
for j in range(0,n):
m_ += A[i,j]
m_ = m_/2.0
print "m: %f" % m_
#calculate the weighted degree for each node
Orig_deg = {}
Orig_deg = UpdateDeg(A, G.nodes())
#run Newman alg
runGirvanNewman(G, Orig_deg, m_)
def cluster(matrix):
G = nx.Graph()
for i in xrange(len(matrix)):
for j in xrange(len(matrix)):
if matrix[i][j] != 0:
G.add_edge(i, j, weight=1/matrix[i][j])
n = G.number_of_nodes() #|V|
A = nx.adj_matrix(G)
m_ = 0.0 #the weighted version for number of edges
for i in range(0,n):
for j in range(0,n):
m_ += A[i,j]
m_ = m_/2.0
#calculate the weighted degree for each node
Orig_deg = {}
UpdateDeg(Orig_deg, A)
#let's find the best split of the graph
BestQ = 0.0
Q = 0.0
Bestcomps = None
while True:
CmtyGirvanNewmanStep(G)
Q = _GirvanNewmanGetModularity(G, Orig_deg);
if Q > BestQ:
BestQ = Q
Bestcomps = nx.connected_components(G) #Best Split
if G.number_of_edges() == 0:
break
return Bestcomps
def main(argv):
# graph_fn="./data/7.txt"
# G = nx.Graph() #let's create the graph first
# buildG(G, graph_fn)
k=5
G=nx.planted_partition_graph(k,10,0.8,0.02)
# G.clear()
bg(G)
from test import da
da(G)
print G.nodes()
print G.number_of_nodes()
g=G.copy()
n = G.number_of_nodes() #|V|
A = nx.adj_matrix(G) #adjacenct matrix
m_ = 0.0 #the weighted version for number of edges
for i in range(0,n):
for j in range(0,n):
m_ += A[i,j]
m_ = m_/2.0
print "m: %f" % m_
#calculate the weighted degree for each node
Orig_deg = {}
Orig_deg = UpdateDeg(A, G.nodes())
#run Newman alg
res=runGirvanNewman(G, Orig_deg, m_)
print res
shs(g,res)
def MCL_cluster(G,ex,r,tol,threshold):
"""
Computes a clustering of graph G using the MCL algorithm
with power parameter ex and inflation parameter r
The algorithm runs until the relative decrease in norm
is lower than tol or after 10,000 iterations
Returns an array whose values are greater than threshold
Leaves the graph G unchanged
"""
M = np.array(nx.adj_matrix(G.copy()))
M = inflate(M,1)
norm_old = 0
norm_new = np.linalg.norm(M)
it = -1
itermax = 10000
while it < itermax:
it += 1
norm_old = norm_new
M = M**ex
M = inflate(M,r)
norm_new = np.linalg.norm(M)
if __name__ == '__main__':
# debugging
print "iteration %s" %it
print "prop. decrease %s" %(abs(norm_old-norm_new)/norm_old)
if abs(norm_old-norm_new)/norm_old < tol:
print it
break
M[M < threshold] = 0
return M
def simulate_affiliation_dpe():
nrange = [400] #50*2**np.arange(3)
drange = np.arange(1,5)
embed = [Embed.dot_product_embed,
Embed.dot_product_embed_unscaled,
Embed.normalized_laplacian_embed,
Embed.normalized_laplacian_embed_scaled]
k = 2
p = .15
q = .1
for n in nrange:
G = rg.affiliation_model(n, k, p, q)
for d in drange:
print n*k,d,
for e in embed:
Embed.cluster_vertices_kmeans(G, e, d, k, 'kmeans')
print num_diffs_w_perms_graph(G, 'block', 'kmeans'),
print
plot.matshow(nx.adj_matrix(G))
plot.show()
def __init__(self, G):
'''
Creates a TwoClubProblem for the given graph.
Parameters
----------
G : networkx.Graph
The graph to find the 2-clubs of.
'''
n = nx.number_of_nodes(G)
self.drivers, _ = find_drivers_id(G)
Adj = nx.adj_matrix(G)
# Create the individual adjacency matrices
self.A = dict()
for i in xrange(n):
self.A[i] = Adj[i,:].transpose() * Adj[i,:]
# Connectivity matrix
C = Adj + Adj * Adj
del Adj
# First info vector
info = [0 for i in xrange(n)]
self.first_node = TwoClubNode(C, info, False)
def rand_spanning_tree(N, rand_weights=False):
'''Creats a random minimal tree on N nodes
Args:
N (int): Number of nodes
Returns:
A NxN numpy array representing the adjacency matrix of the graph.
'''
# Create Random Graph
A_rand = rand.rand(N, N)
G_rand = nx.Graph()
G_rand.add_nodes_from(xrange(N))
for i in xrange(N):
for j in xrange(i+1):
G_rand.add_edge(i, j, weight=A_rand[i, j])
# Find minimal spanning tree
spanning_tree = nx.minimum_spanning_tree(G_rand)
# Create adjacency matrix
final_graph = nx.adj_matrix(spanning_tree).toarray()
final_graph[final_graph > 0] = 1
# Randomize weights if requested
if rand_weights:
R = np.tril(rand.rand(N, N))
R = R + np.transpose(R)
final_graph = final_graph * R
return final_graph
def barabasi_albert(N, M, seed, verbose=True):
'''Create random graph using Barabási-Albert preferential attachment model.
A graph of N nodes is grown by attaching new nodes each with M edges that
are preferentially attached to existing nodes with high degree.
Args:
N (int):Number of nodes
M (int):Number of edges to attach from a new node to existing nodes
seed (int) Seed for random number generator
Returns:
The NxN adjacency matrix of the network as a numpy array.
'''
A_nx = nx.barabasi_albert_graph(N, M, seed=seed)
A = np.array(nx.adj_matrix(A_nx))
if verbose:
print('Barbasi-Albert Network Created: N = {N}, '
'Mean Degree = {deg}'.format(N=N, deg=meanDegree(A)))
return A
def main(argv):
# if len(argv) < 2:
# sys.stderr.write("Usage: %s <input graph>\n" % (argv[0],))
# return 1
# graph_fn = argv[1]
graph_fn = "/Users/yaya/Desktop/CNdata1.txt"
G = nx.Graph() #let's create the graph first
buildG(G, graph_fn, ',')
if _DEBUG_:
print ('G nodes:', G.nodes())
print ('G no of nodes:', G.number_of_nodes())
n = G.number_of_nodes() #|V|
A = nx.adj_matrix(G) #adjacenct matrix
m_ = 0.0 #the weighted version for number of edges
for i in range(0,n):
for j in range(0,n):
m_ += A[i,j]
m_ = m_/2.0
if _DEBUG_:
print ("m: %f" % m_)
#calculate the weighted degree for each node
Orig_deg = {}
Orig_deg = UpdateDeg(A, G.nodes())
#run Newman alg
runGirvanNewman(G, Orig_deg, m_)
def modularity_matrix(G,edec=None):
'''
Computes the 'master' modularity matrix, without subgraph corrections. The
modularity matrix is defined as
Q(i,j) = A(i,j) - (k_i*k_j)/sum(k_i)
where A is the adjacency matrix (weighted) of G and k_i are the (weighted)
node degrees.
INPUT
-------
G: networkx graph, required
input graph for which modularity matrix is desired
edec : string, optional
edge decorator (name for weights) in weighted graphs
OUTPUT:
Q : numpy array
Q will be of size len(G.nodes()) X len(G.nodes())
'''
# adjacency matrix piece (ordered according to G.nodes())
Q = nx.adj_matrix(G,weight=edec)
# degree-product portion (same order as adj_matrix!)
nodes = G.nodes()
ki = G.degree(weight=edec)
kvec = np.zeros((len(nodes),1))
for i in xrange(0,len(nodes)):
kvec[i] = ki[nodes[i]]
return Q - np.dot(kvec,kvec.T)/sum(ki.values())
def _generate_dependency_list(self):
""" Generates a dependency list for a list of graphs. Adds the
following attributes to the pipeline:
New attributes:
---------------
procs: list (N) of underlying interface elements to be
processed
proc_done: a boolean vector (N) signifying whether a process
has been executed
proc_pending: a boolean vector (N) signifying whether a
process is currently running.
Note: A process is finished only when both proc_done==True and
proc_pending==False
depidx: a boolean matrix (NxN) storing the dependency
structure accross processes. Process dependencies are derived
from each column.
"""
if not self._execgraph:
raise Exception('Execution graph has not been generated')
self.procs = self._execgraph.nodes()
self.depidx = nx.adj_matrix(self._execgraph).__array__()
self.proc_done = np.zeros(len(self.procs), dtype=bool)
self.proc_pending = np.zeros(len(self.procs), dtype=bool)
def orient_undirected_graph(self, data, graph, **kwargs):
"""Run PC on an undirected graph.
Args:
data (pandas.DataFrame): DataFrame containing the data
graph (networkx.Graph): Skeleton of the graph to orient
Returns:
networkx.DiGraph: Solution given by PC on the given skeleton.
"""
# Building setup w/ arguments.
self.arguments['{CITEST}'] = self.dir_CI_test[self.CI_test]
self.arguments['{METHOD_INDEP}'] = self.dir_method_indep[self.CI_test]
self.arguments['{DIRECTED}'] = 'TRUE'
self.arguments['{ALPHA}'] = str(self.alpha)
self.arguments['{NJOBS}'] = str(self.njobs)
self.arguments['{VERBOSE}'] = str(self.verbose).upper()
fe = DataFrame(nx.adj_matrix(graph, weight=None).todense())
fg = DataFrame(1 - fe.values)
results = self._run_pc(data,
fixedEdges=fe,
fixedGaps=fg,
verbose=self.verbose)
return nx.relabel_nodes(nx.DiGraph(results),
{idx: i
for idx, i in enumerate(data.columns)})
def generate_crescent_edges_graphs(n_graphs, n_nodes, p_edges, min_p_edges=None):
"""Creates a set of n graphs with a fixed n nodes and choice of
possible edges with crescent probability p.
"""
adj_matrix_dict = defaultdict()
if min_p_edges:
min_p_edges = math.log1p(n_nodes) / n_nodes
filename = 'edges_' + str(n_graphs) + 'G_' + str(n_nodes) + 'N'
filename += '_from_' + str(min_p_edges) + '_to_' + str(p_edges) + 'P'
j = (p_edges - min_p_edges) / n_graphs # p increment
p_edges = min_p_edges
for i in range(0, n_graphs):
G = nx.erdos_renyi_graph(n_nodes, p_edges)
if nx.is_connected(G):
adj_matrix_dict[p_edges] = nx.adj_matrix(G)
p_edges += j
write_to_file(adj_matrix_dict, filename + '.dat', BENCHMARKS_FILE_DIR)
return filename
def test_compute_ncut(epsilon=1e-8):
weights_small = [np.array([[12, -1.3],
[0, 7.4]]),
np.array([[-8.9, 0.15],
[0.23, -5.7]])]
adj_mat_small = weights_to_graph(weights_small).toarray()
clustering_small = [0, 1, 0, 1, 0, 1]
assert isclose(compute_ncut(adj_mat_small, clustering_small, epsilon),
0.09895, abs_tol=1e-3)
weights_big = [np.array([[5.4, 0.03, 0, 0],
[0, 0, -0.4, 5.5],
[-12, 0, 4.8, -0.07],
[0, 6.3, 0.001, 7]]),
np.array([[-13.3, -0.4, 6, 0.1],
[0.7, -8, 0, -5.8],
[7.4, 0.3, -15, 0],
[0, 0, 0, -12.3]])]
adj_mat_big = weights_to_graph(weights_big).toarray()
clustering_big = [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
assert isclose(compute_ncut(adj_mat_big, clustering_big, epsilon),
0.0372, abs_tol=1e-3)
# test on a random graph, and use networkx implementation
G = nx.generators.random_graphs.fast_gnp_random_graph(20, 0.8)
adj_mat = nx.adj_matrix(G)
assert isclose(nx.algorithms.cuts.normalized_cut_size(G,
list(G.nodes)[::2],
list(G.nodes)[1::2]),
compute_ncut(adj_mat, [0, 1] * 10, 0))
def MAWe(G):
"""Eigenvalue approximation of maximum average degree. This is conjectured
to be an upper bound on MAW.
"""
eigenvalues, eigenvectors = scipy.linalg.eig(nx.adj_matrix(G) )
MAWe = float(max(eigenvalues))
return MAWe
def get_neg_adj(self):
pos_G = nx.Graph()
pos_G.add_nodes_from(self.G.g.nodes())
pos_G.add_edges_from(self.G.poslist)
adj_pos = nx.adj_matrix(pos_G)
#print(adj_pos.todense())
return(adj_pos)
def adjacency_matrix(self, uname_order = None, rid_order = None):
"""
Get adjacency matrix between Neurons.
# Arguments
uname_order (list):
A list of the uname of neurons to order the rows and columns of the adjacency matrix.
If None, use rid_order. If rid_order is None, will sort uname for order.
rid_order (list):
A list of the rids of neurons to order the rows and columns of the adjacency matrix.
If None, use uname_order. if uname_order is None, will sort uname for order.
# Returns
M (numpy.ndarray):
A graph representing the connectivity of the neurons.
uname_oder (list):
A list of unames by which the rows and columns of M are ordered.
"""
if uname_order is None and rid_order is None:
order = sorted([(self.nodes[n]['uname'], n) for n in self.nodes()])
uname_order = [uname for uname, _ in order]
rid_order = [rid for _, rid in order]
elif uname_order is None:
# rid_order
uname_order = [self.nodes[n]['uname'] for n in rid_order]
else:
# uname_order
order_dict = {self.nodes[n]['uname']: n for n in self.nodes()}
rid_order = [order_dict[uname] for uname in uname_order]
M = nx.adj_matrix(self, nodelist = rid_order).todense()
return M, uname_order
def get_T(G):
''' Return diffusion operator of a graph.
The diffusion operator is defined as T = I - L, where L is the normalized
Laplacian.
Parameters
----------
G : NetworkX graph
Returns
-------
T : NumPy array
Ln : NumPy array
Normalized Laplacian of G.
Notes
-----
Computing the normalized laplacian by hand. It seems there are some
inconsistencies using nx.normalized_laplacian when G has selfloops.
'''
A = nx.adj_matrix(G, nodelist=sorted(G.nodes()))
D = np.array(np.sum(A,1)).flatten()
Disqrt = np.array(1 / np.sqrt(D))
Disqrt = np.diag(Disqrt)
L = np.diag(D) - A
Ln = np.dot(np.dot(Disqrt, L), Disqrt)
T = np.eye(len(G)) - Ln
T = (T + T.T) / 2 # Iron out numerical wrinkles
return T, L
def gn(g):
init_n = g.number_of_edges()
print("总共的边数(相当于两两比赛的总次数):", init_n) # 统计所有的边数 总共613 也就是613次比赛
if init_n == 0:
return None
# 简单的一个预处理
m = nx.adj_matrix(g) # 按第一列从小到大 整理我们的数据
m = m.sum() / 2 # 总的比赛数
init_deg = get_deg(g)
# print(init_deg) # {"队0": 打的次数, "队1": 打的次数, ...}
i = 1
while g.number_of_edges() > 420:
removing_based_on_betweeness(g)
# 迭代5词计算一下模块度
if i % 5 == 0:
print("迭代次数:{} 模块度的值:{} 边数:{}".format(i, get_modularity(g, init_deg, m), g.number_of_edges()))
i += 1
print("模块度最大: {}".format(get_modularity(g, init_deg, m)))
# 社团中止时的图
nx.draw_networkx(g)
plt.show()
return nx.connected_components(g)
def test_from_numpy_matrix_type(self):
A = np.matrix([[1]])
G = nx.from_numpy_matrix(A)
assert type(G[0][0]['weight']) == int
A = np.matrix([[1]]).astype(np.float)
G = nx.from_numpy_matrix(A)
assert type(G[0][0]['weight']) == float
A = np.matrix([[1]]).astype(np.str)
G = nx.from_numpy_matrix(A)
assert type(G[0][0]['weight']) == str
A = np.matrix([[1]]).astype(np.bool)
G = nx.from_numpy_matrix(A)
assert type(G[0][0]['weight']) == bool
A = np.matrix([[1]]).astype(np.complex)
G = nx.from_numpy_matrix(A)
assert type(G[0][0]['weight']) == complex
A = np.matrix([[1]]).astype(np.object)
pytest.raises(TypeError, nx.from_numpy_matrix, A)
G = nx.cycle_graph(3)
A = nx.adj_matrix(G).todense()
H = nx.from_numpy_matrix(A)
assert all(type(m) == int and type(n) == int for m, n in H.edges())
H = nx.from_numpy_array(A)
assert all(type(m) == int and type(n) == int for m, n in H.edges())
def convToMatrix(self, gList, vecMode=True):
"""
gList: list of normal graphs
vecMode: if false, unvectorized vals will be returned
return: (list of adjacency matrixes, list of node vectors)
"""
graphPropList = []
graphAdjList = []
#vectorize nodes for each node
for g in tqdm(gList):
for num, i in enumerate(g.nodes):
if vecMode == False:
newVector = self.getVector(g.nodes[i]["label"])
else:
newVector = g.nodes[i]["label"]
if num == 0:
nodePropList = newVector
else:
nodePropList = np.vstack((nodePropList, newVector))
graphPropList.append(np.array(nodePropList, dtype="float32"))
#adjacency matrices
graphAdjList.append(
np.array(nx.adj_matrix(g).todense(), dtype="float32"))
return graphPropList, graphAdjList
def helper_genie3(X, theta_true, tf_names=[], BEELINE=False): #_string
print('Running GENIE3 method', X.shape)
theta_true = theta_true.real
ex_matrix = pd.DataFrame(X)
if args.USE_TF_NAMES == 'yes' and len(tf_names) != 0:
tf_names = ['G' + str(n) for n in tf_names]
else:
tf_names = None
gene_names = ['G' + str(c) for c in ex_matrix.columns]
ex_matrix.columns = gene_names
network = genie3(expression_data=ex_matrix,
gene_names=gene_names,
tf_names=tf_names) #, verbose=True)
pred_edges = np.array(network[['TF', 'target', 'importance']])
G_pred = nx.Graph()
# G_pred.add_nodes_from(['G'+str(n) for n in range(args.D)])
G_pred.add_nodes_from(['G' + str(n) for n in range(len(gene_names))])
G_pred.add_weighted_edges_from(pred_edges)
# pred_theta = nx.adj_matrix(G_pred).todense() + np.eye(args.D)
pred_theta = nx.adj_matrix(G_pred).todense() + np.eye(len(gene_names))
recovery_metrics = report_metrics(np.array(theta_true),
np.array(pred_theta))
print(
'GENIE3: FDR, TPR, FPR, SHD, nnz_true, nnz_pred, precision, recall, Fb, aupr, auc'
)
print('GENIE3: Recovery of true theta: ', *np.around(recovery_metrics, 3))
res = list(recovery_metrics)
if BEELINE:
res = [list(recovery_metrics), pred_theta]
return res
def gen_adj(snippets,
pre='snippet',
suf='',
tt_ratio=0.8,
mode=None,
max_len=64,
w_mode='w'):
with open(pre + '_adj' + suf + '.txt', w_mode, newline='') as f:
wr = csv.writer(f)
G_u = G.to_undirected()
idx = 0
pivot = int(len(snippets) * tt_ratio)
for ts in snippets:
if mode == 'val':
if idx < pivot:
idx += 1
continue
else:
if idx > pivot:
break
else:
idx += 1
if mode == 'fc':
final = np.ones((max_len, max_len), dtype=int)
else:
adj = nx.adj_matrix(G_u.subgraph(ts)).todense()
final = np.zeros((max_len, max_len), dtype=int)
final[:adj.shape[0], :adj.shape[1]] = adj
final += np.eye(max_len, dtype=int)
for row in final.tolist():
wr.writerow(row)
wr.writerow([])
wr.writerow([])
def get_BASBM(sizes, p, m=2):
"""A stochastic block model where each block is a Barabasi Albert graph.
Args:
`sizes` (list): a list of ints describing the size of each block. Each
size must be larger than m+1.
`p`: (float or array): if an array then p[i][j] is the probability of connecting
a node from block i to block j. If a float then its the probability of connecting
nodes from different blocks.
`m`: (int): the barabasi albert hyper-parameter.
Returns:
A networkx graph.
"""
if isinstance(p, float) or isinstance(p, int):
p = p * np.ones((len(sizes), len(sizes)))
num_blocks = len(sizes)
blocks = []
for i in range(num_blocks):
block_row = []
for j in range(num_blocks):
if i == j:
block_row.append(
nx.adj_matrix(nx.barabasi_albert_graph(sizes[i],
m)).todense())
else:
block_row.append(
np.random.binomial(1, p[i][j], (sizes[i], sizes[j])))
blocks.append(block_row)
adj_matrix = np.block(blocks)
return nx.from_numpy_array(adj_matrix)
def edgefeat(g, norm=False, fil='ricci'):
"""
wrapper for edge_probability and ricciCurvature computation
:param g: graph
:param fil: edge_p/ricci/jaccard
:param whether normalize edge values or not
:return: gp, a dense numpy array of shape (n_node, n_node)
"""
g = nx.convert_node_labels_to_integers(g)
assert nx.is_connected(g)
adj_m = nx.adj_matrix(g).todense() # dense matrix
gp = np.zeros((len(g), len(g)))
try:
if fil == 'edge_p':
gp = np.array(smoother(adj_m, h=0.3))
gp = np.multiply(adj_m, gp)
elif fil == 'ricci':
g = ricciCurvature(g, alpha=0.5, weight='weight')
ricci_dict = nx.get_edge_attributes(g, 'ricciCurvature')
for u, v in ricci_dict.keys():
gp[u][v] = ricci_dict[(u, v)]
gp += gp.T
elif fil == 'jaccard':
jac_list = nx.jaccard_coefficient(g, g.edges(
)) # important since jaccard can also be defined on non edge
for u, v, jac in jac_list:
gp[u][v] = jac
gp += gp.T
except AssertionError:
print('Have not implemented fil %s. Treat as all zeros' % fil)
gp = np.zeros((len(g), len(g)))
assert (gp == gp.T).all()
if norm: gp = gp / float(max(abs(gp)))
return gp
def construct_train_graph(dataset):
train_pos, train_neg, test_pos, test_neg = get_train_test(dataset)
graph, train_neg_txt, test_pos_txt, test_neg_txt = [],[],[],[]
for i in range(len(train_pos[0])):
graph.append((train_pos[0][i],train_pos[1][i]))
train_neg_txt.append((train_neg[0][i],train_neg[1][i]))
with open(dataset[:-4]+'train_pos.txt','a') as file:
file.write("{}\n".format(graph))
file.close()
with open(dataset[:-4]+'train_neg.txt','a') as file:
file.write("{}\n".format(train_neg_txt))
file.close()
for i in range(len(test_pos[0])):
test_pos_txt.append((test_pos[0][i],test_pos[1][i]))
test_neg_txt.append((test_neg[0][i],test_neg[1][i]))
with open(dataset[:-4]+'test_pos.txt','a') as file:
file.write("{}\n".format(test_pos_txt))
file.close()
with open(dataset[:-4]+'test_neg.txt','a') as file:
file.write("{}\n".format(test_neg_txt))
file.close()
G = nx.Graph(graph)
adj_mat = nx.adj_matrix(G)
filename = 'new_'+dataset
scio.savemat(filename, {'network':adj_mat})
return
def get_matrix_jc(G):
## get all pairwise jaccard indexes
nodes = list(G.nodes())
adj = nx.adj_matrix(G)
shared_nei = adj * adj
d = shared_nei.diagonal()
## matrix i,j sum degree i,j
## jc = overlap / (i) + (j) - overlap
## the steps bellow get the denominator
a = np.tile(d,(d.shape[0],1))
a = a.T
b = np.tile(d,(d.shape[0],1))
sumk = a + b
t = shared_nei.todense()
denom = sumk - shared_nei
## jaccard
jc = t/denom
df = pd.DataFrame(jc)
df.columns = nodes
df.index = nodes
return(df)
def modularity(self):
"""
Compute the modularity.
Returns:
Numerical value of the modularity of the graph.
"""
g = self.gr
A = nx.adj_matrix(g)
degDict = nx.degree_centrality(g)
adjDict = {}
n = A.shape[0]
B = A.sum(axis=1)
for i in range(n):
adjDict[g.nodes()[i]] = B[i,0]
m = len(g.edges())
connComponents = nx.connected_components(g)
mod = 0
for c in connComponents:
edgesWithinCommunity = 0
randomEdges = 0
for u in c:
edgesWithinCommunity += adjDict[u]
randomEdges += degDict[u]
mod += (float(edgesWithinCommunity) - float(randomEdges * randomEdges)/float(2 * m))
mod = mod/float(2 * m)
return mod
def main(argv):
if len(argv) < 2:
sys.stderr.write("Usage: %s <input graph>\n" % (argv[0],))
return 1
graph_fn = argv[1]
G = nx.Graph() #let's create the graph first
buildG(G, graph_fn, ',')
print G.nodes()
print G.number_of_nodes()
n = G.number_of_nodes() #|V|
A = nx.adj_matrix(G) #adjacenct matrix
m_ = 0.0 #the weighted version for number of edges
for i in range(0,n):
for j in range(0,n):
m_ += A[i,j]
m_ = m_/2.0
print "m: %f" % m_
#calculate the weighted degree for each node
Orig_deg = {}
Orig_deg = UpdateDeg(A, G.nodes())
#run Newman alg
runGirvanNewman(G, Orig_deg, m_)
def generate_graph(n_vertex, p):
G = nx.erdos_renyi_graph(n_vertex, p)
matrix = nx.adj_matrix(G)
matrix = matrix.toarray()
vertex = len(matrix)
edges = 0
for line in matrix:
for val in line:
if val == 1:
edges += 1
edges = edges // 2
with open("test_" + str(n_vertex) + "_" + str(int(p * 10)) + ".txt",
"w") as f:
i = 0
j = 0
extra_edges = set({})
print(str(vertex) + " " + str(edges))
f.write(str(vertex) + " " + str(edges))
for line in matrix:
j = 0
for column in line:
if column == 1:
pair = (i, j)
if not pair in extra_edges:
f.write("\n")
f.write(str(i) + " " + str(j))
extra_edges.add((i, j))
extra_edges.add((j, i))
j += 1
i += 1
def generate_crescent_edges_graphs(n_graphs,
n_nodes,
p_edges,
min_p_edges=None):
"""Creates a set of n graphs with a fixed n nodes and choice of
possible edges with crescent probability p.
"""
adj_matrix_dict = defaultdict()
if min_p_edges:
min_p_edges = math.log1p(n_nodes) / n_nodes
filename = 'edges_' + str(n_graphs) + 'G_' + str(n_nodes) + 'N'
filename += '_from_' + str(min_p_edges) + '_to_' + str(p_edges) + 'P'
j = (p_edges - min_p_edges) / n_graphs # p increment
p_edges = min_p_edges
for i in range(0, n_graphs):
G = nx.erdos_renyi_graph(n_nodes, p_edges)
if nx.is_connected(G):
adj_matrix_dict[p_edges] = nx.adj_matrix(G)
p_edges += j
write_to_file(adj_matrix_dict, filename + '.dat', BENCHMARKS_FILE_DIR)
return filename
def adjacency_matrix(self) -> np.ndarray:
"""Converts the estimated structure ``_complete_graph`` to a boolean adjacency matrix representation.
:return: The adjacency matrix of the graph ``_complete_graph``
:rtype: numpy.ndArray
"""
return nx.adj_matrix(self._complete_graph, self._nodes).toarray().astype(bool)
def prune(net):
import networkx as nx
# removes the unconnected components
G = create_nx_from_network(net)
connected_component = G.subgraph(nx.connected_components(G)[0])
return UndirectedNetwork(connected_component.number_of_nodes(), nx.adj_matrix(connected_component))
def __init__(self,Gs,max_depth=10,max_node=1000,tree_num=8,normalize=True):
tree_info = get_graphs_tree_data(Gs,max_depth,K=tree_num)
self.adj_all = []
self.feature_all = []
self.tree_info = tree_info
self.label_all = []
self.max_node = max_node
self.feature_dim = len(Gs[0].node[0]['feat'])
for g in Gs:
adj = nx.adj_matrix(g).todense()
adj = np.array(adj)
if normalize:
sqrt_deg = np.diag(1.0 / np.sqrt(np.sum(adj, axis=0, dtype=float).squeeze()))
adj = np.matmul(np.matmul(sqrt_deg, adj), sqrt_deg)
f = np.zeros([self.max_node, self.feature_dim], dtype=np.float)
for i, u in enumerate(g.nodes()):
if i < self.max_node:
f[i, :] = np.array(g.node[u]['feat'])
else:
break
self.feature_all.append(f)
self.adj_all.append(adj)
self.label_all.append(g.graph['label'])
def get_sample():
g = nx.generators.random_graphs.powerlaw_cluster_graph(
V, 1, self.triprob)
temp_input = nx.adj_matrix(g).toarray()
# temp_input = expm(temp_input)
# temp_input = nx.laplacian_matrix(g).toarray()
# temp_input = np.linalg.pinv(temp_input)
# temp_input = nx.normalized_laplacian_matrix(g).toarray()
temp_label = list(nx.betweenness_centrality(g).values())
# input node feature
feat = np.ones(shape=(V, 1))
feat[:, 0] = np.reshape(
np.sum(nx.adj_matrix(g).todense(), axis=1), (V, ))
return temp_input, np.array(temp_label), feat
def eigenvector_centrality_numpy(G, weight='weight'):
"""Compute the eigenvector centrality for the graph G.
Parameters
----------
G : graph
A networkx graph
weight : None or string, optional
If None, all edge weights are considered equal.
Otherwise holds the name of the edge attribute used as weight.
Returns
-------
nodes : dictionary
Dictionary of nodes with eigenvector centrality as the value.
Examples
--------
>>> G = nx.path_graph(4)
>>> centrality = nx.eigenvector_centrality_numpy(G)
>>> print(['%s %0.2f'%(node,centrality[node]) for node in centrality])
['0 0.37', '1 0.60', '2 0.60', '3 0.37']
Notes
------
This algorithm uses the NumPy eigenvalue solver.
For directed graphs this is "right" eigevector centrality. For
"left" eigenvector centrality, first reverse the graph with
G.reverse().
See Also
--------
eigenvector_centrality
pagerank
hits
"""
try:
import numpy as np
except ImportError:
raise ImportError('Requires NumPy: http://scipy.org/')
if type(G) == nx.MultiGraph or type(G) == nx.MultiDiGraph:
raise nx.NetworkXException('Not defined for multigraphs.')
if len(G) == 0:
raise nx.NetworkXException('Empty graph.')
A = nx.adj_matrix(G, nodelist=G.nodes(), weight='weight')
eigenvalues,eigenvectors = np.linalg.eig(A)
# eigenvalue indices in reverse sorted order
ind = eigenvalues.argsort()[::-1]
# eigenvector of largest eigenvalue at ind[0], normalized
largest = np.array(eigenvectors[:,ind[0]]).flatten().real
norm = np.sign(largest.sum())*np.linalg.norm(largest)
centrality = dict(zip(G,map(float,largest/norm)))
return centrality
def gdraw0(graphs, plotname = 'default_name', measure = 'cosine'):
pos = nx.graphviz_layout(graphs['kg'])
adjs = [ array(nx.adj_matrix(g)) for g in graphs.values() ]
nrms = []
for a in adjs:
n = sqrt(sum(a**2))
nrms.append(a / n)
kgelt = graphs.keys().index('kg')
if measure == 'cosine':
sims = array([round(nfu.cosine_adj(a1,nrms[kgelt]),8) for a1 in nrms])
else:
raise Exception()
kg = graphs['kg']
srto = argsort(graphs.keys())
#XVALs give ranks of each key index.
xvals = argsort(srto)
cols = map(lambda x:
('flt' in x and x.count('thr') > 1) and 'orange' or
('flt' in x) and 'red' or
('thr' in x) and 'yellow' or
('fg' in x) and 'green' or
('su' in x) and 'blue' or
'black', graphs.keys())
yvals = sims
f = plt.gcf()
f = myplots.fignum(3, (.25 * len(sims),10))
f.clear()
ax = f.add_subplot(111)
myplots.padded_limits(ax,xvals,yvals + [0.], margin = [.02,.02])
ax.scatter(xvals,yvals,100, color = cols)
ax.set_ylabel('red fly similarity ({0})'.format(measure))
ax.set_xlabel('networks')
ax.set_xticklabels([])
ax.set_xticks([])
mark_ys = [0, median(sims), mean(sims), sort(sims)[::-1][1],1]
ax.hlines(mark_ys, *ax.get_xlim(), linestyle = ':',alpha = .2)
f.savefig(cfg.dataPath('figs/meAWG/filter_{0}_meth_{1}_nolabels.pdf'.\
format(plotname,measure)))
ax.set_xticks(range(len(srto)))
ax.annotate('\n'.join(' '.join(z) for z in zip(graphs.keys(),cols)),
[0,1],xycoords = 'axes fraction', va = 'top')
ax.set_xticklabels([graphs.keys()[i] for i in srto],
rotation = 45, size = 'xx-small',ha = 'right')
f.savefig(cfg.dataPath('figs/meAWG/filter_{0}_meth_{1}_labels.pdf'.\
format(plotname,measure)))
def cn(graph):
"""
Common neighbours similarity index.
:param graph: a graph to apply this similarity index on.
:return: similarity matrix.
"""
adjacency_matrix = nx.adj_matrix(graph)
return adjacency_matrix**2
def weighted_degree(G):
"""Return an array of degrees that takes weights into account.
For unweighted graphs, this is the same as the normal degree() method
(though we return an array instead of a list).
"""
amat = nx.adj_matrix(G).A # get a normal array out of it
return abs(amat).sum(0) # weights are sums across rows
def total_weight(G):
adj = nx.adj_matrix(G)
N = G.number_of_nodes()
total = 0.0
for i in xrange(0, N):
for j in xrange(i, N):
total += adj[i, j]
return total
def test_adjacency_matrix(self):
"Conversion to adjacency matrix"
assert_equal(nx.adj_matrix(self.G),self.A)
assert_equal(nx.adj_matrix(self.MG),self.A)
assert_equal(nx.adj_matrix(self.MG2),self.MG2A)
assert_equal(nx.adj_matrix(self.G,nodelist=[0,1]),self.A[:2,:2])
assert_equal(nx.adj_matrix(self.WG),self.WA)
assert_equal(nx.adj_matrix(self.WG,weight=None),self.A)
assert_equal(nx.adj_matrix(self.MG2,weight=None),self.MG2A)
assert_equal(nx.adj_matrix(self.WG,weight='other'),0.6*self.WA)
def test_random_modular_graph_between_fraction():
"""Test for graphs with non-zero between_fraction"""
# We need to measure the degree within/between modules
nnods = 120, 240, 360
nmods = 2, 3, 4
av_degrees = 8, 10, 16
btwn_fractions = 0, 0.1, 0.3, 0.5
for nnod in nnods:
for nmod in nmods:
for av_degree in av_degrees:
for btwn_fraction in btwn_fractions:
g = mod.random_modular_graph(nnod, nmod, av_degree,
btwn_fraction)
# First, check the average degree.
av_degree_actual = np.mean(list(g.degree().values()))
# Since we are generating random graphs, the actual average
# degree we get may be off from the reuqested one by a bit.
# We allow it to be off by up to 1.
#print 'av deg:',av_degree, av_degree_actual # dbg
nt.assert_true (abs(av_degree-av_degree_actual)<1.5,
"""av deg: %.2f av deg actual: %.2f -
This is a stochastic test - repeat to confirm.""" %
(av_degree, av_degree_actual))
# Now, check the between fraction
mat = nx.adj_matrix(g)
#compute the total number of edges in the real graph
nedg = nx.number_of_edges(g)
# sanity checks:
if nnod%nmod:
raise ValueError("nmod must divide nnod evenly")
#Compute the of nodes per module
nnod_mod = nnod/nmod
#compute what the values are in the real graph
blocks = [np.ones((nnod_mod, nnod_mod))] * nmod
mask = util.diag_stack(blocks)
mask[mask==0] = 2
mask = np.triu(mask,1)
btwn_real = np.sum(mat[mask == 2].flatten())
btwn_real_frac = btwn_real / nedg
#compare to what the actual values are
nt.assert_almost_equal(btwn_fraction,
btwn_real_frac, 1,
"This is a stochastic test, repeat to confirm failure")
nt.assert_true(abs(btwn_fraction - btwn_real_frac) < 0.1,
"""btwn fraction: %.2f real btwn frac: %.2f -
This is a stochastic test - repeat to confirm.""" %
(btwn_fraction, btwn_real_frac))
def SpectralEmbedding(G, k = 5):
'''
Takes a input Graph, and embeds it into k-dimensional
euclidean space using a top-k-eigenvector embedding.
'''
# creates row normalized weight matrix
M = normalize(nx.adj_matrix(G.copy()), norm='l1', axis=1)
_, v = eigsh(M, k = k, which = 'LM')
return v
def icml_mostafa(G,transpose=False):
A = nx.adj_matrix(G).todense()
if transpose==True:
A = A.T;
m , n = A.shape;
deg = nx.degree(G);
done = 1;
I = np.zeros_like(range(m));
O = np.zeros_like(range(n))
l = 1;
T = [];
while done == 1:
#find the candidate pair
u = -1;
v = -1;
min_d_uv = m+n+1;
for i in range(m):
if I[i] == 0:
for j in range(n):
if (A[i,j] == 1) and (O[j] == 0) and ((deg[i] + deg[j]) < min_d_uv):
min_d_uv = deg[i] + deg[j];
u = i;
v = j;
I[u] = 1;
O[v] = 1;
if (u == -1) and (v == -1):
done = 0;
else:
# set the rows and columns to one if used
for j in range(n):
if A[u,j] == 1:
A[u,j] = 0;
deg[j] -= 1;
O[j] = 1;
I[j] = 1;
for i in range(m):
if A[i,v] == 1:
A[i,v] = 0;
deg[i] -= 1;
I[i] = 1;
O[i] = 1;
I[u] = 1;
O[v] = 1;
T.append((u,v));
return T;
def add_edge_wts(G):
# For each node, it adds the weights of all the edges incident on the node
node_wts = {}
nodes = G.nodes()
# Find the adjacency matrix
adj = nx.adj_matrix(G)
summation = adj.sum(axis=1)
N = G.number_of_nodes()
for x in xrange(0, N):
node_wts[nodes[x]] = summation[x, 0]
return node_wts
