From b436c1d0a9dfdd2c2a9fe22130e52c7fc6925a57 Mon Sep 17 00:00:00 2001
From: chamalee <chamalee.wickramaarachch@helsinki.fi>
Date: Tue, 1 Aug 2023 02:48:51 +0300
Subject: [PATCH] new scripts

---
 aff-lam-fixed.py => lam-aff-fixed.py | 275 +++++++++-----------
 aff-lam-ld.py => lam-aff-ld.py       | 363 ++++++++++++---------------
 2 files changed, 286 insertions(+), 352 deletions(-)
 rename aff-lam-fixed.py => lam-aff-fixed.py (57%)
 rename aff-lam-ld.py => lam-aff-ld.py (52%)

diff --git a/aff-lam-fixed.py b/lam-aff-fixed.py
similarity index 57%
rename from aff-lam-fixed.py
rename to lam-aff-fixed.py
index c3a7ba8..78dc1c7 100644
--- a/aff-lam-fixed.py
+++ b/lam-aff-fixed.py
@@ -1,275 +1,250 @@
 
 
+
 """
-Effect of lambda: Fixed
+Affect of Lambda: Fixed
 Dataset-1
 """
+
 import numpy as np
 import pandas as pd
 import utils
 import sbm_core
 import math
 from itertools import combinations
-import itertools
+import itertools 
 from sklearn.metrics.cluster import adjusted_rand_score
 
 #  Initilaize
-np.random.seed(34573251)
-
-results = np.zeros((50,3) , dtype=float)
-
-for itr_no in range(0,50):
-
-    num_roles=2
-    num_vertices=20
-    num_segments = 4
-
-    NO_SAMPLES= 1850
-    group_assignment= np.random.randint(num_roles, size=(num_vertices))
-
-    nodes = np.arange(num_vertices)
-
-    list_of_groups=  [[] for _ in range(num_roles)]
+np.random.seed(107)
 
-    for idx, val in enumerate(group_assignment):
-        list_of_groups[val].append(nodes[idx])
+results = np.zeros((20,3) , dtype=float)
 
-    # print(list_of_groups)
+num_roles=2
+num_vertices=20
+num_segments = 2
 
-    size_all_pairs = {}
-    for k in range(0, num_roles):
-        for g in range(k, num_roles):
-            U=list_of_groups[k]
-            W=list_of_groups[g]
+NO_SAMPLES= 1850
+group_assignment= np.random.randint(num_roles, size=(num_vertices))
 
-            if k == g:
-                size_all_pairs[k,g] = math.comb(len(U), 2)
-            if k != g:
-                size_all_pairs[k,g] = len(U)*len(W)
+nodes = np.arange(num_vertices) 
 
-    lamda_arr = np.ones((num_roles, num_roles,num_segments) , dtype=float)
-    lamda_arr_act = np.zeros((num_roles, num_roles,num_segments) , dtype=float)
+list_of_groups=  [[] for _ in range(num_roles)]
+   
+for idx, val in enumerate(group_assignment):
+    list_of_groups[val].append(nodes[idx])
+    
+size_all_pairs = {}
+for k in range(0, num_roles):
+    for g in range(k, num_roles):
+        U=list_of_groups[k]
+        W=list_of_groups[g]
 
-    num_levels = 2
-    H =num_levels
+        if k == g:
+            size_all_pairs[k,g] = math.comb(len(U), 2)
+        if k != g:
+            size_all_pairs[k,g] = len(U)*len(W)
 
-    # h-level lambda estimates
-    lambda_estimates_h = np.random.rand(num_roles, num_roles, H)
+lamda_arr = np.ones((num_roles, num_roles,num_segments) , dtype=float)
 
-    # _itr = 8   # Change _itr from 0 to 8 for large lambda differences
-    # _itr = 1
-    # yu = (9-_itr)*.1
-    # lambda_estimates_h[0,0,:] = [yu, 0.01]
-    # lambda_estimates_h[0,1,:] = [0.01, yu]
-    # lambda_estimates_h[1,0,:] = lambda_estimates_h[0,1,:]
-    # lambda_estimates_h[1,1,:] = [yu, yu]
+#set value for each delta ( 0.01 - 1)
+yu = 1
 
