def multilevel(self, data):
conn_indices = np.where(data)
weights = data[conn_indices]
edges = zip(*conn_indices)
G = igraph.Graph(edges=edges, directed=False)
G.es['weight'] = weights
comm = G.community_multilevel(weights=weights, return_levels=False)
return comm
def graph(self):
"""
Draws the Graph/Network switches ...
"""
# ---------------------------------------------------------
N = self.G.nodes()
d = defaultdict(list)
E = self.G.number_of_edges()
print
"The number of Nodes in this Network:", N
print
"The number of Edges in this Network:", E
fig = plt.figure()
fig.canvas.set_window_title("The ERnet Topology View")
nx.draw_networkx(self.G)
plt.show()
g = ig.Graph(len(self.G), zip(*zip(*nx.to_edgelist(self.G))[:2]))
self.pt(g)
cl = g.community_fastgreedy()
# print cl
membership = cl.as_clustering().membership
print
membership
self.pt(g, membership)
# print g.get_all_shortest_paths (2, 33)
membership.pop(0)
for q, a in zip(N, membership):
print
'The Node {0} --> Belongs to cluster {1}.'.format(q, a)
# The following procedure is to get the exact nodes of each cluster
for i in range(max(membership)):
i += 1
for j in range(len(N)):
if membership[j] == i:
d[i].append(N[j])
print
d.items()
# Test the subgraphs correctness, which is the clusters
fig = plt.figure()
fig.canvas.set_window_title("Sub-Graph/Clique 1 of ERnet")
G3 = self.G.subgraph(
d[1]
) # each index in dictionary "d" is considered as a one cluster/subgraph of G
nx.draw_networkx(G3)
plt.show()
def comm_unweighted(data):
'''Community structure based on the multilevel
algorithm of Blondel et al.'''
conn_indices = np.where(data)
edgs = zip(*conn_indices)
G = igraph.Graph(edges=edgs, directed=False)
comm = G.community_multilevel(weights=None, return_levels=False)
return comm
def g2ig(g):
"""
Converts our graph represenataion to an igraph for plotting
"""
t = scipy.where(CG2adj(g) == 1)
l = zip(t[0], t[1])
ig = igr.Graph(l, directed=True)
ig.vs["name"] = scipy.sort([u for u in g])
ig.vs["label"] = ig.vs["name"]
return ig
def comm_weighted(data):
'''Community structure based on the multilevel
algorithm of Blondel et al.'''
conn_indices = np.where(data)
weights = data[conn_indices]
edges = zip(*conn_indices)
G = igraph.Graph(edges=edges, directed=False)
G.es['weight'] = weights
comm = G.community_multilevel(weights=weights, return_levels=False)
return comm
def __init__(self,
file_dir,
embedding_dim,
seed,
shuffle,
model,
sequence_size=8,
stride=1,
neighbor_size=8):
assert model == "pscn"
super(PatchySanDataSet, self).__init__(file_dir, embedding_dim, seed,
shuffle, model)
n_vertices = self.graphs.shape[1]
logger.info("generating receptive fields...")
self.receptive_fields = []
for i in range(self.graphs.shape[0]):
adj = self.graphs[i]
edges = list(zip(*np.where(adj)))
g = igraph.Graph(edges=edges, directed=False)
assert (g.vcount() == n_vertices)
g.simplify()
sequence = self.get_bfs_order(g, n_vertices - 1, sequence_size,
self.influence_features[i])
neighborhoods = np.zeros((sequence_size, neighbor_size),
dtype=np.int32)
neighborhoods.fill(-1)
for j, v in enumerate(sequence):
if v < 0:
break
shortest = list(
itertools.islice(g.bfsiter(int(v), mode='ALL'),
neighbor_size))
for k, vtx in enumerate(shortest):
neighborhoods[j][k] = vtx.index
neighborhoods = neighborhoods.reshape(sequence_size *
neighbor_size)
self.receptive_fields.append(neighborhoods)
self.receptive_fields = np.array(self.receptive_fields, dtype=np.int32)
logger.info("receptive fields generated!")
def generateAllGraphs(V, E):
# Goal: Return a list of all graphs on V vertices with E edges.
allGraphs = []
# IMPORTANT: DO NOT return any graphs with isolated vertices!
## (1) List every edge that can possibly occur on the V vertices.
allPossibleEdges = list(
itertools.combinations_with_replacement(range(0, V), 2))
## (2) List every possible way of choosing E edges from allPossibleEdges with replacement.
allPossibleWaysOfChoosingTheEdges = itertools.combinations_with_replacement(
allPossibleEdges, E)
## (3) For each choice in allPossibleWaysOfChoosingTheEdges, create a graph on V vertices with those edge choices.
for choice in allPossibleWaysOfChoosingTheEdges:
# Create a graph, g, with with V vertices and the chosen edges.
newGraph = jgraph.Graph(V)
newGraph.add_edges(list(choice))
# If the resulting graph does not contain any isolated vertices then store it.
if newGraph.degree().count(0) == 0:
allGraphs.append(newGraph)
del newGraph
return allGraphs
def load_obo(cls,
file): # Only building on "is_a" relation between CL terms
import pronto
ont = pronto.Ontology(file)
graph, vdict = jgraph.Graph(directed=True), {}
for item in ont:
if not item.id.startswith("CL"):
continue
if "is_obsolete" in item.other and item.other["is_obsolete"][
0] == "true":
continue
graph.add_vertex(name=item.id,
cell_ontology_class=item.name,
desc=str(item.desc),
synonyms=[("%s (%s)" % (syn.desc, syn.scope))
for syn in item.synonyms])
assert item.id not in vdict
vdict[item.id] = item.id
assert item.name not in vdict
vdict[item.name] = item.id
for synonym in item.synonyms:
if synonym.scope == "EXACT" and synonym.desc != item.name:
vdict[synonym.desc] = item.id
for source in graph.vs:
for relation in ont[source["name"]].relations:
if relation.obo_name != "is_a":
continue
for target in ont[source["name"]].relations[relation]:
if not target.id.startswith("CL"):
continue
graph.add_edge(
source["name"],
graph.vs.find(name=target.id.split()[0])["name"])
# Split because there are many "{is_infered...}" suffix,
# falsely joined to the actual id when pronto parses the
# obo file
return cls(graph, vdict)
def __init__(self, graph=None, vdict=None):
self.graph = jgraph.Graph(directed=True) if graph is None else graph
self.vdict = {} if vdict is None else vdict
