notebook.community

Edit and run



In [1]:

    
import numpy as np
import networkx as nx
import gensim
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import silhouette_score
from scipy.spatial.distance import cdist, pdist
import pickle

from sklearn.metrics import normalized_mutual_info_score as NMI
%matplotlib inline



In [32]:

    
def getNMI(folder,num):
    path = 'data/'+folder+'/'
    emb_file = path+'embedding_run_'+str(num)+'.emb'
    community_file = path+'community_run_'+str(num)+'.dat'
    graph_file = path+'network_run_'+str(num)+'.dat'
    W = pickle.load(open(emb_file, "rb" ))
    G = nx.read_edgelist(graph_file)
    nodes = G.number_of_nodes()
    emb = (W[0:nodes,:] + W[nodes:,:])/2.0
    community_truth_values = []
    for line in open(community_file):
        cols = line.split()
        community_truth_values.append(cols[1])
    num_clusters = len(set(community_truth_values))
    kmeans = KMeans(n_clusters=num_clusters).fit(emb)
    return NMI(community_truth_values,kmeans.labels_)



In [39]:

    
def getAverageNMI(folder):
    avg = 0
    for i in range(1,6):
        avg += getNMI(folder,i)
    return avg/5.0



In [40]:

    
getAverageNMI('mu_0.4_N_1000')









    Out[40]:





0.32657543281617213



In [44]:

    
def plotNMIGraph():
    x = []
    y = []
    for i in np.arange(0.1,1,0.1):
        x.append(i)
        name = 'mu_'+str(i)+'_N_1000'
        y.append(getAverageNMI(name))
    return x,y



In [45]:

    
x,y = plotNMIGraph()



In [89]:

    
x_n,y_n = plotNMIGraph()



In [90]:

    
plt.plot(x_n,y_n)
plt.xlabel('mixing parameter')
plt.ylabel('NMI score')
plt.title('NMI score Vs mixing parameter for N=1000')









    Out[90]:





<matplotlib.text.Text at 0x123127090>



In [88]:

    
getNMI('mu_0.5_N_1000',3)









    Out[88]:





0.96374769691606144



In [105]:

    
G = nx.read_edgelist('data/train_n2v.txt', nodetype=int, create_using=nx.DiGraph())



In [106]:

    
nodes = list(G.nodes())
min_label = min(nodes)
print min_label



In [107]:

    
sorted(nodes)



In [115]:

    
res = nx.shortest_path(G)



In [117]:

    
res[24578]









    Out[117]:





{15198: [24578, 21968, 15198],
 16770: [24578, 16770],
 18067: [24578, 21968, 18067],
 18297: [24578, 18297],
 21968: [24578, 21968],
 24578: [24578]}



In [120]:

    
dist_cooccur = []
for src in res: 
    for dest in res[src]:
        if src != dest:
            #print 'accessing src : ',src,' dest : ',dest
            path = res[src][dest]
            l = 0
            for i in range(len(path) -1):
                l += G[path[i]][path[i+1]]['weight']
            dist_cooccur.append((int(src)-min_label, int(dest)-min_label, 1.0/l))



In [118]:

    
G[24578][21968]









    Out[118]:





{'weight': 2}



In [ ]:

    
d = pickle.load(open('data/embedding_train_n2v.emb', "rb" ))