-    _itr  = 5 # Change _itr from 0 to 8   for  smaller lambda differences
-    yu = (9-_itr)*.01
-    lambda_estimates_h[0,0,:] = [yu, 0.01]
-    lambda_estimates_h[0,1,:] = [0.01, yu]
-    lambda_estimates_h[1,0,:] = lambda_estimates_h[0,1,:]
-    lambda_estimates_h[1,1,:] = [yu, yu]
+lamda_arr[0,0]=[yu, 0.01]
+lamda_arr[0,1]= [0.01, yu]
+lamda_arr[1,0]=lamda_arr[0,1]
+lamda_arr[1,1]=[yu, yu]
 
+lamda_arr_act = np.zeros((num_roles, num_roles,num_segments) , dtype=float)
 
-    l1 =list(range(0, H))
-    l2 = []
-    if num_segments > num_levels:
-        l2 = [np.random.randint(0,H) for i in range(num_segments-H)]
+change_points_arr = np.zeros((num_roles, num_roles, num_segments+1) , dtype=int)
+df_all= None
 
-    # Mapping from segment to a level
-    g_mapping= np.array(l1 + l2)
-    # print('g mapping {}'.format(g_mapping))
-    #Initialize  lamda
-    lamda_arr = np.zeros((num_roles, num_roles,num_segments) , dtype=float)
-    for d in range(0, num_segments):
-        lamda_arr[:,:, d]= lambda_estimates_h[:,:,g_mapping[d]]
+points= list(range(0, (num_segments+1)*NO_SAMPLES, NO_SAMPLES))
+list1 = []
 
-    change_points_arr = np.zeros((num_roles, num_roles, num_segments+1) , dtype=int)
+# 20 iteartions
+for itr_no in range(0,20):
     df_all= None
 
-    points= list(range(0, (num_segments+1)*NO_SAMPLES, NO_SAMPLES))
-    list1 = []
-
     #  Generate piecewise non-homogeneous poisson process
     for k in range(0, num_roles):
             for g in range(k, num_roles):
                 comb = []
                 if k == g:
-                    comb = list(combinations(list_of_groups[k], 2))
+                    comb = list(combinations(list_of_groups[k], 2)) 
                     # print(type(comb))
                 else:
                     # comb = []
                     key_data = [list_of_groups[k],list_of_groups[g],]
-                    comb = list(itertools.product(*key_data))
+                    comb = list(itertools.product(*key_data)) 
                     # print(comb)
                 if len(comb) != size_all_pairs[k,g]:
                     print('not equal..')
-
+    
                 change_points_arr[k,g,:] = points
                 lamda_arr[k,g,:] = lamda_arr[g,k,:]
-
+                
                 tot_count = np.zeros((num_segments) , dtype=float)
-
+                
                 for pair in comb:
-
+                    
                     for d in range(0,num_segments):
-
+    
                         s = np.random.poisson(lamda_arr[k,g,d], NO_SAMPLES)
                         # print(np.count_nonzero(s))
                         tot_count[d] += np.count_nonzero(s)
-
+                        
                         list1=[i for i, e in enumerate(s) if e != 0]
-
+                              
                         if len(list1) == 0:
                             print('zero')
-
+    
                         list1 = [x+points[d] for x in list1]
-
+                        
                         df = pd.DataFrame(data=list1)
-                        df.columns =['timestamp']
-
-
+                        df.columns =['timestamp']                    
+                        
                         N= df.size
-
-                        list_start_stations =[pair[0]] * N
+                                                         
+                        list_start_stations =[pair[0]] * N                    
                         list_end_stations =[pair[1]] * N
-
-                        df['source'] = list_start_stations
+                        
+                        df['source'] = list_start_stations 
                         df['target'] = list_end_stations
-
+         
                         df_all=pd.concat([df_all, df], ignore_index=True)
