def modularity_dist(adjacency1, labels1, adjacency2, labels2):
"""
Modularity based distance (percent-deviation)
"""
m1 = modularity(adjacency1, labels1)
m2 = modularity(adjacency2, labels2)
return np.abs((m1 - m2) / m1)
def test_undirected(self):
self.louvain_high_resolution = Louvain(engine='python', resolution=2)
self.louvain_null_resolution = Louvain(engine='python', resolution=0)
self.karate_club = karate_club()
self.louvain.fit(self.karate_club)
labels = self.louvain.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.42, 2)
if is_numba_available:
self.louvain_numba.fit(self.karate_club)
labels = self.louvain_numba.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.42,
2)
self.louvain_high_resolution.fit(self.karate_club)
labels = self.louvain_high_resolution.labels_
self.assertEqual(labels.shape, (34, ))
self.assertAlmostEqual(modularity(self.karate_club, labels), 0.34, 2)
self.louvain_null_resolution.fit(self.karate_club)
labels = self.louvain_null_resolution.labels_
self.assertEqual(labels.shape, (34, ))
self.assertEqual(len(set(self.louvain_null_resolution.labels_)), 1)
def test_directed(self):
self.painters = painters(return_labels=False)
self.louvain.fit(self.painters)
labels = self.louvain.labels_
self.assertEqual(labels.shape, (14, ))
self.assertAlmostEqual(modularity(self.painters, labels), 0.32, 2)
self.bilouvain.fit(self.painters)
n1, n2 = self.painters.shape
row_labels = self.bilouvain.row_labels_
col_labels = self.bilouvain.col_labels_
self.assertEqual(row_labels.shape, (n1, ))
self.assertEqual(col_labels.shape, (n2, ))
def getIterateAverages(adjacency,n=1000,mu=1,sigma=1/2,stop=True,plot=False,epsilon=1e-5,d=1,K=2):
"""
Inputs:
- adjacency: adjaceny matrix
- n: number of iterations (default 1000)
- mu: mean of initial gaussian variable (default 1)
- sigma: variance of initial gaussian variable (default 1/2)
- stop: boolean (default True): stop the iterations using variance criterion
- plot: boolean (default False): plot of variance and modularity obtained by kmeans
- epsilon: stopping criterion for variance
- d: dimension f0
- K: number of cluster k-means
"""
f0 = np.sqrt(sigma)*np.random.randn(adjacency.shape[0],d)+mu
fs = [f0]
var = []
if plot:
mod = []
for k in range(n):
fs.append(iterate(fs[-1],adjacency.indptr,adjacency.indices,d))
var.append(np.sum(np.std(fs[-1],axis=0)**2))
if plot:
c,labels_k,inertia = k_means(fs[-1],K)
mod.append(modularity(adjacency,labels_k))
if(stop and k>1 and np.abs(var[-2]-var[-1])<epsilon):
break
if plot:
plt.plot(var)
plt.xlabel("iterations")
plt.ylabel(r"$\sigma^2$")
plt.title("Variance")
plt.show()
plt.plot(mod)
plt.xlabel("iterations")
plt.ylabel("Q")
plt.title("Modularity")
plt.show()
return fs
def test_modularity(self):
adjacency = karate_club()
labels = Louvain().fit_transform(adjacency)
self.assertAlmostEqual(0.42, modularity(adjacency, labels), places=2)
def test_modularity(self):
self.assertAlmostEqual(modularity(self.graph, self.labels), -0.0312, 3)
self.assertAlmostEqual(modularity(self.graph, self.unique_cluster), 0.)
indegreerank_org.to_csv('indegreerank_org.csv')
indegreerank_org = indegreerank_org.rank(ascending=False)
indegreerank_org = indegreerank_org.to_frame()
org_rank = pagerank_org.join(katzrank_org)
org_rank = org_rank.join(indegreerank_org)
org_rank = org_rank.mean(axis=1)
org_rank.to_csv('org_rank.csv')
#####pattern detection
adjacency = nx.adjacency_matrix(G)
louvain = Louvain()
labels = louvain.fit_transform(adjacency)
labels_unique, counts = np.unique(labels, return_counts=True)
optimal_modularity = modularity(adjacency, labels)
#####modularity of the attribute
organization = network_data['Organization']
organization = organization.to_numpy()
organization_label = pd.factorize(organization)[0]
organization_modularity = modularity(adjacency, organization_label)
hireable = network_data['hireable']
hireable = hireable.to_numpy()
hireable_label = pd.factorize(hireable)[0]
hireable_modularity = modularity(adjacency, hireable_label)
language = network_data['language']
language = language.to_numpy()