mobility-Centrality

import seaborn as sns

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

from collections import deque

from scipy import stats

import matplotlib.pyplot as plt

from collections import defaultdict

import os

import sys

from statsmodels.graphics.tsaplots import plot_acf

from statsmodels.tsa.stattools import acf

import operator

from mpl_toolkits import mplot3d

import pandas as pd

from pprint import pprint

import numpy as np

import glob

from tqdm import tqdm

import matplotlib

#mys.rank(method='first', ascending=False)

folder = sys.argv[1]

lags = 100

if len(sys.argv) > 2:

    lags = int(sys.argv[2])

nick = folder.split('/')[-2].split('_')[0]

os.chdir(folder)

bcdf = pd.DataFrame()  # rows=nodes columns=BC at column-index time-instant

degdf = pd.DataFrame()  # rows=nodes columns=DEG at column-index time-instant

kcoredf = pd.DataFrame()  # rows=nodes columns=KCORE at column-index time-instant

print "Loading data from", folder, "..."

for snap in sorted(glob.glob('./stats*')):

    # print "",snap

    node_id = int(snap.strip('.csv').strip('./stats'))

    df = pd.read_csv(snap, names=['time', 'bc', 'deg', 'kcore'], skiprows=1)

    bcdf = pd.concat([bcdf, df['bc']], axis=1)

    degdf = pd.concat([degdf, df['deg']], axis=1)

    kcoredf = pd.concat([kcoredf, df['kcore']], axis=1)

nodes = range(len(bcdf.columns))

'''initialCentrality = {}

for n in nodes:

    initialCentrality[int(n)] = bcdf.iloc[0][n]

sorted_x = sorted(initialCentrality.items(),

                  key=operator.itemgetter(1), reverse=True)

srtNodes = [e[0] for e in sorted_x]'''

bcACF = pd.DataFrame()  # rows=Time-Lags, columns = nodes

degACF = pd.DataFrame()  # rows=Time-Lags, columns = nodes

kcoreACF = pd.DataFrame()  # rows=Time-Lags, columns = nodes

print "Processing data..."

for node in nodes:

    # print "Autocorr of node", node

    nodebcACF = pd.DataFrame([bcdf.iloc[:, node].autocorr(lag)

                              for lag in range(lags)])

    bcACF = pd.concat([bcACF, nodebcACF], axis=1)

    nodedegACF = pd.DataFrame(

        [degdf.iloc[:, node].autocorr(lag) for lag in range(lags)])

    degACF = pd.concat([degACF, nodedegACF], axis=1)

    nodekcoreACF = pd.DataFrame(

        [kcoredf.iloc[:, node].autocorr(lag) for lag in range(lags)])

    kcoreACF = pd.concat([kcoreACF, nodekcoreACF], axis=1)

'''

X ==> time-lag

Y ==> i nodi in ordine di centralita a tempo_0

Z ==> l'acf del nodo y al time-lag x

'''

if not os.path.exists("plots"+nick):

    os.makedirs("plots"+nick)

os.chdir("plots"+nick)

# Plotting

# ACF boxplots

bcACF.T.boxplot(column=[1]+range(5, lags, 5))

plt.ylabel("ACF of BC for all nodes")

plt.xlabel("Time-lag")

plt.xticks(rotation="vertical")

plt.axhline(y=0.2, color='k', linestyle='--', lw=1.2)

plt.axhline(y=0.0, color='k', linestyle='--', lw=2)

plt.axhline(y=-0.2, color='k', linestyle='--', lw=1.2)

plt.ylim(-0.4, 1.0)

plt.yticks(np.arange(-0.4, 1.0, step=0.1))

plt.savefig(nick+"autoCorrBOXPLOT-BC.pdf", format='pdf')

plt.clf()

degACF.T.boxplot(column=[1]+range(5, lags, 5))

plt.ylabel("ACF of DEG for all nodes")

plt.xlabel("Time-lag")

plt.xticks(rotation="vertical")

plt.axhline(y=0.2, color='k', linestyle='--', lw=1.2)

plt.axhline(y=0.0, color='k', linestyle='--', lw=2)

plt.axhline(y=-0.2, color='k', linestyle='--', lw=1.2)

plt.ylim(-0.4, 1.0)

plt.yticks(np.arange(-0.4, 1.0, step=0.1))

plt.savefig(nick+"autoCorrBOXPLOT-DEG.pdf", format='pdf')

plt.clf()

kcoreACF.T.boxplot(column=[1]+range(5, lags, 5))

plt.ylabel("ACF of KCORE for all nodes")

plt.xlabel("Time-lag")

plt.xticks(rotation="vertical")

plt.axhline(y=0.2, color='k', linestyle='--', lw=1.2)

plt.axhline(y=0.0, color='k', linestyle='--', lw=2)

plt.axhline(y=-0.2, color='k', linestyle='--', lw=1.2)

plt.ylim(-0.4, 1.0)

plt.yticks(np.arange(-0.4, 1.0, step=0.1))

plt.savefig(nick+"autoCorrBOXPLOT-KCORE.pdf", format='pdf')

plt.clf()

# Mean AutoCorrelation and Rank-Correlation

# lags=20