-
+                                    
                 for d in range(0,num_segments):
                     lamda_arr_act[k,g,d] = tot_count[d]/(NO_SAMPLES*len(comb))
                     # print(tot_count[d])
     ## Other preparations
-
+    
     # Remove self loops
-    df_all = df_all[((df_all['source'] ) != (df_all['target']))]
+    df_all = df_all[((df_all['source'] ) != (df_all['target']))] 
     #sort
     df_all=df_all.sort_values('timestamp')
     df_all = df_all[['target', 'timestamp','source']]
-
+    
     # Save as .csv file
     # df_all.to_csv('./Data/synthetic_ground_truth_g1.csv')
-
+    
     df=df_all
     dest_folder='./Results/synthetic/3'
     t_df = df['timestamp']
-
-    nodes_arr = np.union1d(df['target'],df['source']).astype(int)
-    # list of nodes
+    
+    nodes_arr = np.union1d(df['target'],df['source']).astype(int) 
+    # list of nodes         
     nodes = nodes_arr.tolist()
     num_vertices = len(nodes)
-
+    
     # node-group dictionary
     group_dic = {}
     keys = nodes
     values = list(group_assignment)
     group_dic = dict(zip(keys,values))
-
-
+    
+    
     # create a new dictionary - key: node-pair , value:  list of timestamps
     dic=df.groupby(['source','target'])['timestamp'].apply(list).to_dict()
     # print('{} {} {} '.format(group_dic, lamda_arr_act,change_points_arr))
-
-
+    
+    
+    liklihood_sum = sbm_core.compute_cost(group_dic,lamda_arr_act,change_points_arr,num_roles,num_segments,dic)
+    # print(' Initial Actual likelihood   .......%f'%liklihood_sum)
+    
     def _swap (row):
         if row['source'] > row['target']:
             row['source'] , row['target'] =row['target'] , row['source']
         return row
-
+        
     # Undirected graph
     df=df.apply(lambda row: _swap(row), axis=1)
     #scale timestamps for zeroth reference point
     refValue = df['timestamp'].min()
     df['timestamp'] -= refValue
-
+    
     # Experiment
-    import experiment
-
+    
+    import experiment    
+    
     # User parameters
     num_roles=2
-    # num_segments=4
-    # num_levels=2# Optional arg
+    num_segments=2
+    num_levels=2# Optional arg
     algo_ver=3
     dest_folder='./Results/synthetic/'
-
+    
     # tuning parameters
-    theta = 1e-7
+    theta = 1e-5
     eta = 1
     tuning_params= {'theta':theta,'eta':eta}
-
-
-    exp_obj = experiment.Experiment(df,num_roles,num_segments,algo_ver,dest_folder,tuning_params,num_levels,refValue)
+        
+    exp_obj = experiment.Experiment(df,num_roles,num_segments,algo_ver,dest_folder,tuning_params,num_levels,refValue)    
     [itr_d,likelihood_d,group_dic_d,lambda_estimates_d,change_points_arr_d] = exp_obj.execute()
-
-
-    t_df = sorted(t_df)
-
+                
+    t_df = sorted(t_df)    
+    
     chg_points =  change_points_arr_d[0,0,:]
     ranges_arr = [ [chg_points[s]+1,chg_points[s+1]] for s in range(0,len(chg_points)-1)]
-    ranges_arr[0][0] = 0
-    list_time_stamps  = list(t_df)
-
-
+    ranges_arr[0][0] = 0 
+    list_time_stamps  = list(t_df)                  
+                                                
     # iterate over timestamps list
-    dis_arr = list()
-    gt_arr = list()
-
-
+    dis_arr = list()  
+    gt_arr = list()       
+                   
     for item in list_time_stamps:
-
+        
         # find the segment which the timestamp belongs
         # (is dependent on which groups the two nodes belong)
