from plot_utility import SVM_plot
from Data_load import read_UCI_data, read_2D
Train_data, Train_label = read_UCI_data(0)
C = 3.0
gamma = 0.4
Global_model = svm.SVC(C=C, kernel='rbf', gamma=gamma, tol=1e-6)
Global_model.fit(Train_data, Train_label)
Global_loss = Ce.training_loss(Global_model)
# print(Ce.training_loss(Global_model))
Edge_node_n = 10
Edge_data, Edge_label, Global_index = \
data_partition(Train_data, Train_label, Edge_node_n)
Edge_loss = np.zeros(Edge_node_n)
Edge_upper_loss = np.zeros(Edge_node_n)
for i in range(Edge_node_n):
local_model = Ed.local_train(Edge_data[i], Edge_label[i], C, gamma, 'rbf')
Edge_loss[i] = Ce.training_loss(local_model)
upper_model = Ed.local_train(Edge_data[i], Edge_label[i], C * Edge_node_n,
gamma, 'rbf')
Edge_upper_loss[i] = \
(1/Edge_node_n) * Ce.training_loss(upper_model)
print('Upper bound:')
print(np.sum(Edge_upper_loss))
def main(argv):
Edge_node_n = 10
C = 3.0
gamma = 0.1
dataset = 3
data_part = 0
n_part = 5
equal_flag = True
try:
opts, args = getopt.getopt(argv, 'hn:C:g:p:d:t:e:', [
'help', 'Edge_node_n=', 'C=', 'gamma=', 'data_part=', 'dataset=',
'n_part=', 'equal_flag='
])
except getopt.GetoptError:
print(
'Bound_DSVM.py -n <Edge_node_n> -C <C> -g <gamma> -p <data_part> -d <dataset> -t <n_part> -e <equal_flag>'
)
sys.exit(2)
for opt, arg in opts:
if (opt == '-h'):
print(
'Bound_DSVM.py -n <Edge_node_n> -C <C> -g <gamma> -p <data_part> -d <dataset> -t <n_part> -e <equal_flag>'
)
print(
'-p 0: data_partition; 1: kmeans_partition; 2: kmeans_random')
print(
'-d 0: skin_nonskin; 1: phishing; 2: a8a; 3: ijcnn; 4: covtype'
)
print('-e True: equal; False: not equal')
sys.exit()
elif (opt == '-n'):
Edge_node_n = int(arg)
elif (opt == '-C'):
C = float(arg)
elif (opt == '-g'):
gamma = float(arg)
elif (opt == '-p'):
data_part = int(arg)
elif (opt == '-d'):
dataset = int(arg)
elif (opt == '-t'):
n_part = int(arg)
elif (opt == '-e'):
equal_flag = arg
method_name = ['optimal', 'proposed', 'local support vector']
n_data_point = [int(0)] * 3
# Train_data, Train_label, Test_data, Test_label = read_UCI_data(1)
Train_data, Train_label, Test_data, Test_label = read_UCI_data(dataset)
print("global size is %s" % (np.size(Train_label)))
# Training_set = sklearn.datasets.load_svmlight_file('german')
#
# Train_label_t = Training_set[1]
# Train_data_t = np.array(Training_set[0].todense())
# Train_data_t = preprocessing.normalize(Train_data_t)
#
# Train_data_s,Train_label_s = shuffle(Train_data_t, Train_label_t)
#
# Train_label = Train_label_s
# Train_data = Train_data_s
# C = 3.0
# gamma = 0.3
Global_model = svm.SVC(C=C, kernel='rbf', gamma=gamma)
Global_model.fit(Train_data, Train_label)
n_data_point[0] = Global_model.n_support_[0] + Global_model.n_support_[1]
# print(Ce.training_loss(Global_model))
# print (np.size(Global_model.dual_coef_[0]))
# SVM_plot(Train_data[:, 0], Train_data[:, 1], Train_label, Global_model)
# Only_SV_model = svm.SVC(C=C, kernel='rbf', gamma=gamma)
# data, label = shuffle(Global_model.support_vectors_, Train_label[Global_model.support_])
# Only_SV_model.fit(Global_model.support_vectors_, Train_label[Global_model.support_])
# Only_SV_model.fit(data, label)
# print(Ce.training_loss(Only_SV_model))
# print(Global_model.n_support_)
# print(Only_SV_model.n_support_)
# # SVM_plot(Train_data[:, 0], Train_data[:, 1], Train_label, Global_model)
# # SVM_plot(Global_model.support_vectors_[:, 0], Global_model.support_vectors_[:, 1], Train_label[Global_model.support_], Only_SV_model)
# Edge_node_n = 10
Edge_data = []
Edge_label = []
if (data_part == 0):
Edge_data, Edge_label, Global_index = data_partition(
Train_data, Train_label, Edge_node_n)
elif (data_part == 1):
Edge_data, Edge_label, Global_index = kmeans_partition(
Train_data, Train_label, Edge_node_n)
elif (data_part == 2):
Edge_data, Edge_label, Global_index = k_means_random_partition(
Train_data, Train_label, Edge_node_n, n_part, equal_flag)
else:
raise ValueError
Edge_data_all = copy.deepcopy(Edge_data)
Edge_label_all = copy.deepcopy(Edge_label)
# for i in range(Edge_node_n):
# print("Edge_data[%i].size is %s and Edge_label[%i].size is %d" % (
# i, np.size(Edge_data[i], axis=0), i, np.size(Edge_label[i])))
Distance_plus = []
Distance_minus = []
support_plus_ = []
support_minus_ = []
support_vectors_plus = []
support_vectors_minus = []
for i in range(Edge_node_n):
local_model = Ed.local_train(Edge_data[i], Edge_label[i], C, gamma,
'rbf')
# # SVM_plot(Edge_data[i][:, 0], Edge_data[i][:, 1], Edge_label[i], local_model)
support_, support_vectors_, n_support_ = Ed.local_support(local_model)
# print("i = %i, n_support = %s" % (i, np.sum(n_support_)))
D_plus = np.multiply(
Edge_label[i][support_[n_support_[0]:]],
local_model.decision_function(support_vectors_[n_support_[0]:, :]))
D_minus = np.multiply(
Edge_label[i][support_[:n_support_[0]]],
local_model.decision_function(support_vectors_[:n_support_[0], :]))
S_plus_, SV_plus, _ \
= Ed.upload_sort(support_[n_support_[0]:], support_vectors_[n_support_[0]:, :], D_plus)
S_minus_, SV_minus, _ \
= Ed.upload_sort(support_[:n_support_[0]], support_vectors_[:n_support_[0], :], D_minus)
Distance_plus.append(D_plus)
Distance_minus.append(D_minus)
support_plus_.append(S_plus_)
support_minus_.append(S_minus_)
support_vectors_plus.append(SV_plus)
support_vectors_minus.append(SV_minus)
#
# local_support_vector = np.concatenate((support_vectors_plus[0], support_vectors_minus[0]), axis=0)
# local_label_plus = np.ones(np.size(support_vectors_plus[0], axis=0))
# local_label_minus = np.ones(np.size(support_vectors_minus[0], axis=0)) * (-1)
# local_label = np.concatenate((local_label_plus, local_label_minus), axis=0)
# for i in range(1, Edge_node_n):
# local_support_vector = np.concatenate((local_support_vector, support_vectors_plus[i], support_vectors_minus[i]),
# axis=0)
# local_label_plus = np.ones(np.size(support_vectors_plus[i], axis=0))
# local_label_minus = np.ones(np.size(support_vectors_minus[i], axis=0)) * (-1)
# local_label = np.concatenate((local_label, local_label_plus, local_label_minus), axis=0)
#
# All_upload_model = svm.SVC(C=C, kernel='rbf', gamma=gamma)
# All_upload_model.fit(local_support_vector, local_label)
#
# # # SVM_plot(local_support_vector[:, 0], local_support_vector[:, 1], local_label, All_upload_model)
# print(np.size(local_label, axis=0))
# print(All_upload_model.n_support_)
'''
First data uploading
'''
# Updated_support_plus_ = []
# Updated_support_minus_ = []
# Updated_support_vectors_plus = []
# Updated_support_vectors_minus = []
Upload_support_vector_ = []
Upload_label = []
for i in range(Edge_node_n):
upper_model = Ed.local_train(Edge_data[i], Edge_label[i],
C * Edge_node_n, gamma, 'rbf')
Upload_edge_support_vector_ = upper_model.support_vectors_
Upload_edge_label = Edge_label[i][upper_model.support_]
Upload_support_vector_.append(Upload_edge_support_vector_)
Upload_label.append(Upload_edge_label)
Collect_support_vector_ = np.concatenate(
(Upload_support_vector_[0], Upload_support_vector_[1]))
Collect_label = np.concatenate((Upload_label[0], Upload_label[1])).reshape(
(-1))
if (Edge_node_n > 2):
for j in range(2, Edge_node_n):
Collect_support_vector_ = np.concatenate(
(Collect_support_vector_, Upload_support_vector_[j]))
Collect_label = np.concatenate(
(Collect_label, Upload_label[j].reshape(-1)))
test = svm.SVC(C=C, kernel='rbf', gamma=gamma)
test.fit(Collect_support_vector_, Collect_label)
# print(Ce.training_loss(test))
# print(np.size(Collect_label, axis=0))
# print(test.n_support_)
#
#
# print(np.size(Collect_label, axis=0))
# while((np.sum(test.n_support_)) == np.size(Collect_support_vector_, axis=0)):
# # while ((np.sum(test.n_support_)) == np.size(Collect_support_vector_, axis=0)):
# for i in range(Edge_node_n):
# k1= [Updated_support_vectors_plus[i][0]]
# k2 = [Updated_support_vectors_minus[i][0]]
# Upload_edge_support_vector_ = np.concatenate(
# (k1, k2), axis=0)
# Upload_support_vector_[i] = np.concatenate((Upload_support_vector_[i], Upload_edge_support_vector_), axis=0)
#
# Upload_edge_label = [1.0, -1.0]
# Upload_label[i] = np.concatenate((Upload_label[i], Upload_edge_label), axis=0)
#
# Updated_support_plus_[i], Updated_support_vectors_plus[i] \
# = Ed.local_upload(Updated_support_plus_[i], Updated_support_vectors_plus[i])
# Updated_support_minus_[i], Updated_support_vectors_minus[i] \
# = Ed.local_upload(Updated_support_minus_[i], Updated_support_vectors_minus[i])
#
# Collect_support_vector_ = np.concatenate((Upload_support_vector_[0], Upload_support_vector_[1]))
# Collect_label = np.concatenate((Upload_label[0], Upload_label[1])).reshape((-1))
#
# if(Edge_node_n > 2):
# for j in range(2,Edge_node_n):
# Collect_support_vector_ = np.concatenate((Collect_support_vector_,Upload_support_vector_[j]))
# Collect_label = np.concatenate((Collect_label, Upload_label[j].reshape(-1)))
# test = svm.SVC(C=C, kernel='rbf', gamma=gamma)
# test.fit(Collect_support_vector_, Collect_label)
#
#
# print(np.size(Collect_label, axis=0))
# print(test.n_support_)
ite = 0
old_support_vectors_ = test.support_vectors_
new_support_vectors_, Upload_support_vector_, Upload_label, Collect_support_vector_, Collect_label \
= training_iteration(Edge_node_n,
Edge_data,
Edge_label,
Upload_support_vector_,
Upload_label,
Collect_support_vector_,
Collect_label,
C, gamma)
# print("ite = %s" % (ite))
ite += 1
while (not Ed.SV_compare(old_support_vectors_, new_support_vectors_)):
old_support_vectors_ = new_support_vectors_
new_support_vectors_, Upload_support_vector_, Upload_label, Collect_support_vector_, Collect_label \
= training_iteration(Edge_node_n,
Edge_data,
Edge_label,
Upload_support_vector_,
Upload_label,
Collect_support_vector_,
Collect_label,
C, gamma)
# print("ite = %s" % (ite))
ite += 1
print(SV_diff_count(Global_model.support_vectors_, new_support_vectors_))
n_data_point[1] = int(np.size(Collect_support_vector_, axis=0))
'''
Uploading all the local support vectors:
'''
# print("For uploading all the local support vectors:")
Edge_num = np.zeros(Edge_node_n).tolist()
for i in range(Edge_node_n):
Edge_num[i] = np.size(Edge_label_all[i])
Distance_plus = []
Distance_minus = []
support_plus_ = []
support_minus_ = []
support_vectors_plus = []
support_vectors_minus = []
for i in range(Edge_node_n):
local_model = Ed.local_train(Edge_data_all[i], Edge_label_all[i], C,
gamma, 'rbf')
# # SVM_plot(Edge_data[i][:, 0], Edge_data[i][:, 1], Edge_label[i], local_model)
support_, support_vectors_, n_support_ = Ed.local_support(local_model)
support_vectors_plus.append(support_vectors_[n_support_[0]:, :])
support_vectors_minus.append(support_vectors_[:n_support_[0], :])
# # SVM_plot(Edge_data[i][:, 0], Edge_data[i][:, 1], Edge_label[i], local_model)
local_support_vector = np.concatenate(
(support_vectors_plus[0], support_vectors_minus[0]), axis=0)
local_label_plus = np.ones(np.size(support_vectors_plus[0], axis=0))
local_label_minus = np.ones(np.size(support_vectors_minus[0],
axis=0)) * (-1)
local_label = np.concatenate((local_label_plus, local_label_minus), axis=0)
for i in range(1, Edge_node_n):
local_support_vector = np.concatenate(
(local_support_vector, support_vectors_plus[i],
support_vectors_minus[i]),
axis=0)
local_label_plus = np.ones(np.size(support_vectors_plus[i], axis=0))
local_label_minus = np.ones(np.size(support_vectors_minus[i],
axis=0)) * (-1)
local_label = np.concatenate(
(local_label, local_label_plus, local_label_minus), axis=0)
old_support_vectors_ = []
central_model, global_support_vector, global_label = \
Ce.central_training(local_support_vector, local_label, C, gamma, 'rbf')
new_support_vectors_ = central_model.support_vectors_
# SVM_plot(local_support_vector[:, 0], local_support_vector[:, 1], local_label, All_upload_model)
# print(np.size(local_label, axis=0))
# print(central_model.n_support_)
ite_count = 1
remain_SV = np.copy(local_support_vector)
while (not Ed.SV_compare(old_support_vectors_, new_support_vectors_)):
ite_count += 1
new_support_vector_plus = []
new_support_vector_minus = []
# print("global_support_v.size is %s" % (np.size(global_support_vector, axis=0)))
# delete the additional local vector before receive the central node delivery
for i in range(Edge_node_n):
# index = 0
# # print ("i is %i" %(i))
# before_size = np.size (Edge_data[i], axis= 0)
# # print (before_size)
# for j in Edge_data[i]:
# for k in global_support_vector:
# # print (j)
# if (vector_compare(k,j)):
# Edge_data[i] = np.delete(Edge_data[i], index, 0)
# Edge_label[i] = np.delete(Edge_label[i], index, 0)
# index -= 1
# index +=1
#
# # print(np.size (Edge_data[i], axis=0))
# num_delete += before_size - np.size (Edge_data[i], axis= 0)
Edge_data_all[i], Edge_label_all[i] = \
Ed.data_mix(Edge_data_all[i], Edge_label_all[i], global_support_vector, global_label)
# print ("Edge_label[%i].size after receiving the delivered data is %s" %(i,np.size(Edge_label_all[i] )))
local_model = Ed.local_train(Edge_data_all[i], Edge_label_all[i],
C, gamma, 'rbf')
support_, support_vectors_, n_support_ = Ed.local_support(
local_model)
# print(n_support_)
# delete the additional local support vector
# index = 0
# for j in support_vectors_:
# for k in support_vectors_plus:
# if (vector_compare(k,j)):
# support_vectors_ = np.delete(support_vectors_, index, 0)
# n_support_[1] -= 1
# index -= 1
# for k in support_vectors_minus:
# if (vector_compare(k,j)):
# support_vectors_ = np.delete(support_vectors_, index, 0)
# n_support_[0] -= 1
# index -= 1
# index += 1
for j in support_vectors_[n_support_[0]:, :]:
if (not Ed.array_compare(j, remain_SV)):
new_support_vector_plus.append(j)
for j in support_vectors_[:n_support_[0], :]:
if (not Ed.array_compare(j, remain_SV)):
new_support_vector_minus.append(j)
# print("support_v_p.size is %a " %( support_vectors_plus ))
# print("(support_vectors_[n_support_[0]:, :]) is %a " %( support_vectors_[n_support_[0]:, :]))
new_support_vector_plus = np.array(new_support_vector_plus)
new_support_vector_minus = np.array(new_support_vector_minus)
# print("num_plus is %s " %(np.size(new_support_vector_plus, axis=0)))
# print("num_minus is %s " %(np.size(new_support_vector_minus, axis=0)))
'''
Uploading all the local support vectors
'''
# print (np.size(support_vectors_plus, axis = 0))
# print (support_vectors_plus)
if (np.size(new_support_vector_plus, axis=0) != 0
and np.size(new_support_vector_minus, axis=0) != 0):
local_support_vector = \
np.concatenate((local_support_vector, new_support_vector_plus, new_support_vector_minus), axis=0)
local_label_plus = np.ones(np.size(new_support_vector_plus,
axis=0))
local_label_minus = np.ones(
np.size(new_support_vector_minus, axis=0)) * (-1)
local_label = np.concatenate(
(local_label, local_label_plus, local_label_minus), axis=0)
elif (np.size(new_support_vector_plus, axis=0) == 0
and np.size(new_support_vector_minus, axis=0) != 0):
local_support_vector = \
np.concatenate((local_support_vector, new_support_vector_minus), axis=0)
local_label_minus = np.ones(
np.size(new_support_vector_minus, axis=0)) * (-1)
local_label = np.concatenate((local_label, local_label_minus),
axis=0)
elif (np.size(new_support_vector_plus, axis=0) != 0
and np.size(new_support_vector_minus, axis=0) == 0):
local_support_vector = \
np.concatenate((local_support_vector, new_support_vector_plus), axis=0)
local_label_plus = np.ones(np.size(new_support_vector_plus,
axis=0))
local_label = np.concatenate((local_label, local_label_plus),
axis=0)
# for i in range(1,Edge_node_n):
# local_support_vector = np.concatenate((local_support_vector, support_vectors_plus[i], support_vectors_minus[i]), axis=0)
# local_label_plus = np.ones(np.size(support_vectors_plus[i], axis=0))
# local_label_minus = np.ones(np.size(support_vectors_minus[i], axis=0)) * (-1)
# local_label = np.concatenate((local_label, local_label_plus, local_label_minus), axis=0)
# print ("local_sv.size is %s" %(np.size(local_support_vector, axis = 0)))
# print ("(after delete) (remain_SV.size) is %s " % (np.size(remain_SV,axis=0)))
remain_SV = np.copy(local_support_vector)
# print("The overall transformed sv num (remain_SV.size) is %s " % (np.size(remain_SV, axis=0)))
old_support_vectors_ = central_model.support_vectors_
central_model, global_support_vector, global_label = \
Ce.central_training(local_support_vector, local_label, C, gamma, 'rbf')
new_support_vectors_ = central_model.support_vectors_
# print(Ce.training_loss(central_model))
# print(np.size(local_label, axis=0))
# print(central_model.n_support_)
# SVM_plot(local_support_vector[:, 0], local_support_vector[:, 1], local_label, central_model)
# print("ite_count = %i" % (ite_count))
# for i in range(Edge_node_n):
# print("the net addition in node %i is %s" % (i, np.size(Edge_label_all[i]) - Edge_num[i]))
# print("The overall transformed sv num (remain_SV.size) is %s " % (np.size(remain_SV, axis=0)))
print(SV_diff_count(Global_model.support_vectors_, new_support_vectors_))
n_data_point[2] = int(np.size(local_support_vector, axis=0))
dataframe = pd.DataFrame({
'method_name': method_name,
'n_data_point': n_data_point
})
if (dataset == 0):
file_name = 'skin_nonskin_' + str(C) + '_' + str(gamma) + '_' + str(
Edge_node_n) + '_nodes.csv'
elif (dataset == 1):
file_name = 'phishing_' + str(C) + '_' + str(gamma) + '_' + str(
Edge_node_n) + '_nodes.csv'
elif (dataset == 2):
file_name = 'a8a_' + str(C) + '_' + str(gamma) + '_' + str(
Edge_node_n) + '_nodes.csv'
elif (dataset == 3):
file_name = 'ijcnn1_' + str(C) + '_' + str(gamma) + '_' + str(
Edge_node_n) + '_nodes.csv'
elif (dataset == 4):
file_name = 'covtype_' + str(C) + '_' + str(gamma) + '_' + str(
Edge_node_n) + '_nodes.csv'
else:
raise ValueError
dataframe.to_csv(file_name, index=False, sep=',')
def main(argv):
edge_node_n = 5
C = 7.0
gamma = 0.5
dataset = 1
data_part = 0
n_part = 5
equal_flag = True
try:
opts, args = getopt.getopt(argv, 'hn:p:d:t:e:', [
'help', 'Edge_node_n=', 'data_part=', 'dataset=', 'n_part=',
'equal_flag='
])
except getopt.GetoptError:
print(
'Distributed_core_set.py -n <Edge_node_n> -p <data_part> -d <dataset> -t <n_part> -e <equal_flag>'
)
sys.exit(2)
for opt, arg in opts:
if (opt == '-h'):
print(
'Distributed_core_set.py -n <Edge_node_n> -p <data_part> -d <dataset> -t <n_part> -e <equal_flag>'
)
print(
'-p 0: data_partition; 1: kmeans_partition; 2: kmeans_random')
print(
'-d 0: skin_nonskin; 1: phishing; 2: NB15; 3: ijcnn; 4: covtype'
)
print('-e True: equal; False: not equal')
sys.exit()
elif (opt == '-n'):
edge_node_n = int(arg)
# elif (opt == '-C'):
# C = float(arg)
# elif (opt == '-g'):
# gamma = float(arg)
elif (opt == '-p'):
data_part = int(arg)
elif (opt == '-d'):
dataset = int(arg)
elif (opt == '-t'):
n_part = int(arg)
elif (opt == '-e'):
equal_flag = arg
if (dataset == 0):
C_set = np.arange(1.0, 18.0, 2.0)
gamma_set = np.array([0.1, 0.3, 0.5, 1.0, 2.0, 3.0])
elif (dataset == 1):
C_set = np.arange(1.0, 11.0, 1.0)
gamma_set = np.array([0.01, 0.03, 0.1, 0.3, 0.5, 1.0])
elif (dataset == 3):
C_set = np.arange(1.0, 16.0, 2.0)
gamma_set = np.array([0.1, 0.3, 0.5, 1.0, 2.0])
epsilon = 0.001
# load training data
train_data, train_label, test_data, test_label = read_UCI_data(dataset)
# separate data
edge_data, edge_label, global_index = data_partition(
train_data, train_label, edge_node_n)
C_list = []
gamma_list = []
upload_n_list = []
SV_n_list = []
accuracy_list = []
for C in C_set:
for gamma in gamma_set:
C_list.append(C)
gamma_list.append(gamma)
# MEB at each edge node
upload_n = 0
global_set = []
for node in range(edge_node_n):
train_size = np.size(edge_label[node])
R, dist_core, core_set = MEB(edge_data[node],
edge_label[node],
train_size,
epsilon,
C,
'rbf',
gamma=gamma)
upload_n = upload_n + np.size(core_set)
global_set.append(global_index[node][core_set])
# print(upload_n)
upload_n_list.append(upload_n)
core_set = global_set[0]
for node in range(1, edge_node_n):
core_set = np.append(core_set, global_set[node])
core_train = train_data[core_set]
core_label = train_label[core_set]
core_model = SVC(C=C, kernel='rbf', gamma=gamma)
core_model.fit(core_train, core_label)
core_SV_size = core_model.n_support_[0] + core_model.n_support_[1]
SV_n_list.append(core_SV_size)
accuracy_list.append(core_model.score(test_data, test_label))
# print(core_SV_size)
# print(core_model.score(test_data, test_label))
dataframe = pd.DataFrame({
'C': C_list,
'gamma': gamma_list,
'# of upload': upload_n_list,
'# of SV': SV_n_list,
'test_accuracy': accuracy_list
})
if (dataset == 0):
file_name = 'skin_nonskin_' + str(edge_node_n) + '_nodes.csv'
elif (dataset == 1):
file_name = 'phishing_' + str(edge_node_n) + '_nodes.csv'
elif (dataset == 2):
file_name = 'NB15_' + str(edge_node_n) + '_nodes.csv'
elif (dataset == 3):
file_name = 'ijcnn1_' + str(edge_node_n) + '_nodes.csv'
elif (dataset == 4):
file_name = 'covtype_' + str(edge_node_n) + '_nodes.csv'
else:
raise ValueError
file_name = 'results/' + file_name
dataframe.to_csv(file_name, index=False, sep=',')
Global_model.fit(Train_data, Train_label)
# print (np.size(Global_model.dual_coef_[0]))
# SVM_plot(Train_data[:, 0], Train_data[:, 1], Train_label, Global_model)
Only_SV_model = svm.SVC(C = C, kernel = 'rbf', gamma=gamma)
Only_SV_model.fit(Global_model.support_vectors_, Train_label[Global_model.support_])
print(Global_model.n_support_)
print(Only_SV_model.n_support_)
# # SVM_plot(Train_data[:, 0], Train_data[:, 1], Train_label, Global_model)
# # SVM_plot(Global_model.support_vectors_[:, 0], Global_model.support_vectors_[:, 1], Train_label[Global_model.support_], Only_SV_model)
Edge_node_n = 10
Edge_data, Edge_label, Global_index = data_partition(Train_data, Train_label, Edge_node_n)
# Edge_data, Edge_label, Global_index = kmeans_partition(Train_data, Train_label, Edge_node_n)
for i in range(Edge_node_n):
print ("Edge_data[%i].size is %s and Edge_label[%i].size is %d" %(i, np.size ( Edge_data[i], axis=0 ), i,np.size(Edge_label[i]) ))
Distance_plus = []
Distance_minus = []
support_plus_ = []
support_minus_ = []
support_vectors_plus = []
support_vectors_minus = []
for i in range(Edge_node_n):
local_model = Ed.local_train(Edge_data[i], Edge_label[i], C, gamma, 'rbf')