mobicen / plotterBCrealization.py @ master
History  View  Annotate  Download (6.18 KB)
1 
import code # code.interact(local=dict(globals(), **locals())) 

2 
import operator 
3 
from scipy import stats 
4 
from collections import defaultdict 
5 
import os 
6 
import sys 
7 
from statsmodels.graphics.tsaplots import plot_acf, acf 
8 
from matplotlib.colors import LinearSegmentedColormap 
9 
import pandas as pd 
10 
from pprint import pprint 
11 
import numpy as np 
12 
import glob 
13 
import matplotlib 
14 
# matplotlib.use('Agg')

15 
import matplotlib.pyplot as plt 
16 
import seaborn as sns 
17 
sns.set() 
18  
19  
20  
21 
folder = sys.argv[1]

22 
interval = 100

23 
if len(sys.argv) > 2: 
24 
interval = int(sys.argv[2]) 
25 
nick = folder.split('/')[2].split('_')[0]+"_" 
26  
27  
28 
os.chdir(folder) 
29  
30 
dfn = pd.DataFrame() # columns=node, rows= BC at rowindex timeinstant

31 
print "Loading data from", folder, "..." 
32 
for snap in sorted(glob.glob('./stats*')): 
33 
# print snap

34 
node_id = int(snap.strip('.csv').strip('./stats')) 
35 
df = pd.read_csv(snap, names=['time', str(node_id)], skiprows=1) 
36 
dfn = pd.concat([dfn, df[str(node_id)]], axis=1) 
37  
38 
#code.interact(local=dict(globals(), **locals()))

39  
40 
print "Processing and plotting..." 
41 
if not os.path.exists("plots"+nick): 
42 
os.makedirs("plots"+nick)

43 
os.chdir("plots"+nick)

44  
45 
nodes = range(len(dfn.columns)) 
46 
initialCentrality = {} 
47 
for n in nodes: 
48 
initialCentrality[n] = dfn.iloc[0][n]

49  
50 
n0 = dfn.iloc[:, 0]

51 
y = n0.values 
52  
53 
'''

54 
#Batch Means of ACF

55 
print "Bacth Means of ACF..."

56 
nlg=15

57 
memo=50

58 
batMeans = []

59 
for i in range(0, len(y)memo, memo):

60 
bacf = acf(y[i:i+memo], nlags=nlg)

61 
batMeans.append(np.mean(bacf))

62 

63 
pd.Series(batMeans).plot()

64 
plt.ylabel("Mean ACF for lags [0...15]")

65 
plt.xlabel("Batches of 50 samples")

66 
plt.savefig(nick+"batchMeansACF.pdf", format='pdf')

67 
plt.clf()'''

68  
69 
# BC realization of a random node

70 
print "BC realization of a random node..." 
71 
if not os.path.exists("BCreal"): 
72 
os.makedirs("BCreal")

73 
os.chdir("BCreal")

74  
75  
76 
for i in range(0, len(y)interval, interval): 
77 
plt.plot(range(i, i+interval, 1), y[i:i+interval]) 
78 
plt.ylim(min(y), max(y)) 
79 
plt.xlabel("Time [s]")

80 
plt.ylabel("Betweenness Centrality (NONnorm)")

81 
plt.savefig(nick+"BCrealization["+str(i) + 
82 
""+str(i+interval)+"].pdf", format='pdf') 
83 
plt.clf() 
84 
os.chdir("./..")

85  
86  
87 
'''

88 
# BC Heatmaps for consecutive timeframes

89 
print "BC Heatmaps for consecutive timeframes"

90 
if not os.path.exists("TimeFramesHeatmaps"):

91 
os.makedirs("TimeFramesHeatmaps")

92 

93 
os.chdir("TimeFramesHeatmaps")

94 
sns.set(font_scale=0.5)

95 

96 
for i in range(0, len(y)interval, interval):

97 
xticks = range(i, i+interval)

98 
#yticks=range(0, len(dfn),5)

99 
sns.heatmap(dfn.iloc[xticks].T, cmap="Spectral",

100 
xticklabels=xticks, cbar_kws={'label': 'BC'})

101 
#ax.set_xticks(range(i, i+interval))

102 
plt.xlabel("Time [sec]")

103 
plt.ylabel("Nodes")

104 
plt.yticks(rotation=0)

105 
plt.savefig(nick+"BCrealization["+str(i) +

106 
""+str(i+interval)+"].pdf", format='pdf')

107 
plt.clf()

108 
os.chdir("./..")

109 
sns.set(font_scale=1)

110 
'''

111  
112 
def coreNodesAtTime(t, perc): 
113 
BCd = dict(dfn.iloc[t])