-        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item))
-        dis_arr.append(d)
-
-
+        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item)) 
+        dis_arr.append(d)                    
+       
+                    
     chg_points =  change_points_arr[0,0,:]
     ranges_arr = [ [chg_points[s]+1,chg_points[s+1]] for s in range(0,len(chg_points)-1)]
-    ranges_arr[0][0] = 0
-    list_time_stamps  = list(t_df)
-
-
-    # iterate over timestamps list
-
+    ranges_arr[0][0] = 0 
+    list_time_stamps  = list(t_df)                  
+                        
+                        
+    # iterate over timestamps list                        
     for item in list_time_stamps:
-
+        
         # find the segment which the timestamp belongs
         # (is dependent on which groups the two nodes belong)
-        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item))
-        gt_arr.append(d)
-
-
-    ind = adjusted_rand_score(gt_arr,dis_arr)
+        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item)) 
+        gt_arr.append(d)    
+        
+       
+    ind = adjusted_rand_score(gt_arr,dis_arr) 
     # print('rand index: seg {} : {}'.format(_itr, ind))
-
+        
     g1= group_dic_d
-    g2= group_dic_d[1]
-
-    ds= list(group_dic_d.values() )
-    gt1 = list(g1.values())
-
-    ind_grp=adjusted_rand_score(ds,gt1)
-    # print('rand index: group {} : {}'.format(_itr, ind_grp))
-
+    g2= group_dic_d[1]    
+    
+    ds= list(group_dic_d.values() )   
+    gt1 = list(g1.values()) 
+    
+    ind_grp=adjusted_rand_score(ds,gt1)  
+    # print('rand index: group {} : {}'.format(_itr, ind_grp))  
+        
     results[itr_no][0] = ind
     results[itr_no][1] = itr_d
     results[itr_no][2] = ind_grp
 
-import pickle
-pickle.dump(results, open('large-fixed-file-{}.pickle'.format(_itr), 'wb'))
-
 arr = results
 ll_avg_val =    (sum(arr)/len(arr))
 
-#FINAL RESULTS
-
 print(ll_avg_val)
+
 print(max(arr[:,0]))
+
 print(min(arr[:,0]))
 
 print(max(arr[:,1]))
+
 print(min(arr[:,1]))
