def main():
# start measuring execution time
start = time.time()
# Load training & testing datasets
X_train, y_train, X_test, y_test = utils.load_dataset()
# Make a SOM whose units(clusters) are from 0 to 24 and learning from X_train
model = Som((5, 5), 42, learning_rate=0.2)
model.fit(X_train, num_epochs=1, updates_epoch=1)
# Choose the proper unit for each row in the testing dataset
y_pred = model.predict(X_test)
y_pred = utils.create_binary_prediction_som(y_pred, 175341, 0.05, 0.1)
print("execution time: ", time.time() - start)
utils.cal_accuracy(y_test, y_pred, 175341)
#######Create models for testing the NSL-KDD dataset#######
X_train = pd.read_csv('../dataset/unsw-nb15/nsl-kdd-ver/train-set.csv')
model = Som((5, 5), 5, learning_rate=0.2)
model.fit(X_train, num_epochs=1, updates_epoch=1)
# Save the model
utils.save_model(model, './model/nsl-kdd-model.sav')
def train(self, x, y, epochs, learning_rate, early_stop=False):
history = {'epochs':[], 'loss':[], 'accuracy':[]}
print('Start training...')
for epoch in range(1, epochs + 1):
# backpropagation
y_hat = self.forward(x)
self.backward(y, y_hat, learning_rate)
# calculate loss and accuracy
loss = self.MSE(y, y_hat)
acc = cal_accuracy(y, y_hat)
# record the values
history['epochs'].append(epoch)
history['loss'].append(loss)
history['accuracy'].append(acc)
# print information
if (epoch % int(epochs / 20)) == 0:
print(f'epoch {epoch:<6} loss: {loss:.5f} accuracy: {acc:.5f}')
# early stopping
if early_stop and acc == 1.0:
print(f'epoch {epoch:<6} loss: {loss:.5f} accuracy: {acc:.5f}')
print('Accuracy = 1.0, early stop the training.')
break
return history
def disc_train(self, sample_shape, batch_feed, fake_state_action=None):
batch_size = sample_shape[0]
# state_rep, action_rep = self.read_real_data(None, batch_feed)
state_rep, action_rep = self.read_real_data_onehot_300(None, batch_feed)
# state_action = torch.cat([self.cast_gpu(state_rep), self.cast_gpu(action_rep)], -1)
embed_batch = self.vae.get_embed(self.cast_gpu(state_rep))
real_disc_v = self.discriminator(embed_batch.detach(), self.cast_gpu(action_rep))
if fake_state_action is None:
fake_state_action = self.sample_step(sample_shape)
else:
fake_state_action = fake_state_action
state_rep_f, action_rep_f = fake_state_action
if np.random.random()<0.5:
# print(action_rep.size())
# state_rep_f, action_rep_f = embed_batch.detach(), self.shuffle_action(action_rep)
state_rep_f, action_rep_f = embed_batch.detach(), action_rep[torch.randperm(action_rep.size()[0]), :]
# print(action_rep_f.size())
fake_disc_v = self.discriminator(state_rep_f.detach(), action_rep_f.detach())
rf_disc_v = torch.cat([real_disc_v, fake_disc_v], dim=0)
labels_one = torch.cat([torch.full((batch_size,),1.0), torch.full((batch_size,),0.0)])
labels_one = self.cast_gpu(labels_one)
# labels_one = self.cast_gpu(torch.FloatTensor([1] * batch_size + [0] * batch_size))
disc_loss = self.loss_BCE(rf_disc_v.view(-1), labels_one)
# disc_loss = BCELoss_double(rf_disc_v.view(-1), labels)
# disc_loss = - torch.mean(real_disc_v) + torch.mean(fake_disc_v)
disc_loss = Pack(disc_loss=disc_loss)
disc_acc = cal_accuracy(rf_disc_v.view(-1), labels_one)
return disc_loss, disc_acc
def disc_train(self, sample_shape, batch_feed, fake_state_action=None):
batch_size = sample_shape[0]
# state_rep, action_rep = self.read_real_data(None, batch_feed)
state_rep, action_rep = self.read_real_data_onehot(None, batch_feed)
state_action = torch.cat([self.cast_gpu(state_rep), self.cast_gpu(action_rep)], -1)
embed_batch = self.vae.encode(state_action)
real_disc_v = self.discriminator(embed_batch.detach())
if fake_state_action is None:
fake_state_action = self.sample_step(sample_shape)
else:
fake_state_action = fake_state_action
if self.config.round_for_disc:
fake_disc_v = self.discriminator(fake_state_action.detach())
else:
fake_disc_v = self.discriminator(fake_state_action.detach())
rf_disc_v = torch.cat([real_disc_v, fake_disc_v], dim=0)
labels_one = torch.cat([torch.full((batch_size,),1.0), torch.full((batch_size,),0.0)])
labels_one = self.cast_gpu(labels_one)
# labels_one = self.cast_gpu(torch.FloatTensor([1] * batch_size + [0] * batch_size))
disc_loss = self.loss_BCE(rf_disc_v.view(-1), labels_one)
# disc_loss = BCELoss_double(rf_disc_v.view(-1), labels)
# disc_loss = - torch.mean(real_disc_v) + torch.mean(fake_disc_v)
disc_loss = Pack(disc_loss=disc_loss)
disc_acc = cal_accuracy(rf_disc_v.view(-1), labels_one)
return disc_loss, disc_acc
def disc_train(self, sample_shape, batch_feed, fake_state_action=None):
batch_size = sample_shape[0]
real_state_rep, action_data_feed = self.read_real_data(sample_shape, batch_feed)
real_disc_v = self.discriminator(real_state_rep, action_data_feed)
if fake_state_action is None:
fake_state_rep, fake_action_rep = self.sample_step(sample_shape)
else:
fake_state_rep, fake_action_rep = fake_state_action
fake_disc_v = self.discriminator(fake_state_rep.detach(), fake_action_rep.detach())
rf_disc_v = torch.cat([real_disc_v, fake_disc_v], dim=0)
true_label = 1.0
false_label = 0.0
labels_one = torch.cat([torch.full((batch_size,),true_label), torch.full((batch_size,),false_label)])
# labels_one = torch.cat([torch.full((batch_size,),1.0), torch.full((batch_size,),0.0)])
labels_one = self.cast_gpu(labels_one)
# labels_one = self.cast_gpu(torch.FloatTensor([1] * batch_size + [0] * batch_size))
disc_loss = self.loss_BCE(rf_disc_v.view(-1), labels_one) + self.discriminator.l2_norm()
# disc_loss = BCELoss_double(rf_disc_v.view(-1), labels)
# disc_loss = - torch.mean(real_disc_v) + torch.mean(fake_disc_v)
disc_loss = Pack(disc_loss=disc_loss)
disc_acc = cal_accuracy(rf_disc_v.view(-1), labels_one)
return disc_loss, disc_acc
def disc_train(self, sample_shape, batch_feed, fake_state_action=None):
batch_size = sample_shape[0]
real_state_rep, action_data_feed = self.read_real_data(sample_shape, batch_feed)
real_disc_v = self.discriminator(real_state_rep, action_data_feed)
if fake_state_action is None:
fake_state_rep, fake_action_rep = self.sample_step(sample_shape)
else:
fake_state_rep, fake_action_rep = fake_state_action
# if self.config.round_for_disc:
# fake_disc_v = self.discriminator(fake_state_rep.detach().round(), fake_action_rep.detach().round())
# else:
if np.random.random()<0.5:
fake_state_rep, fake_action_rep = real_state_rep.detach(), action_data_feed[:,torch.randperm(action_data_feed.size()[1])]
fake_disc_v = self.discriminator(fake_state_rep.detach(), fake_action_rep.detach())
rf_disc_v = torch.cat([real_disc_v, fake_disc_v], dim=0)
labels_one = torch.cat([torch.full((batch_size,),1.0), torch.full((batch_size,),0.0)])
labels_one = self.cast_gpu(labels_one)
# labels_one = self.cast_gpu(torch.FloatTensor([1] * batch_size + [0] * batch_size))
disc_loss = self.loss_BCE(rf_disc_v.view(-1), labels_one)
# disc_loss = BCELoss_double(rf_disc_v.view(-1), labels)
# disc_loss = - torch.mean(real_disc_v) + torch.mean(fake_disc_v)
disc_loss = Pack(disc_loss=disc_loss)
disc_acc = cal_accuracy(rf_disc_v.view(-1), labels_one)
return disc_loss, disc_acc
def main():
# start measuring execution time
start = time.time()
# Load training & testing datasets
X_train, y_train, X_test, y_test = utils.load_dataset()
# Make a SOM whose units(clusters) are from 0 to 24 and learning from X_train
model = Som((5, 5), 42, learning_rate=0.2)
model.fit(X_train, num_epochs=1, updates_epoch=1)
# Choose the proper unit for each row in the testing dataset
y_pred = model.predict(X_test)
y_pred = utils.create_binary_prediction_som(y_pred, 175341, 0.65, 0.05)
print("execution time: ", time.time() - start)
utils.cal_accuracy(y_test, y_pred, 175341)
def test_rf_classification():
iris = datasets.load_iris()
X, y = iris.data, iris.target
print (X.shape, y.shape)
train_X, train_y, test_X, test_y = split_train_test(X, y)
print (train_X.shape, train_y.shape, test_X.shape, test_y.shape)
clf = RandomForestClassifier(n_estimators=100)
clf.fit(train_X, train_y)
preds = clf.predict(test_X)
accuracy = cal_accuracy(test_y, preds)
print ('accuracy: ', accuracy)
def test_gradient_boosting_classification():
iris = datasets.load_iris()
X, y = iris.data, iris.target
print (X.shape, y.shape)
train_X, train_y, test_X, test_y = split_train_test(X, y)
print (train_X.shape, train_y.shape, test_X.shape, test_y.shape)
clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
clf.fit(train_X, train_y)
preds = clf.predict(test_X)
accuracy = cal_accuracy(test_y, preds)
print ('accuracy: ', accuracy)
def main():
# start measuring execution time
start = time.time()
# Load training & testing datasets
X_train, y_train, X_test, y_test = utils.load_dataset()
gini_classifier = train_with_index('gini', X_train, y_train)
print("Results Using Gini Index: \n")
# Prediction using gini
y_pred_gini = prediction(X_test, gini_classifier)
print("execution time of classification with gini index: ",
time.time() - start)
utils.cal_accuracy(y_test, y_pred_gini, 175341)
start = time.time()
entropy_classifier = train_with_index('entropy', X_train, y_train)
print("Results Using Entropy: \n")
# Prediction using entropy
y_pred_entropy = prediction(X_test, entropy_classifier)
print("execution time of classification with entropy index: ",
time.time() - start)
utils.cal_accuracy(y_test, y_pred_entropy, 175341)
#######Create models for testing the NSL-KDD dataset#######
X_train = pd.read_csv('../dataset/unsw-nb15/nsl-kdd-ver/train-set.csv')
gini_classifier = train_with_index('gini', X_train, y_train)
entropy_classifier = train_with_index('entropy', X_train, y_train)
# Save the models
utils.save_model(gini_classifier, './model/nsl-kdd-model-gini.sav')
utils.save_model(entropy_classifier, './model/nsl-kdd-model-entropy.sav')
def test_classification(model):
Classifier = models[model]
dataset = datasets.load_iris()
X, y = dataset.data, dataset.target
print (X.shape, y.shape)
train_X, train_y, test_X, test_y = split_train_test(X, y)
print (train_X.shape, train_y.shape, test_X.shape, test_y.shape)
clf = Classifier()
clf.fit(train_X, train_y)
preds = clf.predict(test_X)
accuracy = cal_accuracy(test_y, preds)
print (accuracy)
min_split_samples=min_split_samples,
min_impurity=min_impurity,
regression=False)
def fit(self, X, y):
y = to_categorical(y)
super(GradientBoostingClassifier, self).fit(X, y)
if __name__ == '__main__':
from sklearn import datasets
from utils import split_train_test, cal_accuracy
iris = datasets.load_iris()
X, y = iris.data, iris.target
print (X.shape, y.shape)
train_X, train_y, test_X, test_y = split_train_test(X, y)
print (train_X.shape, train_y.shape, test_X.shape, test_y.shape)
clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
clf.fit(train_X, train_y)
preds = clf.predict(test_X)
accuracy = cal_accuracy(test_y, preds)
print ('accuracy: ', accuracy)
feature, support = convert_sparse_train_input1(adj, features)
train_labels, weight_mask = convert_loss_input(train_labels, weight_mask)
out = net((feature, support))
out = out[0]
# loss = masked_loss(out, train_labels, weight_mask)
loss = weighted_loss(out, train_labels, weight_mask)
# print("cross entropy loss: {:.5f} ".format(loss.item()))
loss += args.weight_decay * net.l2_loss()
# acc = masked_acc(out, train_labels)
acc = cal_accuracy(out, train_labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
t2 = time.time()
if (epoch+1) % 10 == 0:
print("Epoch:" ,'%04d'% (epoch+1), "time: {:.5f}, loss: {:.5f}, acc: {:.5f}".\
format( (t2-t1), loss.item(), acc.item()))
# if epoch % 10 == 0:
# print(epoch, loss.item(), acc.item())
net.eval()
rpn_accuracy_for_epoch = []
best_loss = np.Inf
while True:
#try:
X, Y, gta = next(gen)
#for i in range(100):
loss_rpn = model_rpn.train_on_batch(X, Y)
#it will return cls, regression bbox, and base feature map
P_rpn = model_rpn.predict_on_batch(X)
#The input structure is [boxes, scores, maximum]
#roi = utils.propose(P_rpn[1], P_rpn[0], 300)
rois, scores = utils.propose_cpu(P_rpn[1], P_rpn[0], 300)
#utils.propose_cpu(P_rpn[1], P_rpn[0], 300)
#print(rois.shape)
utils.cal_accuracy(gta, rois, scores)
#print(np.asarray(roi))
#print(roi[0])
#print(P_rpn[0], P_rpn[1])
print('iter {0}, epoch {1}, loss {2}'.format(iter_num, epoch_num,
loss_rpn))
iter_num += 1
if iter_num == epoch_length:
name = str(iter_num) + str(epoch_num) + 'rpn.h5'
model_rpn.save_weights(name)
iter_num = 0
epoch_num += 1
if epoch_num == num_epochs:
print('Training complete, exiting.')
model_rpn.save_weights('rpn.h5')
import sys
import networkx as nx
import os
import time
from utils import load_data, normalize, cal_accuracy
from model import GCN
datastr = "pubmed"
adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(datastr)
#adj = nx.to_scipy_sparse_matrix(adj)
norm_adj = normalize(adj)
#norm_adj = adj
#print(adj.shape, adj_n.shape, features.shape, y_train.shape, train_mask.shape)
i = torch.LongTensor([norm_adj.row, norm_adj.col])
v = torch.FloatTensor(norm_adj.data)
norm_adj = torch.sparse.FloatTensor(i,v, adj.shape)
features = torch.tensor(features, dtype=torch.float, requires_grad=False)
y_train = torch.tensor(y_train, dtype=torch.long, requires_grad=False)
y_val = torch.tensor(y_val, dtype=torch.long, requires_grad=False)
y_test = torch.tensor(y_test, dtype=torch.long, requires_grad=False)
load_from = "gcn_model"
gcn = torch.load(load_from)
gcn.eval()
output = gcn(features, norm_adj)
test_acc = cal_accuracy(output, y_test, test_mask)
print("test acc:", test_acc)
m2_data = m2_data.reshape(batch_size, 30, 9)
target = target.reshape(batch_size, 20)
summary, c, _ = sess.run(
[merged_summary, cost, optimizer],
feed_dict={
m1_X: m1_data,
m2_X: m2_data,
Y: target
})
m1_data = np.array([])
m2_data = np.array([])
target = np.array([])
count = 0
writer.add_summary(summary, global_step=epoch)
print("Epoch: [%2d], time: [%4.4f], loss: [%.8f]" %
(epoch + 1, time.time() - start_time, c))
saver.save(sess, checkpoint_dir)
print('Learning Finished..!')
else:
m2_test_x, m1_test_x, t_target = load_data(2)
print('Test Acc : [%.8f]' %
cal_accuracy(m1_test_x, m2_test_x, t_target, sess, accuracy,
correct_prediction, hypothesis, m1_X, m2_X, Y))
print('Train Acc : [%.8f]' % cal_accuracy(
m1_x, m2_x, label_data, sess, accuracy, correct_prediction,
hypothesis, m1_X, m2_X, Y)) #에러분석시 주석처리
# os.system('shutdown -s -f -t 0')
gcn = torch.load(load_from)
optimizer = torch.optim.Adam(gcn.parameters(recurse=True), lr=lr, weight_decay=weight_decay)
train_time = time.time()
val_loss_pre = 1e9
val_acc_pre = 0
dec_time = 0
for epoch in range(args.epoch):
t = time.time()
gcn.train()
optimizer.zero_grad()
output = gcn(features, norm_adj)
pred = output[train_mask]
ans = torch.argmax(y_train[train_mask],dim=1)
loss = F.cross_entropy(pred, ans)
train_acc = cal_accuracy(output, y_train, train_mask)
loss.backward()
optimizer.step()
#print(torch.min(pred), torch.max(pred))
gcn.eval()
pred = output[val_mask]
ans = torch.argmax(y_train[val_mask],dim=1)
val_loss = F.cross_entropy(pred, ans)
val_acc = cal_accuracy(output, y_val, val_mask)
print("epoch:", epoch, "time:", time.time()-t)
print("train_loss:",float(loss), "train_acc:", float(train_acc))
print("val_loss:", float(val_loss), "val_acc:", float(val_acc))
if val_loss > val_loss_pre and val_acc < val_acc_pre:
dec_time = dec_time + 1
