Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
# variable to hold leading eigenvector communities
leading_eigen_c = community.community_leading_eigenvector()
# variable to hold leading eigenvector modularity
leading_eigen_m = leading_eigen_c.modularity
# variable to hold walktrap communities
walktrap_c = community.community_walktrap(steps=4).as_clustering()
# variable to hold walktrap modularity
walktrap_m = walktrap_c.modularity
# variable to hold fast greedy communities
fastgreedy_c = community.community_fastgreedy().as_clustering()
# variable to hold fast greedy modularity
fastgreedy_m = fastgreedy_c.modularity
edge_betweenness_c = ig.VertexClustering
edge_betweenness_m = float
# if network is connected and number of components is less than or equal to 2
if community.is_connected() or len(community.components()) <= 2:
# variable to hold edge betweenness communities
edge_betweenness_c = community.community_edge_betweenness(directed=False).as_clustering()
# variable to hold edge betweenness modularity
edge_betweenness_m = edge_betweenness_c.modularity
####################################################################################################################
# variable to hold output file
output_file = open('../../data/networks/{}/communities/txt/'
'{}/{}/modularity.txt'.format(path, edge_type, method, count1), mode='a')
# write modularity to file
# if network is connected and number of components is less than or equal to 2
if network.is_connected() or len(network.components()) <= 2:
# variable to hold edge betweenness communities
edge_betweenness_c = network.community_edge_betweenness(directed=False, weights='weight').as_clustering()
# variable to hold edge betweenness modularity
edge_betweenness_m = edge_betweenness_c.modularity
# if network is not weighted
else:
# variable to hold infomap communities
infomap_c = network.community_infomap()
# variable to hold infomap modularity
infomap_m = infomap_c.modularity
spinglass_c = ig.VertexClustering
spinglass_m = float
# if network is connected
if network.is_connected():
# variable to hold spinglass communities
spinglass_c = network.community_spinglass()
# variable to hold spinglass modularity
spinglass_m = spinglass_c.modularity
# variable to hold louvain communities
louvain_c = network.community_multilevel()
# variable to hold louvain modularity
louvain_m = louvain_c.modularity
# variable to hold label propagation communities
label_prop_c = network.community_label_propagation()
)
if self._adata.uns[vkey].shape != (self._adata.n_obs, self._adata.n_obs):
raise ValueError(
f"The passed 'velocity_graph' have shape {self._adata.uns[vkey].shape} "
f"but shoud have shape {(self._adata.n_obs, self._adata.n_obs)}"
)
# restore this at some point
# if 'expected_n_edges_random' not in self._adata.uns['paga']:
# raise ValueError(
# 'Before running PAGA with `use_rna_velocity=True`, run it with `False`.')
import igraph
g = _utils.get_igraph_from_adjacency(
self._adata.uns[vkey].astype('bool'),
directed=True,
)
vc = igraph.VertexClustering(
g, membership=self._adata.obs[self._groups_key].cat.codes.values
)
# set combine_edges to False if you want self loops
cg_full = vc.cluster_graph(combine_edges='sum')
transitions = _utils.get_sparse_from_igraph(cg_full, weight_attr='weight')
transitions = transitions - transitions.T
transitions_conf = transitions.copy()
transitions = transitions.tocoo()
total_n = self._neighbors.n_neighbors * np.array(vc.sizes())
# total_n_sum = sum(total_n)
# expected_n_edges_random = self._adata.uns['paga']['expected_n_edges_random']
for i, j, v in zip(transitions.row, transitions.col, transitions.data):
# if expected_n_edges_random[i, j] != 0:
# # factor 0.5 because of asymmetry
# reference = 0.5 * expected_n_edges_random[i, j]
# else:
g = G.copy()
g.vs['id'] = list(range(g.vcount()))
if measure=='weak':
result = radicchi_internal(G, g, 0, measure=measure, clustering=4)
elif measure=='strong':
result = radicchi_internal(G, g, 0, measure=measure, clustering=3)
else:
raise Exception('Other measures of community not yet supported')
clustering = [0] * G.vcount()
for i,l in enumerate(result):
for v in l:
clustering[v] = i
return ig.VertexClustering(G, clustering)
if community.is_connected() or len(community.components()) <= 2:
# variable to hold edge betweenness communities
edge_betweenness_c = community.community_edge_betweenness(directed=False,
weights='weight').as_clustering()
# variable to hold edge betweenness modularity
edge_betweenness_m = edge_betweenness_c.modularity
# if community is not weighted
else:
# variable to hold infomap communities
infomap_c = community.community_infomap()
# variable to hold infomap modularity
infomap_m = infomap_c.modularity
spinglass_c = ig.VertexClustering
spinglass_m = float
# if network is connected
if community.is_connected():
# variable to hold spinglass communities
spinglass_c = community.community_spinglass()
# variable to hold spinglass modularity
spinglass_m = spinglass_c.modularity
# variable to hold louvain communities
louvain_c = community.community_multilevel()
# variable to hold louvain modularity
louvain_m = louvain_c.modularity
# variable to hold label propagation communities
label_prop_c = community.community_label_propagation()
def _compute_connectivities_v1_0(self):
import igraph
ones = self._neighbors.connectivities.copy()
ones.data = np.ones(len(ones.data))
g = _utils.get_igraph_from_adjacency(ones)
vc = igraph.VertexClustering(
g, membership=self._adata.obs[self._groups_key].cat.codes.values
)
ns = vc.sizes()
cg = vc.cluster_graph(combine_edges='sum')
inter_es = _utils.get_sparse_from_igraph(cg, weight_attr='weight') / 2
connectivities = inter_es.copy()
inter_es = inter_es.tocoo()
n_neighbors_sq = self._neighbors.n_neighbors**2
for i, j, v in zip(inter_es.row, inter_es.col, inter_es.data):
# have n_neighbors**2 inside sqrt for backwards compat
geom_mean_approx_knn = np.sqrt(
n_neighbors_sq * ns[i] * ns[j])
if geom_mean_approx_knn != 0:
scaled_value = v / geom_mean_approx_knn
else:
scaled_value = 1
def compute_transitions_old(self):
import igraph
g = _utils.get_igraph_from_adjacency(
self._adata.uns['velocyto_transitions'],
directed=True,
)
vc = igraph.VertexClustering(
g, membership=self._adata.obs[self._groups_key].cat.codes.values)
# this stores all single-cell edges in the cluster graph
cg_full = vc.cluster_graph(combine_edges=False)
# this is the boolean version that simply counts edges in the clustered graph
g_bool = _utils.get_igraph_from_adjacency(
self._adata.uns['velocyto_transitions'].astype('bool'),
directed=True,
)
vc_bool = igraph.VertexClustering(
g_bool,
membership=self._adata.obs[self._groups_key].cat.codes.values
)
cg_bool = vc_bool.cluster_graph(combine_edges='sum') # collapsed version
transitions = _utils.get_sparse_from_igraph(cg_bool, weight_attr='weight')
total_n = self._neighbors.n_neighbors * np.array(vc_bool.sizes())
transitions_ttest = transitions.copy()
def _compute_connectivities_v1_2(self):
import igraph
ones = self._neighbors.distances.copy()
ones.data = np.ones(len(ones.data))
# should be directed if we deal with distances
g = _utils.get_igraph_from_adjacency(ones, directed=True)
vc = igraph.VertexClustering(
g, membership=self._adata.obs[self._groups_key].cat.codes.values
)
ns = vc.sizes()
n = sum(ns)
es_inner_cluster = [vc.subgraph(i).ecount() for i in range(len(ns))]
cg = vc.cluster_graph(combine_edges='sum')
inter_es = _utils.get_sparse_from_igraph(cg, weight_attr='weight')
es = np.array(es_inner_cluster) + inter_es.sum(axis=1).A1
inter_es = inter_es + inter_es.T # \epsilon_i + \epsilon_j
connectivities = inter_es.copy()
expected_n_edges = inter_es.copy()
inter_es = inter_es.tocoo()
for i, j, v in zip(inter_es.row, inter_es.col, inter_es.data):
expected_random_null = (es[i]*ns[j] + es[j]*ns[i])/(n - 1)
if expected_random_null != 0:
scaled_value = v / expected_random_null
# variable to hold leading eigenvector communities
leading_eigen_c = community.community_leading_eigenvector(weights='weight')
# variable to hold leading eigenvector modularity
leading_eigen_m = leading_eigen_c.modularity
# variable to hold walktrap communities
walktrap_c = community.community_walktrap(weights='weight', steps=4).as_clustering()
# variable to hold walktrap modularity
walktrap_m = walktrap_c.modularity
# variable to hold fast greedy communities
fastgreedy_c = community.community_fastgreedy(weights='weight').as_clustering()
# variable to hold fast greedy modularity
fastgreedy_m = fastgreedy_c.modularity
edge_betweenness_c = ig.VertexClustering
edge_betweenness_m = float
# if network is connected and number of components is less than or equal to 2
if community.is_connected() or len(community.components()) <= 2:
# variable to hold edge betweenness communities
edge_betweenness_c = community.community_edge_betweenness(directed=False,
weights='weight').as_clustering()
# variable to hold edge betweenness modularity
edge_betweenness_m = edge_betweenness_c.modularity
# if community is not weighted
else:
# variable to hold infomap communities
infomap_c = community.community_infomap()
# variable to hold infomap modularity
def eval_data(title, G, ground_truth, algo_list):
print("\n======== {} ========\n".format(title))
for algo in algos:
print("Testing \"{}\"".format(algo.__name__))
t0 = time.time()
result = algo(G)
t_diff = time.time() - t0
clustering = None
if isinstance(result, VertexClustering):
clustering = result
elif isinstance(result, VertexDendrogram):
clustering = result.as_clustering()
else:
raise Exception("Algorithm output type not recognized")
f1 = metrics.f1(clustering, ground_truth)
print("\t[*] Execution time: {}".format(t_diff))
print("\t[*] F1 Score: {}".format(f1))