114 
srtd_BC = sorted(BCd.items(), key=operator.itemgetter(1), reverse=True) 
115 
upto = int(len(srtd_BC) * (perc/100.0)) 
116 
coreNodes = [int(e[0]) for e in srtd_BC[:upto]] 
117 
coreDict = {k: v for k, v in srtd_BC[:upto]} 
118 
coreRank = {} 
119 
for i in range(upto): 
120 
coreRank[srtd_BC[i][0]] = i

121 
return coreDict, coreRank, coreNodes

122  
123  
124 
print "CoreResistence..." 
125 
'''dfCoreResist = pd.DataFrame()

126 
for t in range(len(dfn.iloc[0])):

127 
coreT, coreRankT, coreNodes = coreNodesAtTime(t, 20)

128 
corePD = pd.DataFrame(coreNodes)

129 
dfCoreResist = pd.concat([dfCoreResist, corePD], axis=1)'''

130 
activeMap = defaultdict(bool)

131 
coreResistMap = [{}] 
132 
firstCore = coreNodesAtTime(0, 20)[2] 
133 
for n in nodes: 
134 
flag = n in firstCore

135 
activeMap[n] = flag 
136 
coreResistMap[0][n] = flag

137  
138 
print "\tComputing ResistMap..." 
139 
for t in range(1, len(dfn.iloc[:,0])): 
140 
coreNodes = coreNodesAtTime(t, 20)[2] 
141 
old_Actives = [k for k, v in activeMap.items() if v] 
142 
#code.interact(local=dict(globals(), **locals()))

143 
# rimuovi chi non e' piu' nella top20

144 
for n in old_Actives: 
145 
if n not in coreNodes: 
146 
activeMap[n] = False

147 
# aggiungi i nuovi arrivatim chi si trova nella meta' alta

148 
for n in coreNodes[:len(coreNodes)/2]: 
149 
activeMap[n] = True

150 
# aggiorna la coreResistMap

151 
resistings = {} 
152 
for n in nodes: 
153 
if activeMap[n]:

154 
if n in coreNodes: 
155 
resistings[n] = True

156 
else:

157 
resistings[n] = False

158 
coreResistMap.append(resistings) 
159  
160 
print "\tPlotting ResistMap..." 
161 
cmap1 = LinearSegmentedColormap.from_list('mycmap1', ['white', 'blue'], 2) 
162 
resDF = pd.DataFrame(coreResistMap).T 
163  
164 
plt.ylabel("Nodes")

165 
plt.xlabel("Time")

166 
#sns.heatmap(resDF, cmap=cmap1, xticklabels=range(10000), yticklabels=range(650), cbar_kws={

167 
# 'label': '\"Core Or Not\" (Blue or White)'})

168  
169 
small=pd.DataFrame(resDF.iloc[:,0:1000]) 
170 
#code.interact(local=dict(globals(), **locals()))

171 
sns.heatmap(small.applymap(int), cmap=cmap1, xticklabels=range(1000), yticklabels=range(len(small)), cbar_kws={ 
172 
'label': '\"Core Or Not\" (Blue or White)'}) 
173  
174 
plt.savefig(nick+"coreResistMapEntryTOP10LeavingTOP20.pdf", format='pdf') 
175 
plt.clf() 
176  
177  
178 
def activeIntervals(v): 
179 
retval = [] 
180 
current = 0

181 
prev = False

182 
for i in range(0, len(v)): 
183 
if v[i]:

184 
if prev == False: 
185 
current += 1

186 
prev = True

187 
elif prev == True: 
188 
current += 1

189 
elif v[i] == False: 
190 
if prev == False: 
191 
continue

192 
elif prev == True: 
193 
retval.append(current) 
194 
current = 0

195 
prev = False

196 
return retval

197  
198 
#code.interact(local=dict(globals(), **locals()))

199 
print "Distribuzione tempo permanenza nel core..." 
200 
nodes2interval = {} 
201 
for n in nodes: 
202 
nodes2interval[n] = activeIntervals(resDF.iloc[n]) 
203  
204 
allint = [] 
205 
for e in nodes2interval.values(): 
206 
allint = allint+e 
207 
np.mean(allint) 
208  
209 
#code.interact(local=dict(globals(), **locals()))

210 
pd.DataFrame(allint).hist(bins=50,normed=True) 
211 
plt.xlabel("Intervals of Persistence in the core [sec]")

212 
plt.ylabel("Normalized Frequency")

213 
plt.savefig( 
214 
nick+"PersistenceDistributionEntryTOP10LeavingTOP20.pdf", format='pdf') 
215 
plt.clf() 
216  
217 
f = open(nick + "stats.txt", 'w') 
218 
f.write(str(pd.DataFrame(allint).describe()))

219 
f.close() 