1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
"""
Current-flow betweenness centrality measures.
"""
# Copyright (C) 2010 by
# Aric Hagberg <hagberg@lanl.gov>
# Dan Schult <dschult@colgate.edu>
# Pieter Swart <swart@lanl.gov>
# All rights reserved.
# BSD license.
__author__ = """Aric Hagberg (hagberg@lanl.gov)"""
__all__ = ['current_flow_betweenness_centrality',
'edge_current_flow_betweenness_centrality']
import networkx as nx
def current_flow_betweenness_centrality(G,normalized=True):
"""Compute current-flow betweenness centrality for nodes.
Current-flow betweenness centrality uses an electrical current
model for information spreading in contrast to betweenness
centrality which uses shortest paths.
Current-flow betweenness centrality is also known as
random-walk betweenness centrality [2]_.
Parameters
----------
G : graph
A networkx graph
normalized : bool, optional
If True the betweenness values are normalized by b=b/(n-1)(n-2) where
n is the number of nodes in G.
Returns
-------
nodes : dictionary
Dictionary of nodes with betweenness centrality as the value.
See Also
--------
betweenness_centrality
edge_betweenness_centrality
edge_current_flow_betweenness_centrality
Notes
-----
The algorithm is from Brandes [1]_.
If the edges have a 'weight' attribute they will be used as
weights in this algorithm. Unspecified weights are set to 1.
References
----------
.. [1] Centrality Measures Based on Current Flow.
Ulrik Brandes and Daniel Fleischer,
Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
http://www.inf.uni-konstanz.de/algo/publications/bf-cmbcf-05.pdf
.. [2] A measure of betweenness centrality based on random walks,
M. E. J. Newman, Social Networks 27, 39-54 (2005).
"""
try:
import numpy as np
except ImportError:
raise ImportError(
"""current_flow_betweenness_centrality() requires NumPy
http://scipy.org/""")
if G.is_directed():
raise nx.NetworkXError(\
"current_flow_betweenness_centrality() not defined for digraphs.")
if not nx.is_connected(G):
raise nx.NetworkXError("Graph not connected.")
betweenness=dict.fromkeys(G,0.0) # b[v]=0 for v in G
F=_compute_F(G) # Current-flow matrix
m,n=F.shape # m edges and n nodes
for (ei,(s,t)) in enumerate(G.edges_iter()):
# ei is index of edge
Fe=F[ei,:] # ei row of F
# rank of F[ei,v] in row Fe sorted in non-increasing order
pos=dict(zip(Fe.argsort()[::-1],xrange(1,n+1)))
for i in xrange(n):
betweenness[s]+=(i+1-pos[i])*Fe[i]
betweenness[t]+=(n-i-pos[i])*Fe[i]
if normalized:
nb=(n-1.0)*(n-2.0) # normalization factor
else:
nb=2.0
for i,vi in enumerate(G): # map integers to nodes
betweenness[vi]=(betweenness[vi]-i)*2.0/nb
return betweenness
def edge_current_flow_betweenness_centrality(G,normalized=True):
"""Compute current-flow betweenness centrality for edges.
Current-flow betweenness centrality uses an electrical current
model for information spreading in contrast to betweenness
centrality which uses shortest paths.
Current-flow betweenness centrality is also known as
random-walk betweenness centrality [2]_.
Parameters
----------
G : graph
A networkx graph
normalized : bool, optional
If True the betweenness values are normalized by b=b/(n-1)(n-2) where
n is the number of nodes in G.
Returns
-------
nodes : dictionary
Dictionary of edge tuples with betweenness centrality as the value.
See Also
--------
betweenness_centrality
edge_betweenness_centrality
current_flow_betweenness_centrality
Notes
-----
The algorithm is from Brandes [1]_.
If the edges have a 'weight' attribute they will be used as
weights in this algorithm. Unspecified weights are set to 1.
References
----------
.. [1] Centrality Measures Based on Current Flow.
Ulrik Brandes and Daniel Fleischer,
Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
http://www.inf.uni-konstanz.de/algo/publications/bf-cmbcf-05.pdf
.. [2] A measure of betweenness centrality based on random walks,
M. E. J. Newman, Social Networks 27, 39-54 (2005).
"""
from itertools import izip
try:
import numpy as np
except ImportError:
raise ImportError(
"""current_flow_betweenness_centrality() requires NumPy
http://scipy.org/""")
if G.is_directed():
raise nx.NetworkXError(\
"current_flow_closeness_centrality() not defined for digraphs.")
if not nx.is_connected(G):
raise nx.NetworkXError("Graph not connected.")
betweenness=(dict.fromkeys(G.edges(),0.0))
F=_compute_F(G) # Current-flow matrix
m,n=F.shape # m edges and n nodes
if normalized:
nb=(n-1.0)*(n-2.0) # normalization factor
else:
nb=2.0
for (ei,e) in enumerate(G.edges_iter()):
# ei is index of edge
Fe=F[ei,:] # ei row of F
# rank of F[ei,v] in row Fe sorted in non-increasing order
pos=dict(zip(Fe.argsort()[::-1],xrange(1,n+1)))
for i in xrange(n):
betweenness[e]+=(i+1-pos[i])*Fe[i]
betweenness[e]+=(n-i-pos[i])*Fe[i]
betweenness[e]/=nb
return betweenness
def _compute_C(G):
"""Inverse of Laplacian."""
try:
import numpy as np
except ImportError:
raise ImportError(
"""current_flow_betweenness_centrality() requires NumPy
http://scipy.org/""")
L=nx.laplacian(G) # use ordering of G.nodes()
# remove first row and column
LR=L[1:,1:]
LRinv=np.linalg.inv(LR)
C=np.zeros(L.shape)
C[1:,1:]=LRinv
return C
def _compute_F(G):
"""Current flow matrix."""
try:
import numpy as np
except ImportError:
raise ImportError(
"""current_flow_betweenness_centrality() requires NumPy
http://scipy.org/""")
C=np.asmatrix(_compute_C(G))
n=G.number_of_nodes()
m=G.number_of_edges()
B=np.zeros((n,m))
# use G.nodes() and G.edges() ordering of edges for B
mapping=dict(zip(G,xrange(n))) # map nodes to integers
for (ei,(v,w,d)) in enumerate(G.edges_iter(data=True)):
c=d.get('weight',1.0)
vi=mapping[v]
wi=mapping[w]
B[vi,ei]=c
B[wi,ei]=-c
return np.asarray(B.T*C)
|
