def tsne(args):
X_train, X_test, X_test_original, Y_test = load_mnist_data()
random_image = np.random.uniform(0, 1, (100, 28, 28, 1))
print("random noise image")
plt.figure(4, figsize=(2, 2))
plt.title('random noise image')
plt.imshow(random_image[0].reshape(28, 28), cmap=plt.cm.gray)
# intermidieate output of discriminator
f = model.feature_extractor(args)
feature_map_of_random = f.predict(random_image, verbose=1)
feature_map_of_mnist = f.predict(X_test_original[Y_test != 1][:300],
verbose=1)
feature_map_of_mnist_1 = f.predict(X_test[:100], verbose=1)
# t-SNE for visualization
output = np.concatenate(
(feature_map_of_random, feature_map_of_mnist, feature_map_of_mnist_1))
output = output.reshape(output.shape[0], -1)
anomaly_flag = np.array([1] * 100 + [0] * 300)
X_embedded = TSNE(n_components=2).fit_transform(output)
plt.figure(5)
plt.title("t-SNE embedding on the feature representation")
plt.scatter(X_embedded[:100, 0],
X_embedded[:100, 1],
label='random noise(anomaly)')
plt.scatter(X_embedded[100:400, 0],
X_embedded[100:400, 1],
label='mnist(anomaly)')
plt.scatter(X_embedded[400:, 0],
X_embedded[400:, 1],
label='mnist(normal)')
plt.legend()
plt.show()
def run(data_dir, batchsize=50, n_epochs=50):
tf.reset_default_graph()
train_dir = data_dir + 'train/'
test_dir = data_dir + 'test/'
train_imgs, train_labels = load_images(train_dir)
test_imgs, test_labels = load_images(test_dir,
resize=train_imgs.shape[2],
seq_len=train_imgs.shape[1])
n_samples = train_imgs.shape[0]
#train_dataset = tf.data.Dataset.from_tensor_slices((train_imgs,train_labels))
test_dataset = tf.data.Dataset.from_tensor_slices((test_imgs, test_labels))
train_img = tf.data.Dataset.from_tensor_slices(train_imgs)
train_labels = tf.data.Dataset.from_tensor_slices(train_labels)
train_dataset = tf.data.Dataset.zip((train_img, train_labels))
train_dataset = train_dataset.shuffle(
buffer_size=100,
reshuffle_each_iteration=True).batch(batchsize).repeat()
test_dataset = test_dataset.shuffle(
buffer_size=100, reshuffle_each_iteration=True).batch(batchsize)
iterator = tf.data.Iterator.from_structure(train_dataset.output_types,
train_dataset.output_shapes)
x, y = iterator.get_next()
train_iterator = iterator.make_initializer(train_dataset)
test_iterator = iterator.make_initializer(test_dataset)
# apply random augmentations
ft_extr = feature_extractor()
logits = ft_extr.create_3dconv_model(x)
#loss = weighted_ce(next_element[1],model,.1)
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))
prediction = tf.nn.softmax(logits)
#cnf_matrix = tf.math.confusion_matrix(predictions=tf.to_float(tf.argmax(prediction,1)),labels=tf.to_float(tf.argmax(y, 1)),num_classes=2)
equality = tf.equal(tf.to_float(tf.argmax(prediction, 1)),
tf.to_float(tf.argmax(y, 1)))
accuracy = tf.reduce_mean(tf.to_float(equality))
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
optimizer = tf.train.AdamOptimizer(learning_rate=.001).minimize(loss)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(train_iterator)
saver = tf.train.Saver()
for epoch in range(n_epochs):
ep_loss = []
ep_cnf = []
for _ in range(int(n_samples / batchsize)):
_, b_loss = sess.run([optimizer, loss],
feed_dict={'is_training:0':
True}) #cnf_mat cnf_matrix
ep_loss.append(b_loss)
#ep_cnf.append(cnf_mat)
print(np.mean(ep_loss))
print(np.mean(ep_cnf, axis=0))
if (n_epochs % 10 == 0):
save_path = saver.save(
sess, data_dir + str(epoch) + "_checkpoint.ckpt")
print('predicting..')
save_path = saver.save(sess, data_dir + "final_checkpoint.ckpt")
with tf.SessionL() as sess:
sess.run(test_iterator)
result_set = []
try:
while True:
pred = sess.run(prediction,
feed_dict={'is_training:0': False})
result_set.append(pred)
except:
pass
import numpy as np
import chess
import model
import input
FLAGS = tf.app.flags.FLAGS
label_strings, _ = input.load_labels()
with tf.device('/cpu:0'):
board = tf.placeholder(tf.float32, shape=[1, 8, 8, 6])
turn = tf.placeholder(tf.float32, shape=[1])
#player = tf.placeholder(tf.float32, shape=[1])
label = tf.placeholder(tf.int64, shape=[1])
example = [board, turn]
features, _ = model.feature_extractor([board])
logits, _ = model.model(example, features)
onehot_labels = tf.one_hot(label, model.NUM_LABELS, dtype=tf.float32)
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits,
labels=onehot_labels))
saver = tf.train.Saver()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
checkpoint = tf.train.get_checkpoint_state(FLAGS.logdir)
if checkpoint and checkpoint.model_checkpoint_path:
makedir('valid_result')
valid_result = f'valid_result/{mag}_train-{train_slide}_valid-{valid_slide}_DArate-{DArate}.csv'
makedir('model_params')
model_params = f'model_params/{mag}_train-{train_slide}_DArate-{DArate}.pth'
f = open(log, 'w')
f_writer = csv.writer(f, lineterminator='\n')
csv_header = ["epoch", "class_loss", "domain_loss", "train_acc"]
f_writer.writerow(csv_header)
f.close()
torch.backends.cudnn.benchmark=True #cudnn benchmark mode
# load model
from model import feature_extractor, class_predictor, domain_predictor, DAMIL
# declare each block
feature_extractor = feature_extractor()
class_predictor = class_predictor()
domain_predictor = domain_predictor(domain_num)
# DAMIL
model = DAMIL(feature_extractor, class_predictor, domain_predictor)
model = model.to(device)
# use cross entropy loss function
loss_fn = nn.CrossEntropyLoss()
# use SGDmomentum for optimizer
optimizer = optim.SGD(model.parameters(), lr=0.0001, momentum=0.9, weight_decay=0.0)
# start training
for epoch in range(EPOCHS):
# generate bags
EP = 15
if __name__ == '__main__':
argument = sys.argv[1:]
source_domain = argument[:-1]
target_domain = argument[-1]
os.makedirs('./model/' + target_domain, exist_ok=True)
N = len(source_domain)
# dataloader
source_dataloader_list = []
source_clf = {}
source_loss = {}
extractor = feature_extractor().to(device)
#extractor.load_state_dict(torch.load('./model/2'+target_domain+'/extractor_5.pth'))
extractor_optim = optim.Adam(extractor.parameters(), lr=3e-4)
min_ = float('inf')
for source in source_domain:
print(source)
dataset = DATASET(source, source + '_train.csv')
dataset = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
if len(dataset) < min_:
min_ = len(dataset)
source_dataloader_list.append(dataset)
# c1 : for target
# c2 : for source
from numpy import linalg as LA
import random
import matplotlib.pyplot as plt
from matplotlib import style
import pandas as pd
import seaborn as sns
import math
import cntk as C
from model import feature_extractor
import json
#######################
target_dist = 30
target_var = 5
#######################
f1 = feature_extractor((2, 360), (1, 32), 0.7)
with open('training_human_data.json') as json_data:
data = json.load(json_data)
#print(np.array(data[list(data.keys())[0]]['radardata_list'][0]['observation']).shape)
#print(data[list(data.keys())[0]]['radardata_list'][0]['position'])
#print(len(data[list(data.keys())[0]]['radardata_list']))
#print(data.keys())
data_new = {}
targets = {}
for key in data.keys():
data_new[key] = []
targets[key] = []
observations = np.array(data[key]['radardata_list'])
n = len(observations)
for i in range(n):
def main(src, tar):
G = feature_extractor().to(device)
cls_c1 = predictor().to(device)
cls_c2 = predictor().to(device)
cls_c1.apply(weights_init_uniform)
cls_c2.apply(weights_init_uniform)
### dataloader ###
if src == 'mnist':
src_train_set = dset.MNIST('./dataset/mnist', train=True, download=True, transform=gray2rgb_transform)
elif src == 'mnistm':
src_train_set = DATASET('./dataset/mnistm/train', './dataset/mnistm/train.csv', transforms=rgb_transform)
elif src == 'svhn':
src_train_set = dset.SVHN(root='./dataset/svhn/', download=download, transform=rgb_transform)
elif src == 'usps':
src_train_set = DATASET('./dataset/usps/train', './dataset/usps/train.csv', transforms=gray2rgb_transform)
if tar == 'svhn':
tar_train_set = dset.SVHN(root='./dataset/svhn/', download=download, transform = rgb_transform)
elif tar == 'mnist':
tar_train_set = dset.MNIST('./dataset/mnist', train=True, download=True, transform=gray2rgb_transform)
elif tar == 'mnistm':
tar_train_set = DATASET('./dataset/mnistm/train', './dataset/mnistm/train.csv', transform=rgb_transform)
elif tar == 'usps':
tar_train_set = DATASET('./dataset/usps/train', './dataset/usps/train.csv', transform=rgb_transform)
src_train_loader = torch.utils.data.DataLoader(
dataset = src_train_set,
batch_size = BATCH_SIZE,
shuffle = True,
)
tar_train_loader = torch.utils.data.DataLoader(
dataset = tar_train_set,
batch_size = BATCH_SIZE,
shuffle = True,
)
optimizer_encoder = optim.Adam(G.parameters() , lr=3e-4, weight_decay=0.0005)
optimizer_clf_1 = optim.Adam(cls_c1.parameters(), lr=3e-4, weight_decay=0.0005)
optimizer_clf_2 = optim.Adam(cls_c2.parameters(), lr=3e-4, weight_decay=0.0005)
# train
ac_list, loss_list = train(G, cls_c1, cls_c2, optimizer_encoder, optimizer_clf_1, optimizer_clf_2, EP, src_train_loader, tar_train_loader, src, tar)
ac_list = np.array(ac_list).flatten()
# plot tsne
loss_list = np.array(loss_list).flatten()
epoch = [i for i in range(EP)]
my_function.tsne_plot(G, src_train_loader, tar_train_loader, src, tar, BATCH_SIZE, 'mcd', mode=False)
### plot learning curve ###
plt.figure()
plt.plot(epoch, ac_list)
plt.xlabel('EPOCH')
plt.ylabel('Accuracy')
plt.title('domian_adapt : ' + src + ' to ' + tar)
plt.savefig('./learning_curve/domian_adapt_' + src + '_to_' + tar + '_accuracy.jpg')
plt.figure()
plt.plot(epoch, loss_list)
plt.xlabel('EPOCH')
plt.ylabel('Loss')
plt.title('domian_adapt : ' + src + ' to ' + tar)
plt.savefig('./learning_curve/domian_adapt_' + src + '_to_' + tar + '_loss.jpg')
filenames = tf.placeholder(tf.string, shape=[None])
dataset = input.inputs(filenames)
iterator = tf.contrib.data.Iterator.from_structure(dataset.output_types,
dataset.output_shapes)
training_init_op = iterator.make_initializer(dataset)
examples, labels, results = iterator.get_next()
labels = tf.cast(labels, tf.int32)
#labels = tf.one_hot(labels, model.NUM_LABELS, dtype=tf.float32)
# Model
features = model.feature_extractor(examples)
layers = []
nn_logits = model.policy_model(examples, features, layers)
saver = tf.train.Saver(save_relative_paths=True)
memory = memory_head.MemoryHead(32768 * 8, model.NUM_LABELS)
memory_input = layers[
1] #tf.one_hot(labels, model.NUM_LABELS, dtype=tf.float32)#layers[2]
logits, mask, teacher_loss = memory.policy_model(examples, memory_input,
labels)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
fullsaver = tf.train.Saver(save_relative_paths=True)
def train_with_tf(train_imgs,
train_labels,
test_imgs,
test_labels,
n_epochs=10,
batchsize=50):
# additional_train_imgs = np.repeat(train_imgs[:122,:],4,axis=0)
# additional_train_labels = np.repeat(train_labels[:122,:],4,axis=0)
# train_imgs = np.concatenate((train_imgs,additional_train_imgs),axis=0)
# train_labels = np.concatenate((train_labels,additional_train_labels),axis=0)
# Fourier transform
# fft_train = fourier_transform(train_imgs)
# Random cnn features
# train_imgs,test_imgs = apply_pretrained_model(train_imgs,test_imgs)
train_dataset = tf.data.Dataset.from_tensor_slices(
(train_imgs, train_labels))
valid_dataset = tf.data.Dataset.from_tensor_slices(
(train_imgs, train_labels))
test_dataset = tf.data.Dataset.from_tensor_slices((test_imgs, test_labels))
n_samples = train_imgs.shape[0]
train_dataset = train_dataset.shuffle(
buffer_size=100, reshuffle_each_iteration=True).batch(
batchsize, drop_remainder=True).repeat() #.prefetch(50)
valid_dataset = valid_dataset.batch(batchsize)
test_dataset = test_dataset.batch(batchsize)
iterator = tf.data.Iterator.from_structure(train_dataset.output_types,
train_dataset.output_shapes)
next_element = iterator.get_next()
train_iterator = iterator.make_initializer(train_dataset)
valid_iterator = iterator.make_initializer(valid_dataset)
test_iterator = iterator.make_initializer(test_dataset)
ft_extr = feature_extractor()
# abandoned as well:
#model = ft_extr.create_lstm_model(next_element[0])
#model,pre_fc = ft_extr.small_model(next_element[0])
model, pre_fc = ft_extr.create_3dconv_model(next_element[0])
# abandoned approaches
#loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=model,labels=next_element[1]))
#loss = sparse_cost_sensitive_loss(model,next_element[1],[[1.,1.],[1.,1.]]) #TODO label to onehot
#loss = weighted_ce(next_element[1],model,.1)
loss = tf.nn.weighted_cross_entropy_with_logits(
tf.cast(next_element[1], tf.float32), model, tf.constant(6000.))
prediction = tf.nn.softmax(model)
cnf_matrix = tf.math.confusion_matrix(
predictions=tf.to_float(tf.argmax(prediction, 1)),
labels=tf.to_float(tf.argmax(next_element[1], 1)),
num_classes=2)
equality = tf.equal(tf.to_float(tf.argmax(prediction, 1)),
tf.to_float(tf.argmax(next_element[1], 1)))
accuracy = tf.reduce_mean(tf.to_float(equality))
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
optimizer = tf.train.AdamOptimizer(learning_rate=.001).minimize(loss)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(train_iterator)
saver = tf.train.Saver()
for epoch in range(n_epochs):
ep_loss = []
ep_cnf = []
for _ in range(int(n_samples / batchsize + .5)):
_, b_loss, cnf_mat = sess.run(
[optimizer, loss, cnf_matrix],
feed_dict={'is_training:0': True})
ep_loss.append(b_loss)
ep_cnf.append(cnf_mat)
print(np.mean(ep_loss))
print(np.mean(ep_cnf, axis=0))
if (n_epochs % 10 == 0):
save_path = saver.save(
sess, data_dir + str(epoch) + "_checkpoint.ckpt")
encoded_train = []
sess.run(valid_iterator)
try:
while True:
enc_pred = sess.run(pre_fc, feed_dict={'is_training:0': False})
encoded_train.append(enc_pred)
except:
pass
encoded_train = np.vstack(np.array(encoded_train))
print('predicting..')
save_path = saver.save(sess, data_dir + "final_checkpoint.ckpt")
sess.run(test_iterator)
result_set = []
encoded_test = []
try:
while True:
pred, pre_feats = sess.run([prediction, pre_fc],
feed_dict={'is_training:0': False})
result_set.append(pred)
encoded_test.append(pre_feats)
except:
pass
# range
# sess.run(optimizer,cost)
# training is false and true sometimes
# save_path = saver.save(sess, "path.ckpt")
# saver.restore(sess, "path.ckpt")
encoded_test = np.vstack(np.array(encoded_test))
result_set = np.vstack(np.array(result_set))
return encoded_train, encoded_test, result_set
def main(src, tar):
G = feature_extractor().to(device)
cls_c1 = predictor().to(device)
cls_c2 = predictor().to(device)
cls_c1.apply(weights_init_uniform)
cls_c2.apply(weights_init_uniform)
### dataloader ###
if src == 'sketch':
src_train_set = DATASET('sketch', 'sketch_train.csv')
elif src == 'infograph':
src_train_set = DATASET('infograpth', 'infograph_train.csv')
elif src == 'real':
src_train_set = DATASET('real', 'real_train.csv')
elif src == 'quickdraw':
src_train_set = DATASET('quickdraw', 'quickdraw_train.csv')
if tar == 'sketch':
tar_train_set = DATASET('sketch', 'sketch_train.csv')
elif tar == 'infograph':
tar_train_set = DATASET('infograpth', 'infograph_train.csv')
elif tar == 'real':
tar_train_set = DATASET('real', 'real_train.csv')
elif tar == 'quickdraw':
tar_train_set = DATASET('quickdraw', 'quickdraw_train.csv')
src_train_loader = torch.utils.data.DataLoader(
dataset=src_train_set,
batch_size=BATCH_SIZE,
shuffle=True,
)
tar_train_loader = torch.utils.data.DataLoader(
dataset=tar_train_set,
batch_size=BATCH_SIZE,
shuffle=True,
)
optimizer_encoder = optim.Adam(G.parameters(),
lr=2e-4,
weight_decay=0.0005)
optimizer_clf_1 = optim.Adam(cls_c1.parameters(),
lr=2e-4,
weight_decay=0.0005)
optimizer_clf_2 = optim.Adam(cls_c2.parameters(),
lr=2e-4,
weight_decay=0.0005)
# train
ac_list, loss_list = train(G, cls_c1, cls_c2, optimizer_encoder,
optimizer_clf_1, optimizer_clf_2, EP,
src_train_loader, tar_train_loader, src, tar)
ac_list = np.array(ac_list).flatten()
# plot tsne
loss_list = np.array(loss_list).flatten()
#epoch = [i for i in range(EP)]
#my_function.tsne_plot(G, src_train_loader, tar_train_loader, src, tar, BATCH_SIZE, 'mcd', mode=False)
### plot learning curve ###
plt.figure()
plt.plot(epoch, ac_list)
plt.xlabel('EPOCH')
plt.ylabel('Accuracy')
plt.title('domian_adapt : ' + src + ' to ' + tar)
plt.savefig('./learning_curve/domian_adapt_' + src + '_to_' + tar +
'_accuracy.jpg')
plt.figure()
plt.plot(epoch, loss_list)
plt.xlabel('EPOCH')
plt.ylabel('Loss')
plt.title('domian_adapt : ' + src + ' to ' + tar)
plt.savefig('./learning_curve/domian_adapt_' + src + '_to_' + tar +
'_loss.jpg')