def hc(G, modelo):
#G=nx.read_edgelist("test.net")
# Extract largest connected component into graph H
components = [comp for comp in nx.connected_component_subgraphs(G)]
component_size = [len(comp)for comp in components]
H=components[0]
# Makes life easier to have consecutively labeled integer nodes
H=nx.convert_node_labels_to_integers(H)
# Create parititions with hierarchical clustering
partitions=create_hc(H)
partition = {}
#Convertimos. partitions a partition como diccionario.
cont = 0
for i in partitions:
for j in i:
partition[j + 1] = cont # se le suma uno para no tener nodo cero sino desde nodo 1.
cont += 1
# Build blockmodel graph
BM=nx.blockmodel(H,partitions)
hc = 1
comunidad(BM, partition, modelo, hc)
hc = 0
def full_hc(self, G, hc = None, clusters = [], clear = True, method='complete', metric ='euclidean', clip = False, t=1.0):
"""
All this function needs is G and it will do a full hierarchical clustering of a graph
You could also seed it with an initial clustering of your own choosing by setting hc
Note: hc is a list of node labels
"""
#clears cached clusters so that clusters are not appended endlessly
if clear:
self.clear()
clear = False
if hc and len(hc) == 1:
self.clusters.append(hc)
clusters.append(hc)
return clusters
else:
if not hc:
hc = self.create_hc(G, method=method, metric=metric, t=t)
bm = nx.blockmodel(G, hc)
#append to local variable
clusters.append(hc)
#append to properties
self.clusters.append(hc)
self.blockmodels.append(bm)
#grab next hc
next_hc = self.next_labeled_hc(hc, bm, method = method, metric = metric, clip = clip, t=t)
return self.full_hc(G, hc=next_hc, clusters=clusters, clear=clear, method=method, metric=metric, clip=clip, t=t)
def pajek_group(G, Grupo, comp):
#print("comienza reduccion de grafo")
#elimino nodos con grado cero.
#nuevo experimento, miraremos si es igual al arrojado por nuestro algoritmo.
Grp = [Grupo[i] for i in Grupo] #guarda los grupos como arreglo para poder que la funcion blockmodel separe los que sobra.
B = nx.blockmodel(G,Grp)
#Re nombro los nodos para eliminar el nodo cero y que todo corresponda a los grupos encontrados en la funcion anterior.
mapping = {} #variable que guardara el nuevo valor de nodos.
cont = 0
for i in B.nodes(): #creo diccionario que guarda el nuevo valor de nodos.
mapping[cont] = cont + 1
cont += 1
A=nx.relabel_nodes(B,mapping) #asigno grafo con el nuevo valor de nodos.
NodosBorrar = []
cont_group = 1
cont = 1
for i in A.nodes():
if A.degree(cont_group) != 0:
cont += 1
if A.degree(cont_group) == 0:
NodosBorrar.append(cont_group)
cont_group += 1
for i in NodosBorrar: A.remove_node(i)
Nodes = A.number_of_nodes()
candidatos(G,A,comp, Grupo)
def blockmodel(self, save=True):
goog_url = SEMANTIC_NETWORK_GOOG_URLS[self.model.name]
cluster_ld = pytxt.tsv2ld(goog_url)
cluster_id2d = pytxt.ld2dd(cluster_ld, 'ID')
node_ld = pytxt.tsv2ld(
self.fn.replace('.graphml', '.analysis-with-modularity.txt'))
id2ld = pytxt.ld2dld(node_ld, 'partition_id')
part_list = []
for p_id, pld in sorted(id2ld.items()):
nodes = [d['word'] for d in pld]
part_list += [nodes]
M = nx.blockmodel(self.g, part_list)
M2 = nx.Graph()
node2name = {}
for node in M.nodes():
cluster = cluster_id2d[str(node)]
name = cluster['NAME']
node2name[node] = name
M2.add_node(name, **cluster)
for a, b in M.edges():
M2.add_edge(node2name[a], node2name[b])
if save:
nx.write_graphml(
M2, self.fn.replace('.graphml', '.blockmodel.graphml'))
return M2
def inter_community_edges(G, partition):
"""Returns the number of inter-community edges according to the given
partition of the nodes of ``G``.
``G`` must be a NetworkX graph.
``partition`` must be a partition of the nodes of ``G``.
The *inter-community edges* are those edges joining a pair of nodes
in different blocks of the partition.
Implementation note: this function creates an intermediate graph
that may require the same amount of memory as required to store
``G``.
"""
# Alternate implementation that does not require constructing a new
# graph object (but does require constructing an affiliation
# dictionary):
#
# aff = dict(chain.from_iterable(((v, block) for v in block)
# for block in partition))
# return sum(1 for u, v in G.edges() if aff[u] != aff[v])
#
return nx.blockmodel(G, partition, multigraph=True).size()
def propagate_constraints(self):
"""Propagate p=0 and p=1 probabilities edges
"""
# propagated p=1 constraints
p1 = []
c = nx.Graph(self)
c.remove_edges_from([(e, f) for e, f, d in self.edges_iter(data=True)
if d[PROBABILITY] != 1])
components = nx.connected_components(c)
for component in components:
for i, n in enumerate(component):
for m in component[i+1:]:
p1.append((n, m))
# propagated p=0 constraints
p0 = []
c = nx.Graph(self)
c.remove_edges_from([(e, f) for e, f, d in self.edges_iter(data=True)
if d[PROBABILITY] != 0])
c = nx.blockmodel(c, components, multigraph=True)
for e, f in c.edges_iter():
for n in components[e]:
for m in components[f]:
p0.append((n, m))
for n, m in p1:
self.add_edge(n, m, **{PROBABILITY: 1.})
for n, m in p0:
self.add_edge(n, m, **{PROBABILITY: 0.})
return self
def hiclus_blockmodel(G):
# Extract largest connected component into graph H
H=nx.connected_component_subgraphs(G)[0]
# Create parititions with hierarchical clustering
partitions=hc.create_hc(H)
# Build blockmodel graph
BM=nx.blockmodel(H,partitions)
# Draw original graph
pos=nx.spring_layout(H,iterations=100)
fig=plt.figure(1,figsize=(6,10))
ax=fig.add_subplot(211)
nx.draw(H,pos,with_labels=False,node_size=10)
plt.xlim(0,1)
plt.ylim(0,1)
# Draw block model with weighted edges and nodes sized by number of internal nodes
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[(2*d['weight']) for (u,v,d) in BM.edges(data=True)]
# Set positions to mean of positions of internal nodes from original graph
posBM={}
for n in BM:
xy=numpy.array([pos[u] for u in BM.node[n]['graph']])
posBM[n]=xy.mean(axis=0)
ax=fig.add_subplot(212)
nx.draw(BM,posBM,node_size=node_size,width=edge_width,with_labels=False)
plt.xlim(0,1)
plt.ylim(0,1)
plt.axis('off')
def hiclus_blockmodel(G):
# Extract largest connected component into graph H
H = nx.connected_component_subgraphs(G)[0]
# Create parititions with hierarchical clustering
partitions = hc.create_hc(H)
# Build blockmodel graph
BM = nx.blockmodel(H, partitions)
# Draw original graph
pos = nx.spring_layout(H, iterations=100)
fig = plt.figure(1, figsize=(6, 10))
ax = fig.add_subplot(211)
nx.draw(H, pos, with_labels=False, node_size=10)
plt.xlim(0, 1)
plt.ylim(0, 1)
# Draw block model with weighted edges and nodes sized by number of internal nodes
node_size = [BM.node[x]['nnodes'] * 10 for x in BM.nodes()]
edge_width = [(2 * d['weight']) for (u, v, d) in BM.edges(data=True)]
# Set positions to mean of positions of internal nodes from original graph
posBM = {}
for n in BM:
xy = numpy.array([pos[u] for u in BM.node[n]['graph']])
posBM[n] = xy.mean(axis=0)
ax = fig.add_subplot(212)
nx.draw(BM,
posBM,
node_size=node_size,
width=edge_width,
with_labels=False)
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.axis('off')
def plot_additional(self, home_nodes, levels=0):
"""Plot new nodes"""
new_nodes = self._neighbors(home_nodes, levels=levels)
new_nodes = home_nodes.union(new_nodes)
displayed_data_nodes = set([v['G_id'] for k,v in self.dispG.node.items()])
current_num_islands = nx.number_connected_components(self.dispG)
new_num_islands = nx.number_connected_components(self.G.subgraph(displayed_data_nodes.union(new_nodes)))
if new_num_islands > current_num_islands:
all_nodes = set(self.G.nodes())
singleton_nodes = all_nodes - displayed_data_nodes - new_nodes
singleton_nodes = map(lambda x: [x], singleton_nodes)
partitions = [displayed_data_nodes, new_nodes] + list(singleton_nodes)
B = nx.blockmodel(self.G, partitions, multigraph=True)
try:
path = nx.shortest_path(B, 0, 1)
except nx.NetworkXNoPath:
pass
else:
ans = tkm.askyesno("Plot path?", "A path exists between the current graph and"
"the nodes you have added. Would you like to plot that path?")
if ans:
for u in path[1:-1]:
Gu = B.node[u]['graph'].nodes()
assert len(Gu) ==1; Gu=Gu[0]
new_nodes.add(Gu)
self._plot_additional(new_nodes)
def _neighbors(self, node, levels=1, graph=None):
"""Return graph of neighbors around node in graph (default: self.dataG)
to a certain number of levels"""
if graph is None:
graph = self.dataG
if not isinstance(node, (list, tuple, set)):
node = [
node,
]
neighbors = set(node)
blocks = [[
n,
] for n in node]
for i in range(levels):
for n in neighbors:
new_neighbors = set(graph.neighbors(n)) - neighbors
blocks.append(new_neighbors)
neighbors = neighbors.union(new_neighbors)
G = graph.subgraph(neighbors)
if len(blocks) > 1:
# Create a block repersentation of our graph and make sure we're plotting
# anything that connects the blocks too
# Create blocks for each individual node not already in a block
non_blocked = set(self.dataG.nodes()) - neighbors
non_blocked = [[
a,
] for a in non_blocked]
partitions = blocks + non_blocked
B = nx.blockmodel(graph, partitions)
# The resulting graph will has nodes numbered according their index in partitions
# We want to go through the partitions which are blocks and find the shortest path
num_blocks = len(blocks)
for frm_node, to_node in zip(range(num_blocks),
range(1, num_blocks - 1)):
try:
path = nx.shortest_path(B, frm_node, to_node)
except nx.NetworkXNoPath as e:
pass # In an island, which is permissible
except nx.NetworkXError as e:
tkm.showerror("Node not in graph", str(e))
return
else:
# Break path in B back down into path in G
path2 = []
for a in path[1:-1]: # don't include end points
for n in partitions[a]:
neighbors.add(n)
G = graph.subgraph(neighbors)
return G
def find_out_edges(list_of_edges, graph):
NG = nx.blockmodel(graph, list_of_edges)
eg = NG.edges_iter(data=True)
count = 0
for e in eg:
count += e[2]['weight']
return count
def GenerateBlockSequenceRepresentatives(G) :
"""Synopsis:
For the graph G, this function does the following:
1. Generates all indecomposable partitions of V(G), denoted by P.
2. For each partition p of P, it generates the graph G \ p and its
update sequence representatives translated back to the blocks of p.
3. It returns a double list where each element is the list of
representatives for G \ p as p varies over P. This list can be
flatten as in the example contained at the end of this file.
The function assumes that the vertices are labeled 0, 1, ...,
n-1. The collection returned is canonical in the sense that each
representative has a maximal number of blocks. Some blocks may be
combined, but this will generally not lead to a canonical set of
representatives.
"""
partitionCollection = GenerateIrreducibleBlockSequences(G)
globalCollection = []
for partition in partitionCollection :
# print "Partition: ", partition
# Generate G \ partition with vertex set range(0, len(partition) )
gMod = nx.blockmodel(G, partition)
# print "Gmod - vertices: ", gMod.number_of_nodes()
# Generate update sequence transversal
linExt = equivalence.LinearExtensions( gMod )
# print "Linear extensions: ", len(linExt)
# for e in linExt :
# print "\t", e
# Generate corresponding block sequences for this partition
blockSequenceCollection = []
for gModSeq in linExt :
blockSequence = []
for index in gModSeq :
blockSequence.append( partition[index] )
blockSequenceCollection.append( blockSequence )
globalCollection.append( blockSequenceCollection )
return globalCollection
def test_barbell(self):
G = networkx.barbell_graph(3, 0)
partition = [[0, 1, 2], [3, 4, 5]]
M = networkx.blockmodel(G, partition)
assert_equal(sorted(M.nodes()), [0, 1])
assert_equal(sorted(M.edges()), [(0, 1)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 3)
assert_equal(M.node[n]['nnodes'], 3)
assert_equal(M.node[n]['density'], 1.0)
def test_path(self):
G=networkx.path_graph(6)
partition=[[0,1],[2,3],[4,5]]
M=networkx.blockmodel(G,partition)
assert_equal(sorted(M.nodes()),[0,1,2])
assert_equal(sorted(M.edges()),[(0,1),(1,2)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'],1)
assert_equal(M.node[n]['nnodes'],2)
assert_equal(M.node[n]['density'],1.0)
def test_path(self):
G = networkx.path_graph(6)
partition = [[0, 1], [2, 3], [4, 5]]
M = networkx.blockmodel(G, partition)
assert_equal(sorted(M.nodes()), [0, 1, 2])
assert_equal(sorted(M.edges()), [(0, 1), (1, 2)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 1)
assert_equal(M.node[n]['nnodes'], 2)
assert_equal(M.node[n]['density'], 1.0)
def test_barbell(self):
G=networkx.barbell_graph(3,0)
partition=[[0,1,2],[3,4,5]]
M=networkx.blockmodel(G,partition)
assert_equal(sorted(M.nodes()),[0,1])
assert_equal(sorted(M.edges()),[(0,1)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'],3)
assert_equal(M.node[n]['nnodes'],3)
assert_equal(M.node[n]['density'],1.0)
def test_multigraph_blockmodel(self):
G = nx.MultiGraph(nx.path_graph(6))
partition = [[0, 1], [2, 3], [4, 5]]
M = nx.blockmodel(G, partition, multigraph=True)
assert_equal(sorted(M.nodes()), [0, 1, 2])
assert_equal(sorted(M.edges()), [(0, 1), (1, 2)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 1)
assert_equal(M.node[n]['nnodes'], 2)
assert_equal(M.node[n]['density'], 1.0)
def test_directed_multigraph_path(self):
G = networkx.MultiDiGraph()
G.add_path(list(range(6)))
partition = [[0, 1], [2, 3], [4, 5]]
M = networkx.blockmodel(G, partition, multigraph=True)
assert_equal(sorted(M.nodes()), [0, 1, 2])
assert_equal(sorted(M.edges()), [(0, 1), (1, 2)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 1)
assert_equal(M.node[n]['nnodes'], 2)
assert_equal(M.node[n]['density'], 0.5)
def test_directed_multigraph_path(self):
G = networkx.MultiDiGraph()
G.add_path(list(range(6)))
partition=[[0,1],[2,3],[4,5]]
M=networkx.blockmodel(G,partition,multigraph=True)
assert_equal(sorted(M.nodes()),[0,1,2])
assert_equal(sorted(M.edges()),[(0,1),(1,2)])
for n in M.nodes():
assert_equal(M.node[n]['nedges'],1)
assert_equal(M.node[n]['nnodes'],2)
assert_equal(M.node[n]['density'],0.5)
def test_barbell_plus(self):
G=networkx.barbell_graph(3,0)
G.add_edge(0,5) # add extra edge between bells
partition=[[0,1,2],[3,4,5]]
M=networkx.blockmodel(G,partition)
assert_equal(sorted(M.nodes()),[0,1])
assert_equal(sorted(M.edges()),[(0,1)])
assert_equal(M[0][1]['weight'],2)
for n in M.nodes():
assert_equal(M.node[n]['nedges'],3)
assert_equal(M.node[n]['nnodes'],3)
assert_equal(M.node[n]['density'],1.0)
def pajek_group(G, Grupos):
print("comienza reduccion de grafo")
#elimino nodos con grado cero.
#nuevo experimento, miraremos si es igual al arrojado por nuestro algoritmo.
B = nx.blockmodel(G,Grupos)
#Re nombro los nodos para eliminar el nodo cero y que todo corresponda a los grupos encontrados en la funcion anterior.
mapping = {} #variable que guardara el nuevo valor de nodos.
cont = 0
for i in B.nodes(): #creo diccionario que guarda el nuevo valor de nodos.
mapping[cont] = cont + 1
cont += 1
A=nx.relabel_nodes(B,mapping) #asigno grafo con el nuevo valor de nodos.
NodosBorrar = []
cont_group = 1
cont = 1
for i in A.nodes():
if A.degree(cont_group) != 0:
cont += 1
if A.degree(cont_group) == 0:
NodosBorrar.append(cont_group)
cont_group += 1
for i in NodosBorrar: A.remove_node(i)
Nodes = A.number_of_nodes()
print "*vertices ", A.number_of_nodes()
cont = 1
for i in A.nodes():
print cont,'"Grupo', i, '"'
cont += 1
print "*Arcs"
for i in A.edges(): print i[0], i[1], int(A[i[0]][i[1]]['weight'])
pos = nx.spring_layout(A)
labels={}
cont = 1
for i in A.nodes():
colr = float(cont)/Nodes
nx.draw_networkx_nodes(A, pos, [i] , node_size = 250, node_color = str(colr), with_labels=True)
labels[i] = i
cont += 1
nx.draw_networkx_labels(A,pos,labels,font_size=5)
nx.draw_networkx_edges(A,pos, alpha=0.5)
plt.show()
def _neighbors(self, node, levels=1, graph=None):
"""Return graph of neighbors around node in graph (default: self.dataG)
to a certain number of levels"""
if graph is None:
graph = self.dataG
if not isinstance(node, (list, tuple, set)):
node = [node,]
neighbors = set(node)
blocks = [[n,] for n in node]
for i in range(levels):
for n in neighbors:
new_neighbors = set(graph.neighbors(n)) - neighbors
blocks.append(new_neighbors)
neighbors = neighbors.union(new_neighbors)
G = graph.subgraph(neighbors)
if len(blocks) > 1:
# Create a block repersentation of our graph and make sure we're plotting
# anything that connects the blocks too
# Create blocks for each individual node not already in a block
non_blocked = set(self.dataG.nodes()) - neighbors
non_blocked = [[a,] for a in non_blocked]
partitions = blocks + non_blocked
B = nx.blockmodel(graph, partitions)
# The resulting graph will has nodes numbered according their index in partitions
# We want to go through the partitions which are blocks and find the shortest path
num_blocks = len(blocks)
for frm_node, to_node in zip(range(num_blocks), range(1,num_blocks-1)):
try:
path = nx.shortest_path(B, frm_node, to_node)
except nx.NetworkXNoPath as e:
pass # In an island, which is permissible
except nx.NetworkXError as e:
tkm.showerror("Node not in graph", str(e))
return
else:
# Break path in B back down into path in G
path2 = []
for a in path[1:-1]: # don't include end points
for n in partitions[a]:
neighbors.add(n)
G = graph.subgraph(neighbors)
return G
def test_barbell_plus(self):
G = networkx.barbell_graph(3, 0)
G.add_edge(0, 5) # add extra edge between bells
partition = [[0, 1, 2], [3, 4, 5]]
M = networkx.blockmodel(G, partition)
assert_equal(sorted(M.nodes()), [0, 1])
assert_equal(sorted(M.edges()), [(0, 1)])
assert_equal(M[0][1]['weight'], 2)
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 3)
assert_equal(M.node[n]['nnodes'], 3)
assert_equal(M.node[n]['density'], 1.0)
def plot_additional(self, home_nodes, levels=0):
"""Add nodes to existing plot. Prompt to include link to existing
if possible. home_nodes are the nodes to add to the graph"""
new_nodes = self._neighbors(home_nodes, levels=levels)
new_nodes = home_nodes.union(new_nodes)
displayed_data_nodes = set(
[v['dataG_id'] for k, v in self.dispG.node.items()])
# It is possible the new nodes create a connection with the existing
# nodes; in such a case, we don't need to try to find the shortest
# path between the two blocks
current_num_islands = nx.number_connected_components(self.dispG)
new_num_islands = nx.number_connected_components(
self.dataG.subgraph(displayed_data_nodes.union(new_nodes)))
if new_num_islands > current_num_islands:
# Find shortest path between two blocks graph and, if it exists,
# ask the user if they'd like to include those nodes in the
# display as well.
# First, create a block model of our data graph where what is
# current displayed is a block, the new nodes are a a block
all_nodes = set(self.dataG.nodes())
singleton_nodes = all_nodes - displayed_data_nodes - new_nodes
singleton_nodes = map(lambda x: [x], singleton_nodes)
partitions = [displayed_data_nodes, new_nodes] + \
list(singleton_nodes)
B = nx.blockmodel(self.dataG, partitions, multigraph=True)
# Find shortest path between existing display (node 0) and
# new display island (node 1)
try:
path = nx.shortest_path(B, 0, 1)
except nx.NetworkXNoPath:
pass
else:
ans = tkm.askyesno(
"Plot path?", "A path exists between the "
"currently graph and the nodes you've asked to be added "
"to the display. Would you like to plot that path?")
if ans: # Yes to prompt
# Add the nodes from the source graph which are part of
# the path to the new_nodes set
# Don't include end points because they are the two islands
for u in path[1:-1]:
Gu = B.node[u]['graph'].nodes()
assert len(Gu) == 1
Gu = Gu[0]
new_nodes.add(Gu)
# Plot the new nodes
self._plot_additional(new_nodes)
def labeled_blockmodel(g,partition):
"""
Perform blockmodel transformation on graph *g*
and partition represented by dictionary *partition*.
Values of *partition* are used to partition the graph.
Keys of *partition* are used to label the nodes of the
new graph.
"""
new_g = nx.blockmodel(g,partition.values())
labels = dict(enumerate(partition.keys()))
new_g = nx.relabel_nodes(new_g,labels)
return new_g
def plot_dhc(PG, part, labels, lvl, pos):
fig = plt.figure(figsize=(9,6))
BM=nx.blockmodel(PG, part)
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[1 for (u,v,d) in BM.edges(data=True)]
BM_pos = nx.spring_layout(BM,iterations=200)
plt.axis("off")
plt.title("Block Model Clusters at level: {}".format(lvl))
nx.draw(BM, BM_pos,node_size=node_size,width=edge_width,with_labels=False)
fig = plt.figure(figsize=(9,6))
plt.axis("off")
plt.title("Node Clusters at level: {}".format(lvl))
nx.draw_networkx(PG, pos, node_size=45, cmap = plt.get_cmap("jet"), node_color=labels, with_labels = False)
def labeled_blockmodel(g, partition):
"""
Perform blockmodel transformation on graph *g*
and partition represented by dictionary *partition*.
Values of *partition* are used to partition the graph.
Keys of *partition* are used to label the nodes of the
new graph.
"""
new_g = nx.blockmodel(g, partition.values())
labels = dict(enumerate(partition.keys()))
new_g = nx.relabel_nodes(new_g, labels)
return new_g
def plot_dhc(PG, part, labels, lvl, pos):
fig = plt.figure(figsize=(9,6))
BM=nx.blockmodel(PG, part)
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[1 for (u,v,d) in BM.edges(data=True)]
BM_pos = nx.spring_layout(BM,iterations=200)
plt.axis("off")
plt.title("Block Model Clusters at level: {}".format(lvl))
nx.draw(BM, BM_pos,node_size=node_size,width=edge_width,with_labels=False)
fig = plt.figure(figsize=(9,6))
plt.axis("off")
plt.title("Node Clusters at level: {}".format(lvl))
nx.draw_networkx(PG, pos, node_size=45, cmap = plt.get_cmap("jet"), node_color=labels, with_labels = False)
def meta_mpg(g):
"""Meta Multimodal Probability Graph
Parameters
----------
g : nx.Graph
Multimodal probability graph
Returns
-------
G : nx.Graph
Multimodal probability graph where hard-linked nodes (p=1) are
grouped into meta-nodes
groups : list of lists
Groups of nodes
"""
# Group of hard-linked nodes
# (ie. nodes connected with probability p=1)
hard = nx.Graph()
hard.add_nodes_from(g)
hard.add_edges_from([(e,f) for e,f,d in g.edges_iter(data=True)
if d[PROBABILITY] == 1.])
groups = nx.connected_components(hard)
# meta graph with one node per group
G = nx.blockmodel(g, groups, multigraph=True)
meta = nx.Graph()
for n in range(len(groups)):
meta.add_node(n)
for m in range(n+1, len(groups)):
# do not do anything in case there is no edge
# between those two meta-nodes
if not G.has_edge(n, m):
continue
# obtain probabilities of all edges between n & m
probabilities = [data[PROBABILITY] for data in G[n][m].values()]
# raise an error in case of conflict (p=0 vs. p>0)
if len(set(probabilities)) > 1 and 0 in probabilities:
raise ValueError('conflict in meta-edges between %r and %r:' \
'probabilities = %r' % (groups[n],
groups[m],
probabilities))
meta.add_edge(n, m, {PROBABILITY: np.mean(probabilities)})
return meta, groups
def plot_additional(self, home_nodes, levels=0):
"""Add nodes to existing plot. Prompt to include link to existing
if possible. home_nodes are the nodes to add to the graph"""
new_nodes = self._neighbors(home_nodes, levels=levels)
new_nodes = home_nodes.union(new_nodes)
displayed_data_nodes = set([ v['dataG_id']
for k,v in self.dispG.node.items() ])
# It is possible the new nodes create a connection with the existing
# nodes; in such a case, we don't need to try to find the shortest
# path between the two blocks
current_num_islands = nx.number_connected_components(self.dispG)
new_num_islands = nx.number_connected_components(
self.dataG.subgraph(displayed_data_nodes.union(new_nodes)))
if new_num_islands > current_num_islands:
# Find shortest path between two blocks graph and, if it exists,
# ask the user if they'd like to include those nodes in the
# display as well.
# First, create a block model of our data graph where what is
# current displayed is a block, the new nodes are a a block
all_nodes = set(self.dataG.nodes())
singleton_nodes = all_nodes - displayed_data_nodes - new_nodes
singleton_nodes = map(lambda x: [x], singleton_nodes)
partitions = [displayed_data_nodes, new_nodes] + \
list(singleton_nodes)
B = nx.blockmodel(self.dataG, partitions, multigraph=True)
# Find shortest path between existing display (node 0) and
# new display island (node 1)
try:
path = nx.shortest_path(B, 0, 1)
except nx.NetworkXNoPath:
pass
else:
ans = tkm.askyesno("Plot path?", "A path exists between the "
"currently graph and the nodes you've asked to be added "
"to the display. Would you like to plot that path?")
if ans: # Yes to prompt
# Add the nodes from the source graph which are part of
# the path to the new_nodes set
# Don't include end points because they are the two islands
for u in path[1:-1]:
Gu = B.node[u]['graph'].nodes()
assert len(Gu) == 1; Gu = Gu[0]
new_nodes.add(Gu)
# Plot the new nodes
self._plot_additional(new_nodes)
def draw_hc(G, lvl):
plt.close()
plt.ion()
fig=plt.figure(figsize=(9,6))
plt.axis("off")
G=nx.convert_node_labels_to_integers(G)
partitions=create_hc(G)
BM=nx.blockmodel(G,partitions)
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[1 for (u,v,d) in BM.edges(data=True)]
pos = nx.spring_layout(BM,iterations=200)
nx.draw(BM,pos,node_size=node_size,width=edge_width,with_labels=False)
plt.title('Agglomerative Hierarchical Clustering for Citibike Network, lvl {}'.format(lvl))
plt.show()
return BM, partitions
def draw_hc(G, lvl):
plt.close()
plt.ion()
fig=plt.figure(figsize=(9,6))
plt.axis("off")
G=nx.convert_node_labels_to_integers(G)
partitions=create_hc(G)
BM=nx.blockmodel(G,partitions)
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[1 for (u,v,d) in BM.edges(data=True)]
pos = nx.spring_layout(BM,iterations=200)
nx.draw(BM,pos,node_size=node_size,width=edge_width,with_labels=False)
plt.title('Agglomerative Hierarchical Clustering for Citibike Network, lvl {}'.format(lvl))
plt.show()
return BM, partitions
def draw_graph(G, membership, filename=None):
partition = { i : [] for i in range(max(membership) + 1) }
for n,p in zip(list(range(len(G))),membership):
partition[p].append(n)
clustering = list(partition.values())
# print clustering
BM = nx.blockmodel(G, clustering)
# print BM.number_of_nodes(), G.number_of_nodes()
pyplot.clf()
posBM = nx.spring_layout(BM)
nx.draw(BM, posBM, with_labels=True)
# pyplot.show()
if filename:
pyplot.savefig(filename)
def test_weighted_path(self):
G=networkx.path_graph(6)
G[0][1]['weight']=1
G[1][2]['weight']=2
G[2][3]['weight']=3
G[3][4]['weight']=4
G[4][5]['weight']=5
partition=[[0,1],[2,3],[4,5]]
M=networkx.blockmodel(G,partition)
assert_equal(sorted(M.nodes()),[0,1,2])
assert_equal(sorted(M.edges()),[(0,1),(1,2)])
assert_equal(M[0][1]['weight'],2)
assert_equal(M[1][2]['weight'],4)
for n in M.nodes():
assert_equal(M.node[n]['nedges'],1)
assert_equal(M.node[n]['nnodes'],2)
assert_equal(M.node[n]['density'],1.0)
def test_weighted_path(self):
G = networkx.path_graph(6)
G[0][1]['weight'] = 1
G[1][2]['weight'] = 2
G[2][3]['weight'] = 3
G[3][4]['weight'] = 4
G[4][5]['weight'] = 5
partition = [[0, 1], [2, 3], [4, 5]]
M = networkx.blockmodel(G, partition)
assert_equal(sorted(M.nodes()), [0, 1, 2])
assert_equal(sorted(M.edges()), [(0, 1), (1, 2)])
assert_equal(M[0][1]['weight'], 2)
assert_equal(M[1][2]['weight'], 4)
for n in M.nodes():
assert_equal(M.node[n]['nedges'], 1)
assert_equal(M.node[n]['nnodes'], 2)
assert_equal(M.node[n]['density'], 1.0)
import networkx as nx
from networkx.drawing.nx_agraph import graphviz_layout
import matplotlib.pyplot as plt
def visualize_a_graph(graph):
pos = graphviz_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.5, edge_color='grey',
node_color='white', node_size=500, with_labels=True)
nx.draw_networkx_edge_labels(graph, pos)
nx.draw_networkx_labels(graph, pos)
plt.axis('off')
plt.show()
if __name__ == '__main__':
G = nx.path_graph(6)
visualize_a_graph(G)
partition = [[0, 1], [2, 3], [4, 5]]
graph = nx.Graph(nx.blockmodel(G, partition, multigraph=True))
visualize_a_graph(graph)
for n, p in zip(list(range(len(G))), membership):
partition[p].append(n)
return list(partition.values())
if __name__ == '__main__':
G = nx.read_edgelist("hartford_drug.edgelist")
# Extract largest connected component into graph H
H = nx.connected_component_subgraphs(G)[0]
# Makes life easier to have consecutively labeled integer nodes
H = nx.convert_node_labels_to_integers(H)
# Create parititions with hierarchical clustering
partitions = create_hc(H)
# Build blockmodel graph
BM = nx.blockmodel(H, partitions)
# Draw original graph
pos = nx.spring_layout(H, iterations=100)
fig = plt.figure(1, figsize=(6, 10))
ax = fig.add_subplot(211)
nx.draw(H, pos, with_labels=False, node_size=10)
plt.xlim(0, 1)
plt.ylim(0, 1)
# Draw block model with weighted edges and nodes sized by number of internal nodes
node_size = [BM.node[x]['nnodes'] * 10 for x in BM.nodes()]
edge_width = [(2 * d['weight']) for (u, v, d) in BM.edges(data=True)]
# Set positions to mean of positions of internal nodes from original graph
posBM = {}
for n in BM:
def create_block_diagram(graph, member_dict):
BM = nx.blockmodel(graph, member_dict.values())
return BM
xy_list_dict[label] = [line_to_xy_dict[xy_list[i]]]
nodes_chunks = []
for key in xy_list_dict.keys():
nodes_chunks.append(xy_list_dict[key])
new_line_xy_dict = {}
cluster_dict = {}
for i, chunk in enumerate(nodes_chunks):
coordinates = [line_xy_dict[ident] for ident in chunk]
com = numpy.sum(coordinates, 0) / len(coordinates)
new_line_xy_dict[i] = com
cluster_dict[i] = chunk
print('Performing blockmodels')
blocks_graph = nx.blockmodel(g, nodes_chunks, multigraph=True)
g = blocks_graph
#nx.draw(g, new_line_xy_dict, node_shape='.', alpha=0.002)
#plt.show()
edges = g.edges()
edges_weigth = {}
for e in edges:
try:
edges_weigth[e] += 1
except:
edges_weigth[e] = 1
new_edges = []
for e, weigth in edges_weigth.items():
if weigth < WEIGTH_THRESHOLD:
def test_overlapping(self):
G=networkx.path_graph(6)
partition=[[0,1,2],[2,3],[4,5]]
M=networkx.blockmodel(G,partition)
def test_overlapping(self):
G = networkx.path_graph(6)
partition = [[0, 1, 2], [2, 3], [4, 5]]
M = networkx.blockmodel(G, partition)
#H=nx.Graph()
ynode = []
for com in listsort:
xnode = []
for comnodes in com:
for node in G.nodes(data=True):
if int(node[1]['label']) == int(comnodes):
xnode.append(int(node[1]['id']))
xnode.sort()
bunch = [int(node[1]['id'])] + G.neighbors(int(node[1]['id']))
Gprime = G.subgraph(bunch)
H.add_edges_from(Gprime.edges())
ynode.append(xnode)
BM = nx.blockmodel(H, ynode)
#pos=nx.circular_layout(H)
pos = nx.graphviz_layout(H, prog='twopi')
#pos=nx.spring_layout(H, iterations = 50, weighted = False)
fig = plt.figure(figsize=(10, 10))
ax = fig.add_axes((0.0, 0.0, 1.0, 1.0))
nshells = len(ynode)
listcomattr = []
weightcom = []
comact = []
bmicom = []
for s in range(nshells):
def main(argv):
#Standardvalues
partitionfile = "data/partitions/final_partitions_p100_200_0.2.csv"
project = "584"
to_pajek = False
try:
opts, args = getopt.getopt(argv,"p:s:o")
except getopt.GetoptError:
print 'group_bridging.py -p <project_name> -s <partitionfile> -o [if you want pajek output]'
sys.exit(2)
for opt, arg in opts:
if opt in ("-p"):
project = arg
elif opt in ("-s"):
partitionfile = arg
elif opt in ("-o"):
to_pajek = True
else:
print 'group_bridging.py -p <project_name> -s <partitionfile> -o [if you want pajek output]'
print "##################### GROUP BRIDGING ########################"
print "Project %s " % project
print "Partition %s" % partitionfile
ff_edges_writer = csv.writer(open("results/%s_ff_bridging_edges.csv" % project, "wb"))
at_edges_writer = csv.writer(open("results/%s_at_bridging_edges.csv" % project, "wb"))
rt_edges_writer = csv.writer(open("results/%s_rt_bridging_edges.csv" % project, "wb"))
csv_bridging_writer = csv.writer(open('results/spss/group bridging/%s_group_bridging.csv' % project , 'wb'))
csv_bridging_writer.writerow(["Project", "Name", "Member_count", "Competing_Lists",
"FF_bin_degree", "FF_bin_in_degree", "FF_bin_out_degree",
"FF_volume_in","FF_volume_out",
"FF_bin_betweeness","FF_bin_closeness", "FF_bin_pagerank", #"FF_bin_eigenvector",
"FF_bin_c_size","FF_bin_c_density","FF_bin_c_hierarchy","FF_bin_c_index",
"AT_bin_degree", "AT_bin_in_degree", "AT_bin_out_degree",
"AT_bin_betweeness", "AT_bin_closeness", "AT_bin_pagerank", #"AT_bin_eigenvector",
"AT_bin_c_size","AT_bin_c_density","AT_bin_c_hierarchy","AT_bin_c_index",
"AT_volume_in", "AT_volume_out",
"RT_volume_in", "RT_volume_out",
"FF_rec", "AT_rec", "AT_avg", "FF_avg"])
# Get the overall network from disk
FF = nx.read_edgelist('data/networks/%s_FF.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph())
AT = nx.read_edgelist('data/networks/%s_solr_AT.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph())
RT = nx.read_edgelist('data/networks/%s_solr_RT.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph())
# Read in the partition
tmp = hp.get_partition(partitionfile)
partitions = tmp[0]
groups = tmp[1]
#Read in members count for each project
reader = csv.reader(open("results/stats/%s_lists_stats.csv" % project, "rb"), delimiter=",")
temp = {}
reader.next() # Skip first row
for row in reader:
temp[row[0]] = {"name":row[0],"member_count":int(row[3])}
#Read in the list-listings for individuals
listings = {}
indiv_reader = csv.reader(open(partitionfile))
for row in indiv_reader:
if listings.has_key(row[1]):
listings[row[1]]["competing_lists"] += int(row[3])
else:
listings[row[1]] = {"competing_lists": int(row[3])}
# Add dummy nodes if they are missing in the networks
for partition in partitions:
for node in partition:
FF.add_node(node)
AT.add_node(node)
RT.add_node(node)
#Blockmodel the networks into groups according to the partition
P_FF = nx.blockmodel(FF,partitions)
P_AT = nx.blockmodel(AT,partitions)
P_RT = nx.blockmodel(RT,partitions)
#Name the nodes in the network
#TODO check: How do I know that the names really match?
mapping = {}
mapping_pajek = {}
i = 0
for group in groups:
mapping_pajek[i] = "\"%s\"" % group # mapping for pajek
mapping[i] = "%s" % group
i += 1
H_FF = nx.relabel_nodes(P_FF,mapping)
H_AT = nx.relabel_nodes(P_AT,mapping)
H_RT = nx.relabel_nodes(P_RT,mapping)
#Outpt the networks to pajek if needed
if to_pajek:
OUT_FF = nx.relabel_nodes(P_FF,mapping_pajek)
OUT_AT = nx.relabel_nodes(P_AT,mapping_pajek)
OUT_RT = nx.relabel_nodes(P_RT,mapping_pajek)
#Write the blocked network out to disk
nx.write_pajek(OUT_FF,"results/networks/%s_grouped_FF.net" % project)
nx.write_pajek(OUT_AT,"results/networks/%s_grouped_AT.net" % project)
nx.write_pajek(OUT_RT,"results/networks/%s_grouped_RT.net" % project)
########## Output the Edges between groups to csv ##############
# Needed for the computation of individual bridging
# Edges in both directions between the groups are addded up
processed_edges = []
for (u,v,attrib) in H_FF.edges(data=True):
if "%s%s" %(u,v) not in processed_edges:
processed_edges.append("%s%s" % (u,v))
if H_FF.has_edge(v,u):
processed_edges.append("%s%s" % (v,u))
ff_edges_writer.writerow([u,v,attrib["weight"]+H_FF[v][u]["weight"]])
else:
ff_edges_writer.writerow([u,v,attrib["weight"]])
processed_edges = []
for (u,v,attrib) in H_AT.edges(data=True):
if "%s%s" %(u,v) not in processed_edges:
processed_edges.append("%s%s" % (u,v))
if H_AT.has_edge(v,u):
processed_edges.append("%s%s" % (v,u))
at_edges_writer.writerow([u,v,attrib["weight"]+H_AT[v][u]["weight"]])
else:
at_edges_writer.writerow([u,v,attrib["weight"]])
processed_edges = []
for (u,v,attrib) in H_RT.edges(data=True):
if "%s%s" %(u,v) not in processed_edges:
processed_edges.append("%s%s" % (u,v))
if H_RT.has_edge(v,u):
processed_edges.append("%s%s" % (v,u))
rt_edges_writer.writerow([u,v,attrib["weight"]+H_RT[v][u]["weight"]])
else:
rt_edges_writer.writerow([u,v,attrib["weight"]])
########## TRIM EDGES ################
# For meaningfull results we have to trim edges in the AT and FF network so the whole network just doesnt look like a blob
# It is chosen this way so the network remains as one component
THRESHOLD = min([hp.min_threshold(H_AT),hp.min_threshold(H_FF)])-1
H_FF = hp.trim_edges(H_FF, THRESHOLD)
H_AT = hp.trim_edges(H_AT, THRESHOLD)
########## MEASURES ##############
#Get the number of nodes in the aggregated networks
#FF_nodes = {}
#for node in H_FF.nodes(data=True):
# FF_nodes[node[0]] = node[1]["nnodes"]
#Get the FF network measures of the nodes
# Works fine on binarized Data
FF_bin_degree = nx.degree_centrality(H_FF)
FF_bin_in_degree = nx.in_degree_centrality(H_FF) # The attention paid towards this group
FF_bin_out_degree = nx.out_degree_centrality(H_FF) # The attention that this group pays towards other people
FF_bin_betweenness = nx.betweenness_centrality(H_FF,weight="weight") # How often is the group between other groups
FF_bin_closeness = nx.closeness_centrality(H_FF) #FF_bin_eigenvector = nx.eigenvector_centrality(H_FF)
FF_bin_pagerank = nx.pagerank(H_FF)
FF_bin_struc = sx.structural_holes(H_FF)
# AT network measures of the nodes
AT_bin_degree = nx.degree_centrality(H_AT)
AT_bin_in_degree = nx.in_degree_centrality(H_AT)
AT_bin_out_degree = nx.out_degree_centrality(H_AT)
AT_bin_betweenness = nx.betweenness_centrality(H_AT,weight="weight")
AT_bin_closeness = nx.closeness_centrality(H_AT) #AT_bin_eigenvector = nx.eigenvector_centrality(H_AT)
AT_bin_pagerank = nx.pagerank(H_AT)
AT_bin_struc = sx.structural_holes(H_AT)
# Tie strengths
dAT_avg_tie = hp.individual_average_tie_strength(H_AT)
dFF_avg_tie = hp.individual_average_tie_strength(H_FF)
dAT_rec = hp.individual_reciprocity(H_AT)
dFF_rec = hp.individual_reciprocity(H_FF)
# Dependent Variable see csv
# TODO A measure that calculates how often Tweets travel through this group: Eventually betweeness in the RT graph
#Arrange it in a list and output
for node in FF_bin_degree.keys():
csv_bridging_writer.writerow([project, node, int(temp[node]["member_count"]), listings[node]["competing_lists"],
FF_bin_degree[node], FF_bin_in_degree[node], FF_bin_out_degree[node],
H_FF.in_degree(node,weight="weight"), H_FF.out_degree(node,weight="weight"),
FF_bin_betweenness[node],FF_bin_closeness[node],FF_bin_pagerank[node], #FF_bin_eigenvector[node],
FF_bin_struc[node]['C-Size'],FF_bin_struc[node]['C-Density'],FF_bin_struc[node]['C-Hierarchy'],FF_bin_struc[node]['C-Index'],
AT_bin_degree[node], AT_bin_in_degree[node], AT_bin_out_degree[node],
AT_bin_betweenness[node], AT_bin_closeness[node], AT_bin_pagerank[node], #AT_bin_eigenvector[node],
AT_bin_struc[node]['C-Size'],AT_bin_struc[node]['C-Density'],AT_bin_struc[node]['C-Hierarchy'],AT_bin_struc[node]['C-Index'],
H_AT.in_degree(node,weight="weight"), H_AT.out_degree(node,weight="weight"),
H_RT.in_degree(node,weight="weight"), H_RT.out_degree(node,weight="weight"),
dFF_rec[node],dAT_rec[node],dAT_avg_tie[node],dFF_avg_tie[node]
])
partition=defaultdict(list)
for n,p in zip(list(range(len(G))),membership):
partition[p].append(n)
return list(partition.values())
if __name__ == '__main__':
G=nx.read_edgelist("hartford_drug.edgelist")
# Extract largest connected component into graph H
H=nx.connected_component_subgraphs(G)[0]
# Makes life easier to have consecutively labeled integer nodes
H=nx.convert_node_labels_to_integers(H)
# Create parititions with hierarchical clustering
partitions=create_hc(H)
# Build blockmodel graph
BM=nx.blockmodel(H,partitions)
# Draw original graph
pos=nx.spring_layout(H,iterations=100)
fig=plt.figure(1,figsize=(6,10))
ax=fig.add_subplot(211)
nx.draw(H,pos,with_labels=False,node_size=10)
plt.xlim(0,1)
plt.ylim(0,1)
# Draw block model with weighted edges and nodes sized by number of internal nodes
node_size=[BM.node[x]['nnodes']*10 for x in BM.nodes()]
edge_width=[(2*d['weight']) for (u,v,d) in BM.edges(data=True)]
# Set positions to mean of positions of internal nodes from original graph
posBM={}