+
+print(yu)
+
diff --git a/aff-lam-ld.py b/lam-aff-ld.py
similarity index 52%
rename from aff-lam-ld.py
rename to lam-aff-ld.py
index deb26c6..b7fc4dc 100644
--- a/aff-lam-ld.py
+++ b/lam-aff-ld.py
@@ -5,316 +5,274 @@
 Effect of lambda: LD
 Dataset-2
 """
+
 import numpy as np
 import pandas as pd
 import utils
 import sbm_core
 import math
 from itertools import combinations
-import itertools 
+import itertools
 from sklearn.metrics.cluster import adjusted_rand_score
 #  Initilaize
 np.random.seed(34573251)
 
-results = np.zeros((50,3) , dtype=float)
+results = np.zeros((20,3) , dtype=float)
 
-for itr_no in range(0,50):
-    
-    num_roles=2
-    num_vertices=20
-    num_segments = 4
-    num_levels = 2
-    
-    NO_SAMPLES= 1850
-    nodes = np.arange(num_vertices) 
-    lamda_arr_act = np.zeros((num_roles, num_roles,num_levels) , dtype=float)
-    
-    
-    H =num_levels
-    print('k-h levels %d'%(num_levels))
-            
-    # h-level lambda estimates    
-    lambda_estimates_h = np.random.rand(num_roles, num_roles, H)
-
-    _itr = 3
-    yu = (9-_itr)*.1
-    lambda_estimates_h[0,0,:] = [yu, 0.01]
-    lambda_estimates_h[0,1,:] = [0.01, yu]
-    lambda_estimates_h[1,0,:] = lambda_estimates_h[0,1,:]
-    lambda_estimates_h[1,1,:] = [yu, yu]
-    
-    _itr  = 4
-    yu = (9-_itr)*.01
-    lambda_estimates_h[0,0,:] = [yu, 0.01]
-    lambda_estimates_h[0,1,:] = [0.01, yu]
-    lambda_estimates_h[1,0,:] = lambda_estimates_h[0,1,:]
-    lambda_estimates_h[1,1,:] = [yu, yu]
-
-    l1 =list(range(0, H))
-    l2 = []
-    if num_segments > num_levels:
-        l2 = [np.random.randint(0,H) for i in range(num_segments-H)]  
-    
-    # Mapping from segment to a level
-    g_mapping= np.array(l1 + l2)
-    print('g mapping {}'.format(g_mapping))
-    
-    # initilaize group assignment randomly
-    group_assignment_arr= np.random.randint(num_roles, size=(num_levels,num_vertices))  
-        # node-group dictionary
-    group_dic = {}
-
-    for i in range(0,num_levels ):
-        level = i
-        
-        group_dic_level = {}
-        keys = nodes
-        values = list(group_assignment_arr[level])
-        group_dic_level = dict(zip(keys,values))
-        group_dic[i] = group_dic_level
-    print('initial')
-    # print(group_dic)
-    
-    for e_h in range(0,num_segments):
-        g_a = group_dic[g_mapping[e_h]]
-        list_of_groups=  [[] for _ in range(num_roles)]
-        for idx, val in g_a.items():
-            list_of_groups[val].append(idx)
-        print('group assignments {}: {}'.format(e_h,list_of_groups)) 
-            # Plotting
-    
-    #Initialize  lamda
-    lamda_arr = np.zeros((num_roles, num_roles,num_segments) , dtype=float)    
-    for d in range(0, num_segments):
-        for k in range(0, num_roles):
-            for g in range(k, num_roles):
-                lamda_arr[k,g, d]= lambda_estimates_h[k,g,g_mapping[d]]
-                lamda_arr[g,k, d]= lamda_arr[k,g, d]
-    change_points_arr = np.zeros((num_roles, num_roles, num_segments+1) , dtype=int)
-    df_all= None
-    
-    points= list(range(0, (num_segments+1)*NO_SAMPLES, NO_SAMPLES))
-    list1 = []
-    
-    level_seg_mapping  = {}
-    for d in range(num_segments): 
-        level = g_mapping[d]
-        if level in level_seg_mapping:
-            level_seg_mapping[level].append(d)
-        else:
-            level_seg_mapping[level] = []
-            level_seg_mapping[level].append(d)
-    # %%
+num_roles=2
+num_vertices=20
+num_segments = 4
+num_levels = 2
+
+NO_SAMPLES= 1850
+nodes = np.arange(num_vertices)
+lamda_arr_act = np.zeros((num_roles, num_roles,num_levels) , dtype=float)
+
+H =num_levels
+
+# h-level lambda estimates
+lambda_estimates_h = np.random.rand(num_roles, num_roles, H)
+
+# set value for each delta ( 0.01 - 1)
+yu = 8*.1
+lambda_estimates_h[0,0,:] = [yu, 0.01]
+lambda_estimates_h[0,1,:] = [0.01, yu]
+lambda_estimates_h[1,0,:] = lambda_estimates_h[0,1,:]
+lambda_estimates_h[1,1,:] = [yu, yu]
+
+l1 =list(range(0, H))
+l2 = []
+if num_segments > num_levels:
+    l2 = [np.random.randint(0,H) for i in range(num_segments-H)]
+
+# Mapping from segment to a level
+g_mapping= np.array(l1 + l2)
+# print('g mapping {}'.format(g_mapping))
+
+# initilaize group assignment randomly
+group_assignment_arr= np.random.randint(num_roles, size=(num_levels,num_vertices))
+    # node-group dictionary
+group_dic = {}
+
+for i in range(0,num_levels ):
+    level = i
+    group_dic_level = {}
+    keys = nodes
+    values = list(group_assignment_arr[level])
+    group_dic_level = dict(zip(keys,values))
+    group_dic[i] = group_dic_level
+
+for e_h in range(0,num_segments):
+    g_a = group_dic[g_mapping[e_h]]
+    list_of_groups=  [[] for _ in range(num_roles)]
+    for idx, val in g_a.items():
+        list_of_groups[val].append(idx)
+    # print('group assignments {}: {}'.format(e_h,list_of_groups))
+
+#Initialize  lamda
+lamda_arr = np.zeros((num_roles, num_roles,num_segments) , dtype=float)
+for d in range(0, num_segments):
+    for k in range(0, num_roles):
+        for g in range(k, num_roles):
+            lamda_arr[k,g, d]= lambda_estimates_h[k,g,g_mapping[d]]
+            lamda_arr[g,k, d]= lamda_arr[k,g, d]
+change_points_arr = np.zeros((num_roles, num_roles, num_segments+1) , dtype=int)
+df_all= None
+
+points= list(range(0, (num_segments+1)*NO_SAMPLES, NO_SAMPLES))
+list1 = []
+
+level_seg_mapping  = {}
+for d in range(num_segments):
+    level = g_mapping[d]
+    if level in level_seg_mapping:
+        level_seg_mapping[level].append(d)
+    else:
+        level_seg_mapping[level] = []
+        level_seg_mapping[level].append(d)    
+
+ # %% 20 iteartions
+
+for itr_no in range(0,20):
     #  Generate piecewise non-homogeneous poisson process
-    
-            
     tot_count = np.zeros((num_levels) , dtype=float)
     com_len = np.zeros((num_levels) , dtype=float)
     # for pair in comb:
-        
+
     for i in range(0,num_levels):
         # i = g_mapping[d]
         group_assignment =  group_assignment_arr[i]
-        
-        print(group_assignment)
-        
+
         list_of_groups=  [[] for _ in range(num_roles)]
-        
+
         for idx, val in enumerate(group_assignment):
             list_of_groups[val].append(nodes[idx])
-    
-        # print(list_of_groups)
-        
+
         size_all_pairs = {}
-        
+
         for kk in range(0, num_roles):
             for gg in range(kk, num_roles):
                 U=list_of_groups[kk]
                 W=list_of_groups[gg]
-        
+
                 if kk == gg:
                     size_all_pairs[kk,gg] = math.comb(len(U), 2)
                 if kk != gg:
                     size_all_pairs[kk,gg] = len(U)*len(W)
-        
+
         for k in range(0, num_roles):
             for g in range(k, num_roles):
-                
-    
+
                 change_points_arr[k,g,:] = points
                 lamda_arr[k,g,:] = lamda_arr[g,k,:]
-                    
-    
-                
+
                 comb = []
                 if k == g:
-                    comb = list(combinations(list_of_groups[k], 2)) 
+                    comb = list(combinations(list_of_groups[k], 2))
                     # print(type(comb))
                 else:
                     # comb = []
                     key_data = [list_of_groups[k],list_of_groups[g],]
-                    comb = list(itertools.product(*key_data)) 
+                    comb = list(itertools.product(*key_data))
                     # print(comb)
                 if len(comb) != size_all_pairs[k,g]:
                     print('not equal..')
-                
-                  
-                print('d val {}'.format( d))
-                com_len[i]   = len(comb)  
-                # print('comb len {}'.format( com_len[d]))
+
+                com_len[i]   = len(comb)
                 tot_count[i] = 0
-                
+
                 for pair in comb:
                     s = np.random.poisson(lamda_arr[k,g,d], NO_SAMPLES)
                     # print(np.count_nonzero(s))
                     tot_count[i] += np.count_nonzero(s)
-    
+
                     list_org=[i for i, e in enumerate(s) if e != 0]
-                          
+
                     if len(list_org) == 0:
                         print('zero')
-             
+
                     for d in level_seg_mapping[i]:
-        
-        
+
                         list1 = [x+points[d] for x in list_org]
                         df= None
                         df = pd.DataFrame(data=list1)
                         df.columns =['timestamp']
 
                         N= df.size
-                                        
-                                                            
-                        list_start_stations =[pair[0]] * N                    
+
+                        list_start_stations =[pair[0]] * N
                         list_end_stations =[pair[1]] * N
-                        
-                        df['source'] = list_start_stations 
+
+                        df['source'] = list_start_stations
                         df['target'] = list_end_stations
-         
+
                         df_all=pd.concat([df_all, df], ignore_index=True)
-                            
-  
-                        lamda_arr_act[k,g,i] = round(((tot_count[i])/(NO_SAMPLES*com_len[i])),1)
-                        lamda_arr_act[g,k,i] = lamda_arr_act[k,g,i] 
 
-                print(' {} {} {} {} : k g d :lamb'.format(k,g,i,lamda_arr_act[g,k,i]))
-    
+
+                        lamda_arr_act[k,g,i] = round(((tot_count[i])/(NO_SAMPLES*com_len[i])),3)
+                        lamda_arr_act[g,k,i] = lamda_arr_act[k,g,i]
+
+                # print(' {} {} {} {} : k g d :lamb'.format(k,g,i,lamda_arr_act[g,k,i]))
+
     # Remove self loops
-    df_all = df_all[((df_all['source'] ) != (df_all['target']))] 
+    df_all = df_all[((df_all['source'] ) != (df_all['target']))]
     #sort
     df_all=df_all.sort_values('timestamp')
     df_all = df_all[['target', 'timestamp','source']]
-    
+
     # Save as .csv file
     # df_all.to_csv('./Data/synthetic_ground_truth_g1.csv')
-        
+
     df= None
     df=df_all
     dest_folder='./Results/synthetic/3'
     t_df = df['timestamp']
-    
-    nodes_arr = np.union1d(df['target'],df['source']).astype(int) 
-    # list of nodes         
+
+    nodes_arr = np.union1d(df['target'],df['source']).astype(int)
+    # list of nodes
     nodes = nodes_arr.tolist()
     num_vertices = len(nodes)
-    
-    
+
     # create a new dictionary - key: node-pair , value:  list of timestamps
     dic=df.groupby(['source','target'])['timestamp'].apply(list).to_dict()
-    print('{} {} {} '.format(group_dic, lamda_arr_act,change_points_arr))
-    
+    # print('{} {} {} '.format(group_dic, lamda_arr_act,change_points_arr))
 
-    
     def _swap (row):
         if row['source'] > row['target']:
             row['source'] , row['target'] =row['target'] , row['source']
         return row
-        
+
     # Undirected graph
     df=df.apply(lambda row: _swap(row), axis=1)
     #scale timestamps for zeroth reference point
     refValue = df['timestamp'].min()
     df['timestamp'] -= refValue
-    
-    
-        
+
     chg_points =  change_points_arr[0,0,:]
     ranges_arr = [ [chg_points[s]+1,chg_points[s+1]] for s in range(0,len(chg_points)-1)]
-    ranges_arr[0][0] = 0 
-    list_time_stamps  = list(t_df)                  
-                        
-                        
+    ranges_arr[0][0] = 0
+    list_time_stamps  = list(t_df)
+
     # iterate over timestamps list
-    gt_arr = list()                    
+    gt_arr = list()
     for item in list_time_stamps:
-        
+
         # find the segment which the timestamp belongs
         # (is dependent on which groups the two nodes belong)
-        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item)) 
-        gt_arr.append(d) 
-    
+        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item))
+        gt_arr.append(d)
+
     # Experiment
     import experiment
-    
+
     # User parameters
     algo_ver=4
     dest_folder='./Results/synthetic/'
-    
+
     # tuning parameters
     theta = 1e-7
     eta = 1
     tuning_params= {'theta':theta,'eta':eta}
-    
 
-    
-    exp_obj = experiment.Experiment(df,num_roles,num_segments,algo_ver,dest_folder,tuning_params,num_levels,refValue)    
+    exp_obj = experiment.Experiment(df,num_roles,num_segments,algo_ver,dest_folder,tuning_params,num_levels,refValue)
     # [likelihood_f,group_dic_f] = exp_obj.execute()
     [it,ll1,group_dic_d,lambda_estimates,change_points_arr_d]= exp_obj.execute()
 
-    
-    # SEGMENTATION ACCURACY 
-    
-    t_df = sorted(t_df)    
-        
+    # SEGMENTATION ACCURACY
+    t_df = sorted(t_df)
+
     chg_points =  change_points_arr_d[0,0,:]
     ranges_arr = [ [chg_points[s]+1,chg_points[s+1]] for s in range(0,len(chg_points)-1)]
-    ranges_arr[0][0] = 0 
-    list_time_stamps  = list(t_df)                  
-                        
-                        
+    ranges_arr[0][0] = 0
+    list_time_stamps  = list(t_df)
+
     # iterate over timestamps list
-    dis_arr = list()                    
+    dis_arr = list()
     for item in list_time_stamps:
-        
         # find the segment which the timestamp belongs
         # (is dependent on which groups the two nodes belong)
-        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item)) 
-        dis_arr.append(d)                    
-   
-                     
+        d =  sbm_core._findSegment(ranges_arr, len(ranges_arr) , int(item))
+        dis_arr.append(d)
+
     gt_arr= np.array(gt_arr, dtype=np.float64)
-    dis_arr= np.array(dis_arr, dtype=np.float64) 
-    ind_seg = adjusted_rand_score(gt_arr,dis_arr) 
-    print('ind {} : {}'.format(_itr, ind_seg))
+    dis_arr= np.array(dis_arr, dtype=np.float64)
+    ind_seg = adjusted_rand_score(gt_arr,dis_arr)
+    # print('ind {} : {}'.format(_itr, ind_seg))
+    # print('g mapping {}'.format(g_mapping))
 
-    
-    print('g mapping {}'.format(g_mapping))
-    
     for e_h in range(0,num_segments):
         g_a = group_dic[g_mapping[e_h]]
         list_of_groups=  [[] for _ in range(num_roles)]
         for idx, val in g_a.items():
             list_of_groups[val].append(idx)
-        print('group assignments {}: {}'.format(e_h,list_of_groups)) 
-    
+        # print('group assignments {}: {}'.format(e_h,list_of_groups))
 
     g1= group_dic_d[0]
     g2= group_dic_d[1]
-            
-    # print('rand index: group {} : {}'.format(_itr, ind_grp))  
-                
+
+    # print('rand index: group {} : {}'.format(_itr, ind_grp))
     found_cont = 0
-    
+
     for i_h in range(0,num_levels):
         # i_h level
         grp = group_dic_d[i_h]
@@ -323,29 +281,31 @@ for itr_no in range(0,50):
 
         for idx, val in grp.items():
             list_of_groups_d[val].append(idx)
-            
-        ds= list(group_dic_d[i_h].values() )   
-        gt1 = list(g1.values()) 
+
+        ds= list(group_dic_d[i_h].values() )
+        gt1 = list(g1.values())
         gt2 =  list(g2.values())
-                 
+
         ind1=adjusted_rand_score(ds,gt1)
-        ind2=adjusted_rand_score(ds,gt2)    
+        ind2=adjusted_rand_score(ds,gt2)
 
-                
         d_in = max(ind1,ind2)
         found_cont += d_in
-            
+
     ind = found_cont/2
-    
+
     results[itr_no][0] = ind_seg
     results[itr_no][1] = it
-    results[itr_no][2] = ind  
-print('end')   
-   
+    results[itr_no][2] = ind
+    
+    # print(ind_seg)
+    # print(lamda_arr)
+    # print(lamda_arr_act)
+print('end')
+
 import pickle
 # pickle.dump(results, open('max-small-file-{}.pickle'.format(_itr), 'wb'))
 
-
 #FINAL RESULTS
 
 arr = results
@@ -355,7 +315,6 @@ print(ll_avg_val)
 print(max(arr[:,0]))
 print(min(arr[:,0]))
 
-
 print(max(arr[:,1]))
 print(min(arr[:,1]))
-
+print(yu)
-- 
GitLab