def prediction(self):
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
my_net= OdNet(sess,self.parameters)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(var_list=tf.trainable_variables())
if os.path.exists('./trained_model/bullymodel.ckpt.index') :
saver.restore(sess, './trained_model/bullymodel.ckpt')
#load data
image, actual,file_list= get_data(self.parameters.test_num,self.parameters.img_path,self.parameters.xml_path)
#run
pred_class, pred_class_val, pred_location = my_net.prediction_run(image,None)
print('images for prediction:' + str(file_list))
for index, act in zip(range(len(image)), actual):
for a in act :
print('【img-'+str(index)+' actual】:' + str(a))
msg = ("predicted class is: {0}\n "
"predicted class value:{1}\n"
"predicted location:{2}")
print(msg.format(pred_class[index], pred_class_val[index],
pred_location[index]))
# print('predicted location:' + str(pred_location[index]))
else:
print('No trained model Exists!')
sess.close()
def load_split_data(data_size, test_p):
# Load data and split into train set, test set randomly.
# data_size is either "100k", "1m", "10m" or "20m".
# test_p is a float between 0 - 1 indicating the portion of data hold out as test set
print("split data randomly")
# Load ratings, data is already permuted in get_data
ratings = get_data(data_size)
nb_users = int(np.max(ratings[:, 0]))
nb_movies = int(np.max(ratings[:, 1]))
# split test/train set
test_size = int(len(ratings) * test_p)
test_ratings = ratings[:test_size]
train_ratings = ratings[test_size:]
# train_ratings is converted into a matrix
train_M = np.zeros((nb_movies, nb_users), dtype=np.float32)
for rating in train_ratings:
train_M[int(rating[1] - 1), int(rating[0] - 1)] = rating[2]
# save test and train data in case more training is needed on this split
np.save(
"Data/" + data_size + "_" + str(int(test_p * 100)) +
"percent_test.npy", test_ratings)
np.save(
"Data/" + data_size + "_" + str(int(test_p * 100)) +
"percent_trainM.npy", train_M)
# test_ratings is numpy array of user id | item id | rating
# train_M is numpy array with nb_movies rows and nb_users columns, missing entries are filled with zero
return test_ratings, train_M, nb_users, nb_movies, len(train_ratings)
def training(self):
running_count = 0
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
my_net= OdNet(sess,self.parameters)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(var_list=tf.trainable_variables())
if os.path.exists('./session_params/session.ckpt.index') :
print('\nStart Restore')
saver.restore(sess, './session_params/session.ckpt')
print('\nEnd Restore')
print('\n============Training start from here============')
min_loss_location = 100000.
min_loss_class = 100000.
while((min_loss_location + min_loss_class) > 0.001 and running_count < self.parameters.iteration_steps):
running_count += 1
train_data, actual_data,_ = get_data(self.parameters.batch_size,self.parameters.img_path,self.parameters.xml_path)
if len(train_data) > 0:
loss_all,loss_class,loss_location,pred_class,pred_location = my_net.train_run(train_data, actual_data)
l = np.sum(loss_location)
c = np.sum(loss_class)
if min_loss_location > l:
min_loss_location = l
if min_loss_class > c:
min_loss_class = c
sum_loss= min_loss_location + min_loss_class
msg = ("Step {0}---Loss:[{1:>4.3}|{2:>4.3}]"
" ** Location::{3:>4.3} ** Class::{4:>4.3}"
" ** pred_class::[{5:>4.3}|{6:>4.3}|{7:>4.3}]"
" ** pred_location::[{8:>4.3f}|{9:>4.3f}|{10:>4.3f}|")
print(msg.format(running_count, sum_loss, loss_all, np.sum(loss_location),
np.sum(loss_class),np.sum(pred_class),np.amax(pred_class),
np.min(pred_class),np.sum(pred_location),np.amax(pred_location),
np.min(pred_location)))
# save ckpt
if running_count % 100 == 0:
saver.save(sess, './trained_model/bullymodel.ckpt')
print('bullymodel.ckpt has been saved.')
gc.collect()
else:
print('No image!,pls check')
break
saver.save(sess, './trained_model/bullymodel.ckpt')
sess.close()
gc.collect()
print('===========Training ended==========')
def Basemodel(_model, filename, trigger_flag, evalua_flag, is_binary_class,
evaluation_list):
filepath = FLAGS.data_dir
sequence_window = FLAGS.sequence_window
is_multi_scale = FLAGS.is_multi_scale
training_level = FLAGS.scale_levels
is_add_noise = FLAGS.is_add_noise
noise_ratio = FLAGS.noise_ratio
result_list_dict = defaultdict(list)
for each in evaluation_list:
result_list_dict[each] = []
np.random.seed(1337) # for reproducibility
# num_selected_features = 25#AS leak tab=0
# num_selected_features = 32#Slammer tab=0
#num_selected_features = 20 # Nimda tab=1
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data_withoutS(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
#total = np.concatenate((x_train,x_val,x_test))
#total_label = np.concatenate((y_train,y_val,y_test))
loaddata.multi_scale_plotting(x_train, y_train)
for tab_selected_features in range(33, 34):
#for tab_selected_features in range(33):
#hello
if _model == '1NN':
#x_train, y_train, x_test, y_test = ucr_load_data.load_ucr_data()
print(_model +
" is running..............................................")
clf = KNeighborsClassifier(n_neighbors=1)
elif _model == '1NN-DTW':
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
x_train = np.transpose(x_train, [0, 2, 1])
x_test = np.transpose(x_test, [0, 2, 1])
print(_model +
" is running..............................................")
clf = KnnDtw(n_neighbors=1)
x_train = x_train[:, tab_selected_features]
x_test = x_test[:, tab_selected_features]
elif _model == 'RF':
clf = RandomForestClassifier(n_estimators=50)
elif _model == "SVM":
x_train = x_train[:, [0, 1]]
x_test = x_test[:, [0, 1]]
print(_model +
" is running..............................................")
clf = svm.SVC(kernel="rbf",
gamma=0.0001,
C=100000,
probability=True)
elif _model == "SVMF":
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data_withoutS(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
print(_model +
" is running.............................................." +
str(tab_selected_features))
clf = svm.SVC(kernel="rbf",
gamma=0.0001,
C=100000,
probability=False)
estimator = SelectKBest(chi2, k=tab_selected_features)
x_train_new = estimator.fit_transform(x_train, y_train)
x_test_new = estimator.fit_transform(x_test, y_test)
x_train = x_train_new
x_test = x_test_new
elif _model == "SVMW":
print(_model +
" is running.............................................." +
str(tab_selected_features))
#estimator = svm.SVC(kernel="rbf", gamma=0.00001, C=1000, probability=False)
estimator = svm.SVC(kernel="linear")
clf = RFE(estimator, tab_selected_features, step=1)
elif _model == "NB":
print(_model +
" is running..............................................")
clf = BernoulliNB()
elif _model == "DT":
print(_model +
" is running.............................................." +
str(x_train.shape))
y_train = y_train
clf = tree.DecisionTreeClassifier()
elif _model == "Ada.Boost":
print(_model +
" is running.............................................." +
str(x_train.shape))
y_train = y_train
clf = AdaBoostClassifier(n_estimators=200)
#visualize.curve_plotting(x_test,y_test,filename,_model)
clf.fit(x_train, y_train)
if evalua_flag == True:
result = clf.predict(x_test)
else:
y_test = loaddata.one_hot(y_test)
result = clf.predict_proba(x_test)
print(y_test.shape)
print(result.shape)
if is_binary_class == True:
print(y_test.shape)
print(result.shape)
#print(evalua_flag)
results = evaluation.evaluation(
y_test, result, trigger_flag,
evalua_flag) # Computing ACCURACY,F1-score,..,etc
else:
accuracy = sklearn.metrics.accuracy_score(y_test, result)
symbol_list = [0, 1, 2, 3, 4]
confmat = confusion_matrix(y_test, result, labels=symbol_list)
#visualize.plotConfusionMatrix(confmat)
#symbol_list2 = [0]
#y_= []
#for symbol in symbol_list2:
# for tab in range(len(y_test)):
# if y_test[tab] == symbol and y_test[tab] == result[tab]:
# y_.append(symbol)
#print(y_test[0:10])
#rint(result[0:10])
#print("Accuracy is :"+str(accuracy))
#accuracy = float(len(y_))/(list(result).count(symbol))
print("True is ")
# print(y_test)
print("The 0 of True is " + str(list(y_test).count(0)))
print("The 1 of True is " + str(list(y_test).count(1)))
print("The 2 of True is " + str(list(y_test).count(2)))
print("The 3 of True is " + str(list(y_test).count(3)))
print("The 4 of True is " + str(list(y_test).count(4)))
# print(len(y_test))
print("Predict is ")
# print(result)
print("The 0 of Predict is " + str(list(result).count(0)))
print("The 1 of Predict is " + str(list(result).count(1)))
print("The 2 of Predict is " + str(list(result).count(2)))
print("The 3 of Predict is " + str(list(result).count(3)))
print("The 4 of Predict is " + str(list(result).count(4)))
# print(len(result))
f1_score = sklearn.metrics.f1_score(y_test,
result,
average="macro")
print("Accuracy of is :" + str(accuracy))
print("F-score of is :" + str(f1_score))
print("Accuracy of " + _model + "is :" + str(accuracy))
print("F-score of " + _model + "is :" + str(f1_score))
results = {
'ACCURACY': accuracy,
'F1_SCORE': f1_score,
'AUC': 9999,
'G_MEAN': 9999
}
try:
y_test2 = np.array(loaddata.reverse_one_hot(y_test))
result2 = np.array(loaddata.reverse_one_hot(result))
except:
y_test2 = y_test
result2 = result
# Statistics False Alarm Rate
with open(
os.path.join("./stat/",
"StatFalseAlarm_" + filename + "_True"),
"w") as fout:
for tab in range(len(y_test2)):
fout.write(str(int(y_test2[tab])) + '\n')
with open(
os.path.join(
"./stat/", "StatFalseAlarm_" + filename + "_" + _model +
"_" + "_Predict"), "w") as fout:
for tab in range(len(result2)):
fout.write(str(int(result2[tab])) + '\n')
for each_eval, each_result in results.items():
result_list_dict[each_eval].append(each_result)
for each_eval in evaluation_list:
result_list_dict[each_eval].append(results[each_eval])
#for eachk, eachv in result_list_dict.items():
#result_list_dict[eachk] = np.average(eachv)
if evalua_flag:
with open(os.path.join(FLAGS.output, "Comparison_Log_" + filename),
"a") as fout:
outfileline = _model + ":__" + str(tab_selected_features)
fout.write(outfileline)
for each_eval in evaluation_list:
fout.write(each_eval + ": " + str(
round(np.average(result_list_dict[each_eval]), 3)) +
",\t")
#for eachk, eachv in result_list_dict.items():
#fout.write(eachk + ": " + str(round(eachv, 3)) + ",\t")
fout.write('\n')
#if '-' in _model:continue
if 'MW' in _model or 'MF' in _model:
continue
else:
break
if evalua_flag:
pass
#return epoch_training_loss_list,epoch_val_loss_list
else:
return results
model.model_name = model_name
return model
"""
def save_model(model):
print
print "Saving", model.model_name
open('%s.json'%model.model_name, 'w').write(model.to_json())
model.save_weights('%s_weights.h5' % model.model_name, overwrite=True)
"""
if __name__ == "__main__":
USE_TOP = 1e8
batch_size = 10
trajs, trajs_trn, observable = get_data()
from keras.callbacks import ModelCheckpoint
NUM_EPOCHS = 1000
dims = [3, 10, 50, 100, 300, 500, 700, 1000]
regs = [
0,
]
#archs = ['rnn','rnn2','rnn_identity','rnn_init_time','rnn1']
#archs = ['rnn3',]
#archs = ['rnn4',]
#archs = ['rnn4_stacked',]
archs = [
'rnn2',
]
#archs = ['rnn2',]; dims = [2,3,5,10]
def train_lstm(method, filename_train_list, filename_test, trigger_flag,
evalua_flag, is_binary_class, result_list_dict,
evaluation_list):
global tempstdout
FLAGS.option = method
dropout = 0.8
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename_test,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=FLAGS.is_multi_scale,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
"""
if filename_test == 'HB_AS_Leak.txt':
filename_train = 'HB_C_N_S.txt'
elif filename_test == 'HB_Code_Red_I.txt':
filename_train = 'HB_A_N_S.txt'
elif filename_test == 'HB_Nimda.txt':
filename_train = 'HB_A_C_S.txt'
elif filename_test == 'HB_Slammer.txt':
filename_train = 'HB_A_C_N.txt'
print(filename_test)
#x_train, y_train, x_val, y_val = loaddata.get_trainData(FLAGS.pooling_type, FLAGS.is_add_noise, FLAGS.noise_ratio, FLAGS.data_dir,
# filename_train, FLAGS.sequence_window, trigger_flag,is_binary_class,
# multiScale=FLAGS.is_multi_scale, waveScale=FLAGS.scale_levels,
# waveType=FLAGS.wave_type)
#x_test, y_test = loaddata.get_testData(FLAGS.pooling_type, FLAGS.is_add_noise, FLAGS.noise_ratio, FLAGS.data_dir,
# filename_test, FLAGS.sequence_window, trigger_flag,is_binary_class,
# multiScale=FLAGS.is_multi_scale, waveScale=FLAGS.scale_levels,
# waveType=FLAGS.wave_type)
"""
#loaddata.Multi_Scale_Plotting_2(x_train)
if FLAGS.is_multi_scale:
FLAGS.scale_levels = x_train.shape[1]
FLAGS.input_dim = x_train.shape[-1]
FLAGS.number_class = y_train.shape[1]
if "Nimda" in filename_test:
FLAGS.batch_size = int(int(x_train.shape[0]) / 5)
else:
FLAGS.batch_size = int(x_train.shape[0])
else:
FLAGS.input_dim = x_train.shape[-1]
FLAGS.number_class = y_train.shape[1]
if "Nimda" in filename_test:
FLAGS.batch_size = int(int(x_train.shape[0]) / 5)
else:
FLAGS.batch_size = int(x_train.shape[0])
#g = tf.Graph()
with tf.Graph().as_default():
#config = tf.ConfigProto()
config = tf.ConfigProto(device_count={'/gpu': 0}) #turn GPU on and off
#config = tf.ConfigProto(log_device_placement=True)
#config.gpu_options.per_process_gpu_memory_fraction = 0.2
#with tf.variable_scope("middle")as scope:
tf.set_random_seed(1337)
#global_step = tf.Variable(0,name="global_step",trainable=False)
data_x, data_y = mslstm.inputs(FLAGS.option)
#output_u_w,prediction, label = mslstm.inference(data_x,data_y,FLAGS.option)
is_training = tf.placeholder(tf.bool)
prediction, label, output_last = mslstm.inference(
data_x, data_y, FLAGS.option, is_training)
loss = mslstm.loss_(prediction, label)
tran_op, optimizer = mslstm.train(loss)
minimize = optimizer.minimize(loss)
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(label, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
#summary_op = tf.merge_all_summaries()
weights = tf.Variable(tf.constant(
0.1,
shape=[len(y_test) * FLAGS.sequence_window, 1,
FLAGS.scale_levels]),
name="weights123")
init_op = tf.global_variables_initializer()
#init_op = tf.initialize_all_variables()
sess = tf.Session(config=config)
sess.run(init_op)
#summary_writer = tf.train.SummaryWriter(FLAGS.log_dir, sess.graph)
#saver = tf.train.Saver()
saver = tf.train.Saver({"my_weights": weights})
epoch_training_loss_list = []
epoch_training_acc_list = []
epoch_val_loss_list = []
epoch_val_acc_list = []
early_stopping = 10
no_of_batches = int(len(x_train) / FLAGS.batch_size)
#visualize.curve_plotting_withWindow(x_train, y_train, 0, "Train_"+'_'+FLAGS.option)
#visualize.curve_plotting_withWindow(x_test, y_test, 2, "Test_"+'_'+FLAGS.option)
total_iteration = 0
for i in range(FLAGS.max_epochs):
if early_stopping > 0:
pass
else:
break
j_iteration = 0
for j_batch in iterate_minibatches(x_train,
y_train,
FLAGS.batch_size,
shuffle=False):
j_iteration += 1
total_iteration += 1
inp, out = j_batch
sess.run(minimize, {
data_x: inp,
data_y: out,
is_training: True
})
training_acc, training_loss = sess.run((accuracy, loss), {
data_x: inp,
data_y: out,
is_training: True
})
#sys.stdout = tempstdout
val_acc, val_loss = sess.run((accuracy, loss), {
data_x: x_val,
data_y: y_val,
is_training: True
})
pprint(
FLAGS.option + "_Epoch%s" % (str(i + 1)) + ">" * 3 +'_Titer-'+str(total_iteration) +'_iter-'+str(j_iteration)+ str(FLAGS.wave_type) + '-' + str(FLAGS.scale_levels) + '-' + str(FLAGS.learning_rate)+'-'+str(FLAGS.num_neurons1)+'-'+str(FLAGS.num_neurons2)+ ">>>=" + "train_accuracy: %s, train_loss: %s" % (
str(training_acc), str(training_loss)) \
+ ",\tval_accuracy: %s, val_loss: %s" % (str(val_acc), str(val_loss)), method)
epoch_training_loss_list.append(training_loss)
epoch_training_acc_list.append(training_acc)
epoch_val_loss_list.append(val_loss)
epoch_val_acc_list.append(val_acc)
try:
max_val_acc = epoch_val_acc_list[-2]
except:
max_val_acc = 0
if epoch_val_acc_list[-1] < max_val_acc:
early_stopping -= 1
elif epoch_val_acc_list[-1] >= max_val_acc:
early_stopping = 10
if val_loss > 10 or val_loss == np.nan:
break
if 1 < 0:
#pprint("PPP")
weights_results = sess.run(output_last, {
data_x: x_test,
data_y: y_test
})
#print(weights_results)
#sys.stdout = tempstdout
visualize.curve_plotting(weights_results, y_test, filename_test,
FLAGS.option)
#pprint("QQQ")
with open(filename_test + "_EA.txt", 'w') as fout:
fout.write(weights_results)
#sess.run(weights.assign(weights_results))
else:
pass
#weights = output_u_w.eval(session=sess)
#weights = saver.restore(sess, "./tf_tmp/model.ckpt")
#pprint(weights)
#weight_list = return_max_index(weights)
result = sess.run(prediction, {data_x: x_test, data_y: y_test})
#print(result)
#pprint(result)
#print("LLL")
saver.save(sess, "./tf_tmp/model.ckpt")
sess.close()
#results = evaluation.evaluation(y_test, result)#Computing ACCURACY, F1-Score, .., etc
if is_binary_class == True:
#sys.stdout = tempstdout
results = evaluation.evaluation(
y_test, result, trigger_flag,
evalua_flag) # Computing ACCURACY,F1-score,..,etc
y_test = loaddata.reverse_one_hot(y_test)
result = loaddata.reverse_one_hot(result)
else:
symbol_list = [0, 1, 2, 3, 4]
sys.stdout = tempstdout
print(y_test)
print(result)
y_test = loaddata.reverse_one_hot(y_test)
result = loaddata.reverse_one_hot(result)
confmat = confusion_matrix(y_test, result, labels=symbol_list)
visualize.plotConfusionMatrix(confmat)
#accuracy = sklearn.metrics.accuracy_score(y_test, result)
symbol_list2 = [0]
y_ = []
for symbol in symbol_list2:
for tab in range(len(y_test)):
if y_test[tab] == symbol and y_test[tab] == result[tab]:
y_.append(symbol)
# print(y_test[0:10])
# rint(result[0:10])
# print("Accuracy is :"+str(accuracy))
accuracy = float(len(y_)) / (list(result).count(symbol))
print("Accuracy of " + str(symbol) + " is :" + str(accuracy))
print("True is ")
# print(y_test)
print("The 0 of True is " + str(list(y_test).count(0)))
print("The 1 of True is " + str(list(y_test).count(1)))
print("The 2 of True is " + str(list(y_test).count(2)))
print("The 3 of True is " + str(list(y_test).count(3)))
print("The 4 of True is " + str(list(y_test).count(4)))
# print(len(y_test))
print("Predict is ")
# print(result)
print("The 0 of Predict is " + str(list(result).count(0)))
print("The 1 of Predict is " + str(list(result).count(1)))
print("The 2 of Predict is " + str(list(result).count(2)))
print("The 3 of Predict is " + str(list(result).count(3)))
print("The 4 of Predict is " + str(list(result).count(4)))
print("Accuracy is :" + str(accuracy))
f1_score = sklearn.metrics.f1_score(y_test, result, average="macro")
print("F-score is :" + str(f1_score))
results = {
'ACCURACY': accuracy,
'F1_SCORE': f1_score,
'AUC': 9999,
'G_MEAN': 9999
}
sys.stdout = tempstdout
#print(weights_results.shape)
#print("215")
y_test2 = np.array(y_test)
result2 = np.array(result)
#results = accuracy_score(y_test2, result2)
#print(y_test2)
#print(result2)
#print(results)
with open(
os.path.join(os.path.join(os.getcwd(), 'stat'),
"StatFalseAlarm_" + filename_test + "_True.txt"),
"w") as fout:
for tab in range(len(y_test2)):
fout.write(str(int(y_test2[tab])) + '\n')
with open(
os.path.join(
os.path.join(os.getcwd(), 'stat'), "StatFalseAlarm_" +
filename_test + "_" + method + "_" + "_Predict.txt"),
"w") as fout:
for tab in range(len(result2)):
fout.write(str(int(result2[tab])) + '\n')
#eval_list = ["AUC", "G_MEAN","ACCURACY","F1_SCORE"]
for each_eval in evaluation_list:
result_list_dict[each_eval].append(results[each_eval])
if evalua_flag:
with open(
os.path.join(FLAGS.output,
"TensorFlow_Log" + filename_test + ".txt"),
"a") as fout:
if not FLAGS.is_multi_scale:
outfileline = FLAGS.option + "_epoch:" + str(
FLAGS.max_epochs) + ",_lr:" + str(
FLAGS.learning_rate) + ",_multi_scale:" + str(
FLAGS.is_multi_scale) + ",hidden_nodes: " + str(
FLAGS.num_neurons1) + "/" + str(
FLAGS.num_neurons2) + "\n"
else:
outfileline = FLAGS.option + "_epoch:" + str(
FLAGS.max_epochs) + ",_wavelet:" + str(
FLAGS.wave_type) + ",_lr:" + str(
FLAGS.learning_rate) + ",_multi_scale:" + str(
FLAGS.is_multi_scale
) + ",_train_set_using_level:" + str(
FLAGS.scale_levels) + ",hidden_nodes: " + str(
FLAGS.num_neurons1) + "/" + str(
FLAGS.num_neurons2) + "\n"
fout.write(outfileline)
for each_eval in evaluation_list:
#for eachk, eachv in result_list_dict.items():
fout.write(
each_eval + ": " +
str(round(np.mean(result_list_dict[each_eval]), 3)) +
",\t")
fout.write('\n')
return epoch_training_acc_list, epoch_val_acc_list, epoch_training_loss_list, epoch_val_loss_list
else:
return results
model.model_name = model_name
return model
"""
def save_model(model):
print
print "Saving", model.model_name
open('%s.json'%model.model_name, 'w').write(model.to_json())
model.save_weights('%s_weights.h5' % model.model_name, overwrite=True)
"""
if __name__ == "__main__":
USE_TOP = 1e8
batch_size = 10
trajs, trajs_trn, observable = get_data()
from keras.callbacks import ModelCheckpoint
NUM_EPOCHS=1000
dims = [3,10,50,100,300,500,700,1000]
regs = [0,]
#archs = ['rnn','rnn2','rnn_identity','rnn_init_time','rnn1']
#archs = ['rnn3',]
#archs = ['rnn4',]
#archs = ['rnn4_stacked',]
archs = ['rnn2',]
#archs = ['rnn2',]; dims = [2,3,5,10]
#archs = ['rnn2',]; dims = [50,100]; NUM_EPOCHS = 1000
#archs = ['rnn2',]; dims = [2,3,5,10]
#archs = ['rnn2_invstacked',]; dims = [3]; NUM_EPOCHS = 1000
#regs = [0, 1e-3, 1e-2, 1e-1, 0.5, 1]; dims = [100,]
def Basemodel(_model, filename, trigger_flag, evalua_flag, is_binary_class,
evaluation_list):
result_list_dict = defaultdict(list)
for each in evaluation_list:
result_list_dict[each] = []
# num_selected_features = 25#AS leak tab=0
# num_selected_features = 32#Slammer tab=0
num_selected_features = 33 # Nimda tab=1
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data_withoutS(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
print("DDD")
print(FLAGS.sequence_window)
FLAGS.input_dim = x_train.shape[-1]
FLAGS.number_class = y_train.shape[1]
# using MLP to train
if _model == "MLP":
pprint(_model +
" is running..............................................")
start = time.clock()
model = Sequential()
model.add(
Dense(FLAGS.num_neurons1,
activation="sigmoid",
input_dim=FLAGS.input_dim))
#model.add(Dense(output_dim=FLAGS.num_neurons1))
#model.add(Dense(output_dim=FLAGS.num_neurons1))
model.add(Dense(output_dim=FLAGS.number_class))
model.add(Activation("softmax"))
sgd = keras.optimizers.SGD(lr=0.01,
momentum=0.0,
decay=0.0,
nesterov=False)
#model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
batch_size=FLAGS.batch_size,
nb_epoch=FLAGS.max_epochs)
print("AOA")
result = model.predict(x_test)
print(result)
end = time.clock()
pprint("The Time For MLP is " + str(end - start))
pprint(x_test.shape)
elif _model == "RNN":
pprint(_model +
" is running..............................................")
start = time.clock()
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
rnn_object1 = SimpleRNN(FLAGS.num_neurons1,
input_length=len(x_train[0]),
input_dim=FLAGS.input_dim)
model = Sequential()
model.add(rnn_object1) # X.shape is (samples, timesteps, dimension)
#model.add(Dense(30, activation="sigmoid"))
#rnn_object2 = SimpleRNN(FLAGS.num_neurons2, input_length=len(x_train[0]), input_dim=FLAGS.input_dim)
#model.add(rnn_object2) # X.shape is (samples, timesteps, dimension)
model.add(Dense(output_dim=FLAGS.number_class))
model.add(Activation("sigmoid"))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
batch_size=FLAGS.batch_size,
nb_epoch=FLAGS.max_epochs)
result = model.predict(x_test)
end = time.clock()
pprint("The Time For RNN is " + str(end - start))
# print(result)
elif _model == "LSTM":
pprint(_model +
" is running..............................................")
start = time.clock()
x_train, y_train, x_val, y_val, x_test, y_test = loaddata.get_data(
FLAGS.pooling_type,
FLAGS.is_add_noise,
FLAGS.noise_ratio,
FLAGS.data_dir,
filename,
FLAGS.sequence_window,
trigger_flag,
is_binary_class,
multiScale=False,
waveScale=FLAGS.scale_levels,
waveType=FLAGS.wave_type)
initi_weight = keras.initializers.RandomNormal(mean=0.0,
stddev=1,
seed=None)
initi_bias = keras.initializers.Constant(value=0.1)
lstm_object = LSTM(FLAGS.num_neurons1,
input_length=x_train.shape[1],
input_dim=FLAGS.input_dim)
model = Sequential()
model.add(lstm_object,
kernel_initializer=initi_weight,
bias_initializer=initi_bias
) # X.shape is (samples, timesteps, dimension)
#model.add(Dense(30, activation="relu"))
model.add(Dense(output_dim=FLAGS.number_class))
model.add(Activation("sigmoid"))
sgd = keras.optimizers.SGD(lr=0.02,
momentum=0.0,
decay=0.0,
nesterov=False)
model.compile(optimizer=sgd,
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
batch_size=FLAGS.batch_size,
nb_epoch=FLAGS.max_epochs)
result = model.predict(x_test)
end = time.clock()
pprint("The Time For LSTM is " + str(end - start))
if is_binary_class == True:
results = evaluation.evaluation(
y_test, result, trigger_flag,
evalua_flag) # Computing ACCURACY,F1-score,..,etc
else:
y_test = loaddata.reverse_one_hot(y_test)
result = loaddata.reverse_one_hot(result)
accuracy = sklearn.metrics.accuracy_score(y_test, result)
f1_score = sklearn.metrics.f1_score(y_test, result, average="macro")
#print("F-score is :" + str(f1_score))
symbol_list2 = [0]
y_ = []
print("True is ")
#print(y_test)
print("The 0 of True is " + str(list(y_test).count(0)))
print("The 1 of True is " + str(list(y_test).count(1)))
print("The 2 of True is " + str(list(y_test).count(2)))
print("The 3 of True is " + str(list(y_test).count(3)))
print("The 4 of True is " + str(list(y_test).count(4)))
#print(len(y_test))
print("Predict is ")
#print(result)
print("The 0 of Predict is " + str(list(result).count(0)))
print("The 1 of Predict is " + str(list(result).count(1)))
print("The 2 of Predict is " + str(list(result).count(2)))
print("The 3 of Predict is " + str(list(result).count(3)))
print("The 4 of Predict is " + str(list(result).count(4)))
#print(len(result))
print("Accuracy of " + _model + "is :" + str(accuracy))
print("F-score of " + _model + "is :" + str(f1_score))
#for symbol in symbol_list2:
#for tab in range(len(y_test)):
#if y_test[tab] == symbol and y_test[tab] == result[tab]:
#y_.append(symbol)
#accuracy = float(len(y_)) / (list(result).count(symbol))
#print("Accuracy of " + str(symbol) + " is :" + str(accuracy))
results = {
'ACCURACY': accuracy,
'F1_SCORE': 9999,
'AUC': 9999,
'G_MEAN': 9999
}
try:
y_test2 = np.array(loaddata.reverse_one_hot(y_test))
result2 = np.array(loaddata.reverse_one_hot(result))
except:
y_test2 = y_test
result2 = result
# Statistics False Alarm Rate
with open(os.path.join("./stat/", "StatFalseAlarm_" + filename + "_True"),
"w") as fout:
for tab in range(len(y_test2)):
fout.write(str(int(y_test2[tab])) + '\n')
with open(
os.path.join(
"./stat/", "StatFalseAlarm_" + filename + "_" + _model + "_" +
"_Predict"), "w") as fout:
for tab in range(len(result2)):
fout.write(str(int(result2[tab])) + '\n')
#for each_eval, each_result in results.items():
#result_list_dict[each_eval].append(each_result)
for each_eval in evaluation_list:
result_list_dict[each_eval].append(results[each_eval])
#for eachk, eachv in result_list_dict.items():
#result_list_dict[eachk] = np.average(eachv)
if evalua_flag:
with open(os.path.join(FLAGS.output, "Comparison_Log_" + filename),
"a") as fout:
outfileline = _model + '_' + str(FLAGS.num_neurons1) + ":__"
fout.write(outfileline)
for each_eval in evaluation_list:
fout.write(
each_eval + ": " +
str(round(np.average(result_list_dict[each_eval]), 3)) +
",\t")
#for eachk, eachv in result_list_dict.items():
#fout.write(eachk + ": " + str(round(eachv, 3)) + ",\t")
fout.write('\n')
#return epoch_training_loss_list,epoch_val_loss_list
else:
return results