firstRank = bcdf.iloc[0, :]

x = range(0, lags)

meanbcACF = []

meandegACF = []

meankcoreACF = []

rankCorr = []

weightedRankCorr = []

for i in x:

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

    meanbcACF.append(np.mean(bcACF.iloc[i]))

    meandegACF.append(np.mean(degACF.iloc[i]))

    meankcoreACF.append(np.mean(kcoreACF.iloc[i]))

    rankCorr.append(stats.spearmanr(firstRank, bcdf.iloc[i, :])[0])

    #weightedRankCorr.append(stats.weightedtau(firstRank, dfn.iloc[i,:])[0])

plt.plot(x, meanbcACF, lw="1.5", label='Mean BC Autocorrelation')

plt.plot(x, meandegACF, lw="1.5", label='Mean DEG Autocorrelation')

plt.plot(x, meankcoreACF, lw="1.5", label='Mean KCORE Autocorrelation')

plt.plot(x, rankCorr, lw="1.5", label='Rank-Correlation (with rank at t_0)')

# plt.plot(x, weightedRankCorr, lw="1.5",

#         label='Weighted-Rank-Correlation (with rank at t_0)')

plt.ylabel('Correlation indexes')

plt.xlabel('Time-lags / Time')

plt.grid()

plt.legend()

# plt.ylim(-1.0,1.0)

plt.xlim(0, lags)

plt.savefig(nick+"autoCorrMean-RankSpearman.pdf", format='pdf')

plt.clf()

toWrite = pd.concat([pd.Series(meanbcACF), pd.Series(

    meandegACF), pd.Series(meankcoreACF)], axis=1).iloc[1:, :]

fout = open("meanAC"+nick+".csv", 'w')

toWrite.to_csv(fout, index=False)

fout.close()

bc_deg = []

bc_kcore = []

deg_kcore = []

for n in nodes:

    bcn = bcdf.iloc[:, n]

    degn = degdf.iloc[:, n]

    kn = kcoredf.iloc[:, n]

    cordf = pd.concat([bcn, degn, kn], axis=1)

    cm = cordf.corr()

    bc_deg.append(cm['bc']['deg'])

    bc_kcore.append(cm['bc']['kcore'])

    deg_kcore.append(cm['deg']['kcore'])

a = np.mean(bc_deg)

b = np.mean(bc_kcore)

c = np.mean(deg_kcore)

toplotdf = pd.DataFrame([[1, a, b],

                         [a, 1, c],

                         [b, c, 1]])

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

sns.set()

'''f250=bcdf.iloc[750:1000,:]

f250.columns=map(str, range(0, len(f250.columns)))

sns.heatmap(f250.corr(), cmap="RdBu_r", center=0.0, vmin=-1.0, vmax=1.0,

    cbar_kws={"label": "Cross-nodes BC Pearson Correlation"})

plt.xlabel("Nodes")

plt.ylabel("Nodes")

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

plt.clf()

cg=sns.clustermap(f250.corr(), cmap="RdBu_r", robust=True)

cg.ax_row_dendrogram.set_visible(False)

cg.ax_col_dendrogram.set_visible(False)

cg.savefig(nick+"bcNodesClusteredCorr.pdf", format='pdf')

plt.clf()'''

sns.heatmap(toplotdf, cmap="RdBu_r", center=0.0, vmin=-1.0, vmax=1.0)

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

plt.clf()

fout = open("meanMetricsCorr"+nick+".csv", 'w')

toplotdf.to_csv(fout, index=False)

fout.close()

'''

nodes2coreInst = defaultdict(list)

#nodes2rankInst = defaultdict(list)

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

    coreT, coreRankT = coreNodesAtTime(dfn, t, 5)

    for n in coreT:

        nodes2coreInst[n].append((t,coreT[n],coreRankT[n]))

for n in [5,38,59,92]:

    points = nodes2coreInst[n]

    x = [p[0] for p in points]

    y = [len(nodes2coreInst)-p[2] for p in points]

    color = n / float(len(nodes2coreInst.keys()))

    #rgba = cmap(color)

    #plt.scatter(x,y, rgba)

    plt.plot(x,y, 'o')

plt.ylim(0, len(nodes2coreInst))

plt.show()

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

plt.show()

exit()

# Core Persitence

plags=100

x = range(0, plags)

y = []

for i in x:

    print "cacca"

plt.clf()

'''

'''X, Y, Z = [], [], []

for node in srtNodes:

    #print "n:", node

    for lag in range(lags):

        #print "\tn:%d  lag:%d" % (node,lag)

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

        X.append(lag)

        Y.append(node)

        Z.append(list(bcACF.iloc[lag])[node])

fig = plt.figure()

ax = plt.axes(projection='3d')

ax.set_xlabel('Time-Lag')

ax.set_ylabel('Nodes sorted by BC at t_0')

ax.set_zlabel('ACF at time-lag x of node y')

ax.plot_trisurf(X, Y, Z, linewidth=0.2, antialiased=True)

ax.set_xlim(0, lags)

ax.set_ylim(0, len(srtNodes))

#ax.set_zlim(-1.0, 1.0)

plt.savefig(nick+"autoBC-3d.pdf", format="pdf")'''

print "THE END"