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