def test_subgraph_centrality_big_graph(self):
g199 = nx.complete_graph(199)
g200 = nx.complete_graph(200)
comm199 = nx.subgraph_centrality(g199)
comm199_exp = nx.subgraph_centrality_exp(g199)
comm200 = nx.subgraph_centrality(g200)
comm200_exp = nx.subgraph_centrality_exp(g200)
def test_subgraph_centrality_big_graph(self):
g199 = nx.complete_graph(199)
g200 = nx.complete_graph(200)
comm199 = nx.subgraph_centrality(g199)
comm199_exp = nx.subgraph_centrality_exp(g199)
comm200 = nx.subgraph_centrality(g200)
comm200_exp = nx.subgraph_centrality_exp(g200)
def subgraph_centraility(G, num_rounds, num_seeds):
centrality = nx.subgraph_centrality(G)
top_nodes = sorted(centrality.items(),
key=operator.itemgetter(1),
reverse=True)[:num_seeds]
highest_nodes = [i[0] for i in top_nodes]
return (highest_nodes * num_rounds)
def agregar_centralidad(G, criterio='degree', max_iter=100, tol=1e-3):
if criterio == 'degree':
nodes = list(G.nodes())
degree = list(dict(nx.degree(G)).values())
return nodes, degree
if criterio == 'eigen':
nodes = list(G.nodes())
eigen = list(
dict(nx.eigenvector_centrality(G, max_iter=max_iter,
tol=tol)).values())
return nodes, eigen
if criterio == 'sub':
nodes = list(G.nodes())
sub = list(dict(nx.subgraph_centrality(G)).values())
return nodes, sub
if criterio == 'bet':
nodes = list(G.nodes())
bet = list(dict(nx.betweenness_centrality(G)).values())
return nodes, bet
if criterio == 'flow':
nodes = list(G.nodes())
flow = list(dict(nx.current_flow_betweenness_centrality(G)).values())
return nodes, flow
if criterio == 'random':
nodes = list(G.nodes())
value = random.choice(nodes)
return value, nodes
def rank_centrality(top_k_words, top_k, word_in_file):
for i, cluster in enumerate(top_k):
cluster = np.array(cluster)
subgraph = calc_coo_matrix(top_k_words[i], word_in_file)
G = nx.from_numpy_matrix(subgraph)
sc = nx.subgraph_centrality(G)
ind = np.argsort([sc[node]
for node in sorted(sc)])[-10:][::-1].astype(int)
top_k_words[i] = np.array(top_k_words[i])[ind]
return top_k_words
def RemoveNodes(RED, method):
# Función que remueve los nodos.
red = RED.copy()
print('\n', method)
x = []
y = []
N0 = red.number_of_nodes()
print('Cantidad inicial de nodos de la red %s:\t%d' % (s, N0))
giant = max(nx.connected_component_subgraphs(red), key=len)
largest_component = giant.number_of_nodes()
# Se remueven los nodos según el método:
while largest_component > 1:
if method == 'Random':
Node = np.random.choice(list(red.nodes))
elif method == 'Degree':
D = dict(nx.degree_centrality(red))
Node = max(D, key=D.get)
elif method == 'Eigenvector':
D = dict(nx.eigenvector_centrality(red, tol=1e-03))
Node = max(D, key=D.get)
elif method == 'Subgraph':
D = dict(nx.subgraph_centrality(red))
Node = max(D, key=D.get)
elif method == 'Shortest path':
D = dict(nx.betweenness_centrality(red))
Node = max(D, key=D.get)
elif method == 'Current flow':
D = dict(nx.current_flow_betweenness_centrality(red))
Node = max(D, key=D.get)
red.remove_node(Node)
giant = max(nx.connected_component_subgraphs(red), key=len)
largest_component = giant.number_of_nodes()
N = red.number_of_nodes()
print('\rNodos restantes:\t%4d' % (N), end='')
x.append(1 - N / N0)
y.append(largest_component / N)
np.save(path + '%s-x_%s' % (s, method), x)
np.save(path + '%s-y_%s' % (s, method), y)
plt.plot(x, y, label=method)
return
def set_capacities_communicability_gravity(topology, capacities,
capacity_unit='Mbps'):
"""
Set link capacities proportionally to the product of the communicability
centralities of the two end-points of the link
Parameters
----------
topology : Topology
The topology to which link capacities will be set
capacities : list
A list of all possible capacity values
capacity_unit : str, optional
The unit in which capacity value is expressed (e.g. Mbps, Gbps etc..)
"""
if LooseVersion(nx.__version__) < LooseVersion("2.0"):
centrality = nx.communicability_centrality(topology)
else:
centrality = nx.subgraph_centrality(topology)
_set_capacities_gravity(topology, capacities, centrality, capacity_unit)
def set_capacities_communicability_gravity(topology,
capacities,
capacity_unit='Mbps'):
"""
Set link capacities proportionally to the product of the communicability
centralities of the two end-points of the link
Parameters
----------
topology : Topology
The topology to which link capacities will be set
capacities : list
A list of all possible capacity values
capacity_unit : str, optional
The unit in which capacity value is expressed (e.g. Mbps, Gbps etc..)
"""
if LooseVersion(nx.__version__) < LooseVersion("2.0"):
centrality = nx.communicability_centrality(topology)
else:
centrality = nx.subgraph_centrality(topology)
_set_capacities_gravity(topology, capacities, centrality, capacity_unit)
def test_subgraph_centrality():
''' Check subgraph centrality with networkx implementation '''
num_nodes = 5
edge_list = [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (2, 4), (3, 4)]
# this test requires networkx as backend
nngt.use_backend("networkx")
g = nngt.Graph(num_nodes, directed=False)
g.new_edges(edge_list)
# test full centralities
import networkx as nx
sc_nx = nx.subgraph_centrality(g.graph)
sc_nx = np.array([sc_nx[i] for i in range(num_nodes)])
sc_nngt = nngt.analysis.subgraph_centrality(g,
weights=False,
normalize=False)
assert np.all(np.isclose(sc_nx, sc_nngt))
# test max_centrality
sc_nngt = nngt.analysis.subgraph_centrality(g,
weights=False,
normalize="max_centrality")
assert np.all(np.isclose(sc_nx / sc_nx.max(), sc_nngt))
# test subpart
sc_nngt = nngt.analysis.subgraph_centrality(g,
weights=False,
normalize=False,
nodes=[0, 1])
assert np.all(np.isclose(sc_nx[:2], sc_nngt))
def subg(g):
g = g.to_undirected()
return nx.subgraph_centrality(g)
qposts.loc[:, 'firsttag'] = qposts['TagList'].apply(lambda x: x[0])
# topics are the tags most frequently occurring as first tag
firstagdf = qposts['firsttag'].value_counts()
### using graphs
datag = data.copy()
datag.loc[:, 'forgraph'] = datag.apply(lambda x: (x['index'], x['columns'], {
'weight': x['freq']
}),
axis=1)
G = nx.Graph()
G.add_edges_from(datag['forgraph'].tolist())
### MEASURE OF CENTER IN SUBGRAPHS - topics are the most central
centr_subgraph = nx.subgraph_centrality(G)
centr_subgraphdf = pd.DataFrame({
'tag':
list(centr_subgraph.keys()),
'subgraphcentrality':
list(centr_subgraph.values())
})
centr_subgraphdf = centr_subgraphdf.sort_values(by='subgraphcentrality',
ascending=False)
### MEASURE OF CENTER IN GRAPH - topics are the most central
centrality = nx.degree_centrality(G)
centrdf = pd.DataFrame({
'tag': list(centrality.keys()),
'centrality': list(centrality.values())
})
def drawGraph(G, pos, a, labels):
print(globalLabSize, "glob")
#Changing G for threshold here
#Check filter metric
if (globalOptionsMet4 == "Default"):
G = G
if (globalOptionsMet4 == "Degree"):
displayedNodes = []
nx.set_node_attributes(G,
values=nx.degree_centrality(G),
name='degree')
for node, data in G.nodes(data=True):
if (data['degree'] > threshold):
displayedNodes.append(node)
G = G.subgraph(displayedNodes)
if (globalOptionsMet4 == "Between Centrality"):
displayedNodes = []
# Metrics computing
betweenCentralities = nx.betweenness_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=betweenCentralities,
name='betweenCentrality')
# iterate trough nodes
for node, data in G.nodes(data=True):
if (data['betweenCentrality'] > threshold):
displayedNodes.append(node)
G = G.subgraph(displayedNodes)
if (globalOptionsMet4 == "Load Centrality"):
displayedNodes = []
# Metrics computing
loadCentralities = nx.load_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=loadCentralities,
name='loadCentrality')
# iterate trough nodes
for node, data in G.nodes(data=True):
if (data['loadCentrality'] > threshold):
displayedNodes.append(node)
G = G.subgraph(displayedNodes)
if (globalOptionsMet4 == "Subgraph Centrality"):
displayedNodes = []
# Metrics computing
subgraphCentralities = nx.subgraph_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=subgraphCentralities,
name='subgraphCentrality')
# iterate trough nodes
for node, data in G.nodes(data=True):
if (data['subgraphCentrality'] > threshold):
displayedNodes.append(node)
G = G.subgraph(displayedNodes)
#Choosing size, the size list will be defined here for the rest of the function
sizeM = maxSize
sizes = []
if (globalOptionsMet3 == "Default"):
for node, data in G.nodes(data=True):
sizes.append(sizeM)
if (globalOptionsMet3 == "Degree"):
degrees = nx.degree_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G, values=degrees, name='degree')
# minmax
minDeg = min(degrees.values())
maxDeg = max(degrees.values())
#loop trough nodes
for node, data in G.nodes(data=True):
sizes.append(
(normalizeSize(data['degree'], maxDeg, minDeg, sizeM) + 5))
if (globalOptionsMet3 == "Between Centrality"):
# Metrics computing
betweenCentralities = nx.betweenness_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=betweenCentralities,
name='betweenCentrality')
# minmax
minBetween = min(betweenCentralities.values())
maxBetween = max(betweenCentralities.values())
#loop trough nodes
for node, data in G.nodes(data=True):
sizes.append((normalizeSize(data['betweenCentrality'], maxBetween,
minBetween, sizeM) + 5))
if (globalOptionsMet3 == "Load Centrality"):
# Metrics computing
loadCentralities = nx.load_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=loadCentralities,
name='loadCentrality')
# minmax
minLoad = min(loadCentralities.values())
maxLoad = max(loadCentralities.values())
#loop trough nodes
for node, data in G.nodes(data=True):
sizes.append((normalizeSize(data['loadCentrality'], maxLoad,
minLoad, sizeM) + 5))
if (globalOptionsMet3 == "Subgraph Centrality"):
# Metrics computing
subgraphCentralities = nx.subgraph_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=subgraphCentralities,
name='subgraphCentrality')
# minmax
minSub = min(subgraphCentralities.values())
maxSub = max(subgraphCentralities.values())
#loop trough nodes
for node, data in G.nodes(data=True):
sizes.append((normalizeSize(data['subgraphCentrality'], maxSub,
minSub, sizeM) + 5))
#Choosing cmap for colors
cmapChosen = plt.cm.viridis
if (cmap1 == "Viridis"):
cmapChosen = plt.cm.viridis
if (cmap1 == "Magma"):
cmapChosen = plt.cm.magma
if (cmap1 == "Plasma"):
cmapChosen = plt.cm.plasma
if (cmap1 == "Blues"):
cmapChosen = plt.cm.Blues
if (cmap1 == "Purples"):
cmapChosen = plt.cm.Purples
if (cmap1 == "Reds"):
cmapChosen = plt.cm.Reds
if (cmap1 == "Greens"):
cmapChosen = plt.cm.Greens
if (cmap1 == "YlOrRd"):
cmapChosen = plt.cm.YlOrRd
#drawing
if (globalOptionsMet2 == "Default"):
labelDic = nx.get_node_attributes(G, 'label')
nx.draw_networkx_nodes(G,
pos=pos,
ax=a,
node_color=range(len(G)),
cmap=cmapChosen,
node_size=sizes)
nx.draw_networkx_edges(G,
pos,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity,
ax=a)
if (labels):
nx.draw_networkx_labels(G,
pos,
font_size=globalLabSize,
ax=a,
font_color=globalLabelCol)
if (globalOptionsMet2 == "Communities"):
cmapUsed = ""
if (cmap1 == "Pale"):
cmapUsed = ListedColormap(
palettable.colorbrewer.qualitative.Set3_12.mpl_colors,
N=len(G))
if (cmap1 == "Bright"):
cmapUsed = ListedColormap(
palettable.colorbrewer.qualitative.Set1_9.mpl_colors, N=len(G))
partition = community.best_partition(G)
labelSet = nx.get_node_attributes(G, 'label')
size = float(len(set(partition.values())))
count = 0.
for com in set(partition.values()):
count = count + 1.
list_nodes = [
nodes for nodes in partition.keys() if partition[nodes] == com
]
nx.draw_networkx_nodes(G,
pos,
list_nodes,
label=labelSet,
node_color=cmapUsed(com),
ax=a,
node_size=sizes)
nx.draw_networkx_edges(G,
pos,
ax=a,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity)
if (labels):
nx.draw_networkx_labels(G,
pos,
ax=a,
font_size=globalLabSize,
font_color=globalLabelCol)
if (globalOptionsMet2 == "Degree"):
# Metrics computing
degrees = nx.degree_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G, values=degrees, name='degree')
# minmax
minDeg = min(degrees.values())
maxDeg = max(degrees.values())
colDeg = []
# Set the colors that could be used next
for node, data in G.nodes(data=True):
colDeg.append(normalize(data['degree'], maxDeg, minDeg))
nx.draw_networkx_nodes(G,
pos=pos,
vmax=1,
vmin=0,
cmap=cmapChosen,
with_labels=labels,
node_size=sizes,
node_color=colDeg,
ax=a)
nx.draw_networkx_edges(G,
pos,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity,
ax=a)
if (labels):
nx.draw_networkx_labels(G,
pos,
font_size=globalLabSize,
ax=a,
font_color=globalLabelCol)
if (globalOptionsMet2 == "Between Centrality"):
# Metrics computing
betweenCentralities = nx.betweenness_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=betweenCentralities,
name='betweenCentrality')
# minmax
minBetween = min(betweenCentralities.values())
maxBetween = max(betweenCentralities.values())
colBetween = []
# Set the colors that could be used next
for node, data in G.nodes(data=True):
colBetween.append(
normalize(data['betweenCentrality'], maxBetween, minBetween))
nx.draw_networkx_nodes(G,
pos=pos,
vmax=1,
vmin=0,
cmap=cmapChosen,
with_labels=labels,
node_size=sizes,
node_color=colBetween,
ax=a)
nx.draw_networkx_edges(G,
pos,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity,
ax=a)
if (labels):
nx.draw_networkx_labels(G,
pos,
font_size=globalLabSize,
ax=a,
font_color=globalLabelCol)
if (globalOptionsMet2 == "Subgraph Centrality"):
# Metrics computing
subgraphCentralities = nx.subgraph_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=subgraphCentralities,
name='subgraphCentrality')
# minmax
minSub = min(subgraphCentralities.values())
maxSub = max(subgraphCentralities.values())
colSub = []
# Set the colors that could be used next
for node, data in G.nodes(data=True):
colSub.append(normalize(data['subgraphCentrality'], maxSub,
minSub))
nx.draw_networkx_nodes(G,
pos=pos,
vmax=1,
vmin=0,
cmap=cmapChosen,
with_labels=labels,
node_size=sizes,
node_color=colSub,
ax=a)
nx.draw_networkx_edges(G,
pos,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity,
ax=a)
if (labels):
nx.draw_networkx_labels(G,
pos,
font_size=globalLabSize,
ax=a,
font_color=globalLabelCol)
if (globalOptionsMet2 == "Load Centrality"):
# Metrics computing
loadCentralities = nx.load_centrality(G)
# Add metrics as params of the nodes
nx.set_node_attributes(G,
values=loadCentralities,
name='loadCentrality')
# minmax
minLoad = min(loadCentralities.values())
maxLoad = max(loadCentralities.values())
colLoad = []
# Set the colors that could be used next
for node, data in G.nodes(data=True):
colLoad.append(normalize(data['loadCentrality'], maxLoad, minLoad))
nx.draw_networkx_nodes(G,
pos=pos,
vmax=1,
vmin=0,
cmap=cmapChosen,
with_labels=labels,
node_size=sizes,
node_color=colLoad,
ax=a)
nx.draw_networkx_edges(G,
pos,
edge_color=globalEdgeCol,
style=globalEdgeType,
alpha=globalEdgeOpacity,
ax=a)
if (labels):
nx.draw_networkx_labels(G,
pos,
font_size=globalLabSize,
ax=a,
font_color=globalLabelCol)
def get_subgraph(graph, run):
if run:
centrality = nx.subgraph_centrality(graph)
df = pd.DataFrame(centrality, index=['Subgraph Centrality'])
return df
def compute_subgraph_center(self, subgraph):
if self.method == 'betweenness_centrality':
d = nx.betweenness_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'betweenness_centrality_subset':
d = nx.betweenness_centrality_subset(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'information_centrality':
d = nx.information_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'local_reaching_centrality':
d = {}
for n in self.G.nodes():
d[n] = nx.local_reaching_centrality(self.G, n, weight='weight')
center = max(d, key=d.get)
elif self.method == 'voterank':
d = nx.voterank(subgraph)
center = max(d, key=d.get)
elif self.method == 'percolation_centrality':
d = nx.percolation_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'subgraph_centrality':
d = nx.subgraph_centrality(subgraph)
center = max(d, key=d.get)
elif self.method == 'subgraph_centrality_exp':
d = nx.subgraph_centrality_exp(subgraph)
center = max(d, key=d.get)
elif self.method == 'estrada_index':
d = nx.estrada_index(subgraph)
center = max(d, key=d.get)
elif self.method == 'second_order_centrality':
d = nx.second_order_centrality(subgraph)
center = max(d, key=d.get)
elif self.method == 'eigenvector_centrality':
d = nx.eigenvector_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'load_centrality':
d = nx.load_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'closeness_centrality':
d = nx.closeness_centrality(subgraph)
center = max(d, key=d.get)
elif self.method == 'current_flow_closeness_centrality':
d = nx.current_flow_closeness_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'current_flow_betweenness_centrality':
d = nx.current_flow_betweenness_centrality(subgraph,
weight='weight')
center = max(d, key=d.get)
elif self.method == 'current_flow_betweenness_centrality_subset':
d = nx.current_flow_betweenness_centrality_subset(subgraph,
weight='weight')
center = max(d, key=d.get)
elif self.method == 'approximate_current_flow_betweenness_centrality':
d = nx.approximate_current_flow_betweenness_centrality(
subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'harmonic_centrality':
d = nx.harmonic_centrality(subgraph)
center = max(d, key=d.get)
elif self.method == 'page_rank':
d = nx.pagerank(subgraph, weight='weight')
center = max(d, key=d.get)
elif self.method == 'hits':
d = nx.hits(subgraph)
center = max(d, key=d.get)
elif self.method == 'katz_centrality':
d = nx.katz_centrality(subgraph, weight='weight')
center = max(d, key=d.get)
else:
new_centers = nx.center(subgraph)
# new_centers gives a list of centers and here we just pick one randomly --not good for stability
# to do : find a better way to choose the center--make it stable
index = random.randint(0, len(new_centers) - 1)
center = new_centers[index]
return center
def calc_centralities(G,org_name,string_version):
print("Calculating centralities")
centrality_measures = {}
string_location=f.string_version_data(string_version)[0]
print(string_location)
# if 1==0:
if os.path.isfile('centrality_data/%s/%s.cent'%(string_location,org_name)):
print("Using cached centrality data")
file=open('centrality_data/%s/%s.cent'%(string_location,org_name))
lines=file.readlines()
centrality_list=lines.pop(0).strip().split(' ')
centrality_list.pop(0)
for i,centrality in enumerate(centrality_list):
centrality_measures[centrality]={}
for line in lines:
value_list=line.split(' ')
for i,centrality in enumerate(centrality_list):
# print("%d. %s" % (i+1,centrality))
centrality_measures[centrality][value_list[0]]=float(value_list[i+1])
else:
print("1. Degree centrality")
centrality_measures['Degree_Centrality']=nx.degree_centrality(G)
print("2. Closeness centrality")
centrality_measures['Closeness_Centrality']=Counter(nx.algorithms.centrality.closeness_centrality(G))
print("3. Betweenness centrality")
centrality_measures['Betweenness_Centrality']=Counter(nx.algorithms.centrality.betweenness_centrality(G))
print("4. Clustering coefficient")
centrality_measures['Clustering_Co-efficient']=Counter(nx.clustering(G))
print("5. Eigenvector centrality")
centrality_measures['Eigenvector_Centrality']= nx.eigenvector_centrality(G)
print("6. Subgraph centrality")
centrality_measures["Subgraph_Centrality"]=nx.subgraph_centrality(G)
print("7. Information centrality")
centrality_measures["Information_Centrality"]=nx.current_flow_closeness_centrality(f.trim_graph(G))
print("8. Clique Number")
cliq={}
for i in G.nodes():
cliq[i]=nx.node_clique_number(G,i)
centrality_measures["Clique_Number"]=cliq
print("9. Edge clustering coefficient")
edge_clus_coeff={}
for n in G.nodes:
edge_clus_coeff[n]=0
for e in G.edges(n):
num=len(list(nx.common_neighbors(G,e[0],e[1])))
den=(min(G.degree(e[0]),G.degree(e[1]))-1)
if den==0:
den=1
edge_clus_coeff[n]+=num/den
centrality_measures['Edge_Clustering_Coefficient']=edge_clus_coeff
print("10. Page Rank")
centrality_measures['Page_Rank']=nx.pagerank(G)
print("11. Random Walk Betweenness Centrality")
centrality_measures["Random_Walk_Betweenness_Centrality"]=nx.current_flow_betweenness_centrality(f.trim_graph(G))
print("12. Load Centrality")
centrality_measures["Load_Centrality"]=nx.load_centrality(G)
print("13. Communicability Betweenness")
centrality_measures["Communicability_Betweenness"]=nx.communicability_betweenness_centrality(f.trim_graph(G))
print("14. Harmonic Centrality")
centrality_measures["Harmonic_Centrality"]=nx.harmonic_centrality(G)
print("15. Reaching Centrality")
reach_cent={}
for node in G.nodes:
reach_cent[node] = nx.local_reaching_centrality(G,node)
centrality_measures["Reaching_Centrality"]=reach_cent
print("16. Katz Centrality(not calculated)")
# centrality_measures["Katz_Centrality"]=nx.katz_centrality(G)
datafile=open("refex_props/%s.refex" % (org_name))
sample_line=datafile.readline()
s= sample_line.strip().split(' ')
for x in range(1,len(s)):
centrality_measures["refex#%d" % (x)]={}
for line in datafile:
props=line.strip().split(" ")
props=[i.strip('\t') for i in props]
for x in range(1,len(s)):
centrality_measures["refex#%d" % (x)][props[0]]=float(props[x])
datafile=open("refex_rider_props/%s.riderproperties" % (org_name))
sample_line=datafile.readline()
s= sample_line.strip().split(' ')
s.pop(1)
print(len(s))
for x in range(1,len(s)):
centrality_measures["refex_rider#%d" % (x)]={}
for line in datafile:
props=line.strip().split(" ")
props.pop(1)
for x in range(1,len(props)):
centrality_measures["refex_rider#%d" % (x)][props[0]]=float(props[x])
with open('centrality_data/%s/%s.cent'%(string_location,org_name),'w') as file:
file.write(str(org_name)+' ')
centrality_list=list(centrality_measures)
for x in centrality_list:
file.write(str(x)+' ')
for node in G.nodes:
file.write('\n'+node+' ')
for x in centrality_list:
if node not in centrality_measures[x]:
file.write('-1 ')
else:
file.write(str(centrality_measures[x][node])+' ')
return centrality_measures
#Get edge list from the file
edgelist = [(row['protein1'], row['protein2']) for index, row in file.iterrows()]
# Create graph for the virus-human PPI network
G = nx.Graph()
G.add_edges_from(edgelist)
# Print the virus-human PPI network info
print(nx.info(G))
deg_centrality = nx.degree_centrality(G)
eig_vec_centrality = nx.eigenvector_centrality(G)
close_centrality = nx.closeness_centrality(G)
#egde_betw_centrality = nx.edge_betweenness_centrality(G)
harm_centrality = nx.harmonic_centrality(G)
ld_centrality = nx.load_centrality(G)
subg_centrality = nx.subgraph_centrality(G)
centrality_df = pd.DataFrame({'prot_id': list(deg_centrality.keys()) , #add nodes
'degree_centrality': list(deg_centrality.values()) , #add degree centrality
'eigen_vector_centrality': list(eig_vec_centrality.values()), #add eigen vector centrality
'close_centrality': list(close_centrality.values()), #add closeness centrality
#'edge_betweenness': , #add edge betweenness
'harmonic_centrality': list(harm_centrality.values()), #add harmonic centrality
'load_centrality': list(ld_centrality.values()), #add load centrality
'subgraph_centrality': list(subg_centrality.values()) #add subg centrality
})
#centrality_df.to_csv("centrality_measures_hhv1.csv",index=False)
plt.show()
nx.draw(g1, with_labels=1)
plt.title("Example visualization of Maslov-Snepen graph")
plt.show()
list_of_weighted_cms_lists = []
list_of_unweighted_cms_lists = []
# Centrality measurements for weighted graphs
for i in listOfWeightedGraphs:
centrality_measurements = []
centrality_measurements.append(list(nx.degree_centrality(i).values()))
centrality_measurements.append(list(nx.eigenvector_centrality(i).values()))
centrality_measurements.append(list(nx.betweenness_centrality(i).values()))
centrality_measurements.append(list(nx.subgraph_centrality(i).values()))
centrality_measurements.append(list(nx.katz_centrality_numpy(i).values()))
centrality_measurements.append(list(nx.pagerank(i).values()))
centrality_measurements.append(list(nx.closeness_centrality(i).values()))
#centrality_measurements.append(list(nx.current_flow_betweenness_centrality(i).values()))
#centrality_measurements.append(list(nx.communicability_betweenness_centrality(i).values()))
#centrality_measurements.append(list(nx.average_neighbor_degree(i).values()))
list_of_weighted_cms_lists.append(centrality_measurements)
# Centrality measurements for unweighted graphs
for i in listOfUnweightedGraphs:
centrality_measurements = []
centrality_measurements.append(list(nx.degree_centrality(i).values()))
centrality_measurements.append(list(nx.eigenvector_centrality(i).values()))
centrality_measurements.append(list(nx.betweenness_centrality(i).values()))
centrality_measurements.append(list(nx.subgraph_centrality(i).values()))
