def main(argv=None):
data_file = FLAGS.data_dir + FLAGS.dataset_name + '.npz'
data = np.load(data_file)
read_index = FLAGS.read_index
train_data, train_labels, test_data, test_labels = data['train_X'], data[
'train_Y'], data['test_X'], data['test_Y']
train_X, train_Y, test_X, test_Y = train_data[read_index], train_labels[
read_index], test_data[read_index], test_labels[read_index]
if FLAGS.dataset_name != 'mnist':
train_X, test_X = train_X / 255, test_X / 255
val_X, val_Y = data['val_X'] / 255, data['val_Y']
else:
mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
val_X, val_Y = mnist.validation.images, mnist.validation.labels
Train_size = len(train_X)
total_batch = Train_size / FLAGS.batch_size
model.build(total_batch)
with tf.Session() as sess:
tf.global_variables_initializer().run()
print('== Get feature weight by using AFS ==')
A = run_train(sess, train_X, train_Y, val_X, val_Y)
print('== The Evaluation of AFS ==')
ac_score_list = run_test(A, train_X, train_Y, test_X, test_Y, total_batch)
show_result(ac_score_list, FLAGS.dataset_name)
def test_in_dir(test, dir, fd_result, fd_check):
output_m = test_minishell(test)
file_output_m, files_m = get_created_files(test)
output_b = test_bash(test)
file_output_b, files_b = get_created_files(test)
ret1 = check_text_differences(test, output_m, output_b)
ret2 = check_text_differences(None, file_output_m, file_output_b)
ret3 = check_created_files(files_m, files_b)
show_result(dir, fd_result, fd_check, ret1, ret2, ret3, test, output_m,
output_b, files_b, files_m, file_output_m, file_output_b)
def main():
train_url = "e:/data/comment_sentiment/train_set.csv"
test_url = "e:/data/comment_sentiment/test_set.csv"
train_x, train_y = utils.load_data(train_url)
test_x, test_y = utils.load_data(test_url)
bayes = Bayes()
bayes.train_model(train_x, train_y)
pre_y = bayes.predict(test_x)
utils.show_result(test_y, np.array([pre_y]).T, "bayes_comment")
def main():
train_url = "train_set.csv"
test_url = "test_set.csv"
x, y = utils.load_data(train_url)
test_x, test_y = utils.load_data(test_url)
gda = GDA()
gda.train_model(x, y)
pre_y = gda.predict(test_x)
utils.show_result(test_y, pre_y, "gda_comment")
def main():
train_url = "e:/data/comment_sentiment/train_set.csv"
test_url = "e:/data/comment_sentiment/test_set.csv"
x, y = utils.load_data(train_url)
test_x, test_y = utils.load_data(test_url)
lr = LogisticRegression()
lr.train_model(x, y)
pre_y = lr.predict(test_x)
utils.show_result(test_y, pre_y, "logistic_comment")
def main(params):
np.random.seed(7)
if params['data'] == 'linear':
inputs, labels = utils.generate_linear(n=100)
elif params['data'] == 'xor':
inputs, labels = utils.generate_xor_easy()
else:
raise KeyError("Please select a correct input data")
model = MyModel(in_features=2,
out_features=1,
hid_dim=[8, 16],
activation=params['no_activation'])
# Start training
e = 0
loss_recorder = []
while (1):
e += 1
outputs = model.forward(inputs)
if params['loss_fn'] == 'ce':
model.backward(inputs,
outputs,
labels,
nesterov=params['nesterov'],
loss='ce')
loss = model.ce(outputs, labels)
elif params['loss_fn'] == 'mse':
model.backward(inputs,
outputs,
labels,
nesterov=params['nesterov'],
loss='mse')
loss = model.mse(outputs, labels)
else:
raise ValueError(f"No such loss function: {params['loss_fn']}")
model.update(lr=params['lr'], gamma=params['momentum'])
loss_recorder.append(loss)
if e % params['show_period'] == 0:
preds = model.pred(outputs)
print(
f"[{e:^7d}]Accuracy now is "
f"{model.cal_acc(preds, labels):.2%}"
f", Loss now is {loss:.2f}", )
if loss < 0.01 or model.cal_acc(preds, labels) == 1:
print("Model has almost fitted the data")
print(f"Model prediction:\n {outputs}")
utils.show_result(inputs, labels, preds)
utils.show_loss_rec(loss_recorder, range(1, e + 1))
break
def train(model, optimizer, dataloader, loss_fn, metric_fn, param, current_epoch):
model.train()
summary = []
for i, data in enumerate(dataloader):
img_batch = data['img']
depth_batch = data['depth']
# move to GPU if available
img_batch, depth_batch = img_batch.cuda(), depth_batch.cuda()
# compute model output
output_batch = model(img_batch)
# clear previous gradients, compute loss
optimizer.zero_grad()
loss = loss_fn(output_batch, depth_batch, param['mode'], img=img_batch)
loss.backward()
# performs updates using calculated gradients
optimizer.step()
if i % 10 == 0:
print('Train: epoch %d iter %d loss: %.3f' % (current_epoch, i, loss))
writer.add_scalar('training loss', loss, current_epoch * len(dataloader) + i)
output_batch, depth_batch = output_batch.cpu().detach().numpy(), depth_batch.cpu().detach().numpy()
pred_batch = net.depth_inference(output_batch, param['mode'])
metrics = metric_fn(pred_batch, depth_batch)
# for metric, value in metrics.items():
# print('Training epoch %d iter %d metric %s: %.3f' % (epoch, i, metric, value))
# writer.add_scalar(metric, value, epoch * len(dataloader) + i)
metrics['loss'] = loss.item()
summary.append(metrics)
if i % 100 == 0:
if param['mode'] in ['sord_ent_weighted', 'sord_weighted_minent']:
aux_map = net.local_entropy(depth_batch, kernel=16, mask=True)
elif param['mode'] == 'sord_min_local_ent':
aux_map = net.local_entropy(pred_batch, kernel=16)
elif param['mode'] == 'sord_align_grad':
aux_map = net.edge(pred_batch)
else:
aux_map = None
error_map = net.depth_error_map(pred_batch, depth_batch)
show_result_fig = utils.show_result(data, pred_batch, aux_map, error_map, param['batch_size'], shuffle=True)
writer.add_figure('Train Input_RGB Input_Depth Output_Depth_map', show_result_fig, current_epoch * len(dataloader) + i)
metrics_train = {metric: np.mean([x[metric] for x in summary]) for metric in summary[0]}
print('\n------ After training %d epochs, train set metrics mean: ------ \n%s\n' % (current_epoch, metrics_train))
def evaluate(model, dataloader, loss_fn, metric_fn, param, current_epoch, writer):
model.eval()
summary = []
for i, data in enumerate(dataloader):
img_batch = data['img']
depth_batch = data['depth']
# move to GPU if available
img_batch_cropped = net.equally_spaced_crop(img_batch, param['eval_n_crop'])
depth_batch_cropped = net.equally_spaced_crop(depth_batch, param['eval_n_crop'])
img_batch_cropped, depth_batch_cropped = img_batch_cropped.cuda(), depth_batch_cropped.cuda()
with torch.no_grad():
# compute model output
output_batch_cropped = model(img_batch_cropped)
# compute loss (No need to compute loss for evaluation, save time)
# loss = loss_fn(output_batch_cropped, depth_batch_cropped, param['mode'], img=img_batch_cropped)
output_batch_cropped, depth_batch = output_batch_cropped.cpu().numpy(), depth_batch.cpu().numpy()
pred_batch_cropped = net.depth_inference(output_batch_cropped, param['mode'])
pred_batch = net.pred_overlap(pred_batch_cropped, depth_batch.shape, param['eval_n_crop'])
metrics = metric_fn(pred_batch, depth_batch)
# metrics['loss'] = loss.item()
summary.append(metrics)
if i % 10 == 0:
print('------')
for metric, value in metrics.items():
print('Val: epoch %d iter %d metric %s: %.3f' % (current_epoch, i, metric, value))
if param['mode'] in ['sord_ent_weighted', 'sord_weighted_minent']:
aux_map = net.local_entropy(depth_batch, kernel=16, mask=True)
elif param['mode'] == 'sord_min_local_ent':
aux_map = net.local_entropy(pred_batch, kernel=16)
elif param['mode'] == 'sord_align_grad':
aux_map = net.edge(pred_batch)
else:
aux_map = None
error_map = net.depth_error_map(pred_batch, depth_batch)
show_result_fig = utils.show_result(data, pred_batch, aux_map, error_map, param['batch_size'], shuffle=False)
writer.add_figure('Val Input_RGB Input_Depth Output_Depth_map', show_result_fig, current_epoch * len(dataloader) + i)
# for metric, value in metrics.items():
# writer.add_scalar(metric, value, i)
metrics_mean = {metric: np.mean([x[metric] for x in summary]) for metric in summary[0]}
return metrics_mean
accuracy_t = compute_acc(test_output, tes_label)
if accuracy_t > accuracy_max:
accuracy_max = accuracy_t
preds = test_output.data.max(1)[1]
print(classification_report(tes_label.cpu().detach().numpy(),
preds.cpu().detach().numpy(),
digits=6),
file=file_name)
torch.save(netG.state_dict(), './netG_max.pth')
torch.save(netD.state_dict(), './netD_max.pth')
print(
'[%d/%d][%d/%d] Loss_D: %.4f Loss_G: %.4f D(x): %.4f D(G(z)): %.4f / %.4f Acc: %.4f AccT: %.4f MAX: %.4f'
% (epoch + 1, opt.niter, i + 1, len(dataloader), errD, errG,
D_x, D_G_z1, D_G_z2, accuracy, accuracy_t, accuracy_max),
file=file_name)
###########################
# results visualization & model preservation
###########################
if (epoch + 1) % 50 == 0:
show_result(real_cpu.cpu().detach().numpy(), (epoch + 1),
path='%s/real_samples.png' % opt.outf)
fake = netG(eval_noise)
show_result(fake.cpu().detach().numpy(), (epoch + 1),
path='%s/fake_samples_epoch_%03d.png' %
(opt.outf, epoch + 1))
torch.save(netG.state_dict(),
'%s/netG_epoch_%d.pth' % (opt.outf, epoch + 1))
torch.save(netD.state_dict(),
'%s/netD_epoch_%d.pth' % (opt.outf, epoch + 1))
def train_adan(self):
stop = False
pre_epoch = 0
count = 0
self.build_adan()
# Trainable variables
T_vars = tf.trainable_variables()
self.D_vars = [
var for var in T_vars if var.name.startswith('discriminator')
]
self.C_vars = [
var for var in T_vars if var.name.startswith('classifier')
]
self.G_vars = [
var for var in T_vars if var.name.startswith('generator')
]
self.E_vars = [var for var in T_vars if var.name.startswith('encoder')]
self.R_vars = [var for var in T_vars if var.name.startswith('decoder')]
# Optimizer
with tf.control_dependencies(
tf.get_collection_ref(tf.GraphKeys.UPDATE_OPS)):
D_optimizer = tf.train.AdamOptimizer(self.lr_D,
beta1=0.5,
epsilon=1e-5).minimize(
self.D_loss,
var_list=self.D_vars)
C_optimizer = tf.train.AdamOptimizer(self.lr_C,
beta1=0.5,
epsilon=1e-5).minimize(
self.C_loss,
var_list=self.C_vars)
G_optimizer = tf.train.AdamOptimizer(self.lr_G,
beta1=0.5,
epsilon=1e-5).minimize(
self.G_loss,
var_list=self.G_vars)
E_optimizer = tf.train.AdamOptimizer(self.lr_E,
beta1=0.5,
epsilon=1e-5).minimize(
self.E_loss,
var_list=self.E_vars)
R_optimizer = tf.train.AdamOptimizer(self.lr_R,
beta1=0.5,
epsilon=1e-5).minimize(
self.R_loss,
var_list=self.R_vars)
tf.global_variables_initializer().run()
train_op = tf.group(C_optimizer, R_optimizer, E_optimizer, G_optimizer)
train_hist = {
'D_losses': [],
'C_losses': [],
'G_losses': [],
'R_losses': []
}
acc_hist = {'f_acc': [], 'r_acc': [], 'f_std': [], 'r_std': []}
with tqdm(total=self.epoch) as pbar:
for e in range(self.epoch):
if stop != True:
pbar.update(1)
index = np.arange(len(self.x_train))
np.random.shuffle(index)
x_train = self.x_train[index]
y_train_ohe = self.y_train_ohe[index]
for iter in range(x_train.shape[0] // self.batch):
x_ = x_train[iter * self.batch:(1 + iter) * self.batch]
y_ = y_train_ohe[iter * self.batch:(1 + iter) *
self.batch]
z_ = np.random.normal(0, 1, (self.batch, self.zdim))
# Training the discriminator and then freezing its weights
for d in range(self.d_times):
self.sess.run(D_optimizer, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_d = self.sess.run(self.D_loss, {
self.x: x_,
self.y: y_,
self.z: z_
})
self.sess.run(train_op, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_c, loss_r, loss_e, loss_g = self.sess.run(
[
self.C_loss, self.R_loss, self.E_loss,
self.G_loss
], {
self.x: x_,
self.y: y_,
self.z: z_
})
train_hist['D_losses'].append(loss_d)
train_hist['C_losses'].append(loss_c)
train_hist['G_losses'].append(loss_g)
train_hist['R_losses'].append(loss_r)
z_trn = np.random.normal(
0, 1, (self.x_train.shape[0], self.zdim))
prob_f = self.sess.run(self.prob_fake, {
self.z: z_trn,
self.y: self.y_train_ohe
})
prob_f_mean = np.mean(prob_f)
prob_trn = self.sess.run(self.prob_real, {
self.x: self.x_train,
self.y: self.y_train_ohe
})
prob_trn_mean = np.mean(prob_trn)
acc_hist['f_acc'].append(prob_f_mean)
acc_hist['r_acc'].append(prob_trn_mean)
acc_hist['f_std'].append(np.std(prob_f))
acc_hist['r_std'].append(np.std(prob_trn))
prob_r = self.sess.run(self.prob_real,
{self.x: self.x_train})
prob_mean = np.mean(prob_r)
# Early stop
if e > 200 and np.abs(prob_mean - 0.5) <= 0.01 and np.abs(
prob_trn_mean -
0.5) <= 0.01 and np.abs(prob_f_mean - 0.5) <= 0.01:
if np.abs(e - pre_epoch) <= 2 and count == 3:
stop = True
show_result(train_hist, e, self.num)
show_result2(acc_hist, e, self.num)
model_name = './model_adan/model' + str(
e) + '.ckpt'
self.saver.save(self.sess, model_name)
elif np.abs(e - pre_epoch) <= 2:
pre_epoch = e
count = count + 1
else:
pre_epoch = e
if e == self.epoch - 1:
show_result(train_hist, e, self.num)
show_result2(acc_hist, e, self.num)
model_name = './model_adan/model_loso' + str(
self.num) + '_final.ckpt'
self.saver.save(self.sess, model_name)
print("Starting Conv_MLP training")
history, test_predictions, test_real, MSE = model.train_series(
serie[0:n],
serie_test[0:test_size],
epochs=epochs,
bsize=bsize,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
"""
Pure LSTM
"""
if model_choice == "LSTM":
print("Initializing LSTM object")
model = noHW_LSTM(inp_window=in_window, out_window=out_window)
print("Starting LSTM training")
history, test_predictions, test_real, MSE = model.fit_NN(
serie[0:n],
serie_test[0:test_size],
epochs=epochs,
bsize=bsize,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
show_result(test_real, test_predictions, full=False)
def train_wadan(self):
self.build_wadan()
# Trainable variables
T_vars = tf.trainable_variables()
self.D_vars = [
var for var in T_vars if var.name.startswith('discriminator')
]
self.C_vars = [
var for var in T_vars if var.name.startswith('classifier')
]
self.G_vars = [
var for var in T_vars if var.name.startswith('generator')
]
self.E_vars = [var for var in T_vars if var.name.startswith('encoder')]
self.R_vars = [var for var in T_vars if var.name.startswith('decoder')]
# Optimizer
with tf.control_dependencies(
tf.get_collection_ref(tf.GraphKeys.UPDATE_OPS)):
D_optimizer = tf.train.AdamOptimizer(self.lr_D,
beta1=0.5,
epsilon=1e-5).minimize(
self.D_loss,
var_list=self.D_vars)
C_optimizer = tf.train.AdamOptimizer(self.lr_C,
beta1=0.5,
epsilon=1e-5).minimize(
self.C_loss,
var_list=self.C_vars)
G_optimizer = tf.train.AdamOptimizer(self.lr_G,
beta1=0.5,
epsilon=1e-5).minimize(
self.G_loss,
var_list=self.G_vars)
E_optimizer = tf.train.AdamOptimizer(self.lr_E,
beta1=0.5,
epsilon=1e-5).minimize(
self.E_loss,
var_list=self.E_vars)
R_optimizer = tf.train.AdamOptimizer(self.lr_R,
beta1=0.5,
epsilon=1e-5).minimize(
self.R_loss,
var_list=self.R_vars)
tf.global_variables_initializer().run()
train_op = tf.group(R_optimizer, E_optimizer)
train_hist = {
'D_losses': [],
'C_losses': [],
'G_losses': [],
'R_losses': []
}
with tqdm(total=self.epoch) as pbar:
for e in range(self.epoch):
# start = time.clock()
pbar.update(1)
index = np.arange(len(self.x_train))
np.random.shuffle(index)
x_train = self.x_train[index]
y_train_ohe = self.y_train_ohe[index]
for iter in range(x_train.shape[0] // self.batch):
# start = time.clock()
x_ = x_train[iter * self.batch:(1 + iter) * self.batch]
y_ = y_train_ohe[iter * self.batch:(1 + iter) * self.batch]
z_ = np.random.normal(0, 1, (self.batch, self.zdim))
self.sess.run(C_optimizer, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_c = self.sess.run(self.C_loss, {
self.x: x_,
self.y: y_,
self.z: z_
})
for d in range(self.d_times):
self.sess.run(D_optimizer, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_d = self.sess.run(self.D_loss, {
self.x: x_,
self.y: y_,
self.z: z_
})
for e_t in range(self.e_times):
self.sess.run(train_op, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_r = self.sess.run(self.R_loss, {
self.x: x_,
self.y: y_,
self.z: z_
})
self.sess.run(G_optimizer, {
self.x: x_,
self.y: y_,
self.z: z_
})
loss_g = self.sess.run(self.G_loss, {
self.x: x_,
self.y: y_,
self.z: z_
})
# elapse = (time.clock()-start)
# print('Time used:', elapse)
train_hist['D_losses'].append(loss_d)
train_hist['C_losses'].append(loss_c)
train_hist['G_losses'].append(loss_g)
train_hist['R_losses'].append(loss_r)
if e == self.epoch - 1:
show_result(train_hist, e, self.num)
model_name = './model_wadan/model_loso' + str(
self.num) + '_final.ckpt'
self.saver.save(self.sess, model_name)
X_train, Y_train = generate_linear(n=100)
X_test, Y_test = generate_linear(n=100)
elif args.dataset == 'xor':
X_train, Y_train = generate_XOR_easy()
X_test, Y_test = generate_XOR_easy()
else:
raise RuntimeError('Dataset Not Found')
net = Net()
if args.criterion == 'mse':
criterion = nn.MSE()
elif args.criterion == 'crossentropy':
criterion = nn.CrossEntropy()
else:
raise RuntimeError('Criterion Not Found')
if args.optimizer == 'sgd':
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum)
elif args.optimizer == 'adagrad':
optimizer = optim.Adagrad(net.parameters(), lr=args.lr)
else:
raise RuntimeError('Optimizer Not Found')
model = Model(net, criterion, optimizer)
train_history = model.train(X_train, Y_train, epochs=args.epochs)
test_history = model.test(X_test, Y_test)
show_history(train_history)
show_result(X_test, Y_test, test_history['predict'])
history, test_predictions, test_real, MSE = model.train_series(
serie_train,
serie_test,
epochs=epochs,
bsize=bsize,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
print("=============Ending Conv_MLP without HW============")
"""
Pure LSTM
"""
if model_choice == "LSTM":
print("Initializing LSTM object")
model = noHW_LSTM(inp_window=in_window, out_window=out_window)
print("Starting LSTM training")
history, test_predictions, test_real, MSE = model.fit_NN(
serie_train,
serie_test,
epochs=5,
bsize=32,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
show_result(test_real, test_predictions)
if 'cls' in result_name:
cls_scores.append(caffe_result[result_name])
else:
bbox_preds.append(caffe_result[result_name])
get_bboxes_caffe = Get_Bboxes_Caffe(
anchor_generator['strides'],
anchor_generator['ratios'],
octave_base_scale=anchor_generator['octave_base_scale'],
scales_per_octave=anchor_generator['scales_per_octave'])
# get bboxes from model
bbox_list = get_bboxes_caffe.get_bboxes(cls_scores,
bbox_preds,
img_meta,
test_cfg,
rescale=True)
bbox_results = [
bbox2result(det_bboxes, det_labels, 1)
for det_bboxes, det_labels in bbox_list
]
out_file = os.path.join(args.show_dir, img_meta['ori_filename'])
show_result(raw_img,
bbox_results[0],
show=True,
out_file=out_file,
score_thr=0.3)
# import ipdb; ipdb.set_trace()
A = utils.create_affinity_matrix(X_norm)
Q = utils.create_constraint_matrix(z)
D = np.diag(np.sum(A, axis=1))
vol = np.sum(A)
D_norm = np.linalg.inv(np.sqrt(D))
L_norm = np.eye(*A.shape) - D_norm.dot(A.dot(D_norm))
Q_norm = D_norm.dot(Q.dot(D_norm))
# alpha < K-th eigenval of Q_norm
alpha = 0.6 * sp.linalg.svdvals(Q_norm)[K]
Q1 = Q_norm - alpha * np.eye(*Q_norm.shape)
val, vec = sp.linalg.eig(L_norm, Q1)
vec = vec[:,val >= 0]
vec_norm = (vec / np.linalg.norm(vec, axis=0)) * np.sqrt(vol)
costs = np.multiply(vec_norm.T.dot(L_norm), vec_norm.T).sum(axis=1)
ids = np.where(costs > 1e-10)[0]
min_idx = np.argsort(costs[ids])[0:K]
min_v = vec_norm[:,ids[min_idx]]
u = D_norm.dot(min_v)
model = KMeans(n_clusters=K).fit(u)
labels = model.labels_
utils.show_result(X_norm, labels)
for j in range(3):
if game_state.board_state[i,j] == 1:
utils.show_piece(screen, gs.black_piece, (i,j))
elif game_state.board_state[i,j] == -1:
utils.show_piece(screen, gs.white_piece, (i,j))
index1, index2 = 0, 0 # 绘制的是第几个形状
for i in range(9):
if game_state.player1.collected_flag[i,0] == 1:
shape = game_state.player1.collected_shape_dict[i]
index1 += 1
used_flag = game_state.player1.collected_flag[i, 1]
utils.show_collected_shape(screen, player = 1, shape = shape, \
index = index1, used_flag=used_flag)
# if game_state.player1.collected_flag[i,1] == 1:
# utils.show_used_symbol()
if game_state.player2.collected_flag[i,0] == 1:
shape = game_state.player2.collected_shape_dict[i]
index2 += 1
used_flag = game_state.player2.collected_flag[i, 1]
utils.show_collected_shape(screen, player = 2, shape = shape, \
index = index2, used_flag=used_flag)
if game_state.convert_shape_selected != -1:
area_index = game_state.shape_area_selected_index
# print('area_index: ', area_index)
utils.show_selected_shape(screen, player_id, area_index)
utils.show_result(screen, result, player_id)
pygame.display.update()
def main(rank):
#Seed - Added for TPU purposes
torch.manual_seed(1)
#Create log folder
root = 'result_fg/'
model = 'coco_model_'
result_folder_name = 'images_' + FLAGS['log_dir']
model_folder_name = 'models_' + FLAGS['log_dir']
if not os.path.isdir(root):
os.mkdir(root)
if not os.path.isdir(root + result_folder_name):
os.mkdir(root + result_folder_name)
if not os.path.isdir(root + model_folder_name):
os.mkdir(root + model_folder_name)
#Save the script
copyfile(os.path.basename(__file__), root + result_folder_name + '/' + os.path.basename(__file__))
#Define transformation for dataset images - e.g scaling
transform = transforms.Compose(
[
transforms.Scale((FLAGS['img_size'],FLAGS['img_size'])),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
)
#Load dataset
category_names = FLAGS['category_names'].split(',')
#Serial Executor - This is needed to spread inside TPU for memory purposes
SERIAL_EXEC = xmp.MpSerialExecutor()
#Define Dataset
dataset = SERIAL_EXEC.run(
lambda: CocoData(
root = FLAGS['train_imgs_path'],
annFile = FLAGS['train_annotation_path'],
category_names = category_names,
transform=transform,
final_img_size=FLAGS['img_size']
)
)
#Discard images contain very small instances
dataset.discard_small(min_area=0.03, max_area=1)
#Define data sampler - Added for TPU purposes
train_sampler = DistributedSampler(
dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
#Define data loader
train_loader = DataLoader( #Modified for TPU purposes
dataset,
batch_size=FLAGS['batch_size'],
sampler=train_sampler,
num_workers=FLAGS['num_workers']
# shuffle=True
)
#Define device - Added for TPU purposes
device = xm.xla_device(devkind='TPU')
#For evaluation define fixed masks and noises
data_iter = iter(train_loader)
sample_batched = data_iter.next()
x_fixed = sample_batched['image'][0:FLAGS['num_test_img']]
x_fixed = Variable(x_fixed.to(device))
y_fixed = sample_batched['single_fg_mask'][0:FLAGS['num_test_img']]
y_fixed = Variable(y_fixed.to(device))
z_fixed = torch.randn((FLAGS['num_test_img'],FLAGS['noise_size']))
z_fixed = Variable(z_fixed.to(device))
#Define networks
generator = Generator_FG(
z_dim=FLAGS['noise_size'],
label_channel=len(category_names),
num_res_blocks=FLAGS['num_res_blocks']
)
discriminator_glob = Discriminator(
channels=3+len(category_names)
)
discriminator_instance = Discriminator(
channels=3+len(category_names),
input_size=FLAGS['local_patch_size']
)
WRAPPED_GENERATOR = xmp.MpModelWrapper(generator) #Added for TPU purposes
WRAPPED_DISCRIMINATOR_GLOB = xmp.MpModelWrapper(discriminator) #Added for TPU purposes
WRAPPED_DISCRIMINATOR_INSTANCE = xmp.MpModelWrapper(discriminator) #Added for TPU purposes
G_fg = WRAPPED_GENERATOR.to(device) #Modified for TPU purposes
D_glob = WRAPPED_DISCRIMINATOR.to(device) #Modified for TPU purposes
D_instance = WRAPPED_DISCRIMINATOR.to(device) #Modified for TPU purposes
#Load parameters from pre-trained models
if FLAGS['pre_trained_model_path'] != None and FLAGS['pre_trained_model_epoch'] != None:
try:
G_fg.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'G_fg_epoch_' + FLAGS['pre_trained_model_epoch']))
D_glob.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'D_glob_epoch_' + FLAGS['pre_trained_model_epoch']))
D_instance.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'D_local_epoch_' + FLAGS['pre_trained_model_epoch']))
xm.master_print('Parameters are loaded!')
except:
xm.master_print('Error: Pre-trained parameters are not loaded!')
pass
#Define interpolation operation
up_instance = nn.Upsample(
size=(FLAGS['local_patch_size'],FLAGS['local_patch_size']),
mode='bilinear'
)
#Define pooling operation for the case that image size and local patch size are mismatched
pooling_instance = nn.Sequential()
if FLAGS['local_patch_size']!=FLAGS['img_size']:
pooling_instance.add_module(
'0',
nn.AvgPool2d(int(FLAGS['img_size']/FLAGS['local_patch_size']))
)
#Define training loss function - binary cross entropy
BCE_loss = nn.BCELoss()
#Define feature matching loss
criterionVGG = VGGLoss()
criterionVGG = criterionVGG.to(device) #Modified for TPU Purposes
#Define optimizer
G_local_optimizer = optim.Adam(
G_fg.parameters(),
lr=FLAGS['lr'],
betas=(0.0, 0.9)
)
D_local_optimizer = optim.Adam(
list(filter(lambda p: p.requires_grad, D_glob.parameters())) + list(filter(lambda p: p.requires_grad, D_instance.parameters())),
lr=FLAGS['lr'],
betas=(0.0,0.9)
)
#Deine learning rate scheduler
scheduler_G = lr_scheduler.StepLR(
G_local_optimizer,
step_size=FLAGS['optim_step_size'],
gamma=FLAGS['optim_gamma']
)
scheduler_D = lr_scheduler.StepLR(
D_local_optimizer,
step_size=FLAGS['optim_step_size'],
gamma=FLAGS['optim_gamma']
)
#----------------------------TRAIN-----------------------------------------
xm.master_print('training start!')
tracker = xm.RateTracker() #Added for TPU reasons
start_time = time.time()
for epoch in range(FLAGS['train_epoch']):
epoch_start_time = time.time()
para_loader = pl.ParallelLoader(train_loader, [device]) #Added for TPU purposes
loader = para_loader.per_device_loader(device) #Added for TPU purposes
D_local_losses = []
G_local_losses = []
y_real_ = torch.ones(FLAGS['batch_size'])
y_fake_ = torch.zeros(FLAGS['batch_size'])
y_real_ = Variable(y_real_.to(device)) #Modified for TPU purposes
y_fake_ = Variable(y_fake_.to(device)) #Modified for TPU purposes
data_iter = iter(loader)
num_iter = 0
while num_iter < len(loader): #Modified for TPU purposes
j=0
while j < FLAGS['critic_iter'] and num_iter < len(loader):
j += 1
sample_batched = data_iter.next()
num_iter += 1
x_ = sample_batched['image']
x_ = Variable(x_.to(device)) #Modified for TPU purposes
y_ = sample_batched['single_fg_mask']
y_ = Variable(y_.to(device)) #Modified for TPU purposes
fg_mask = sample_batched['seg_mask']
fg_mask = Variable(fg_mask.to(device)) #Modified for TPU purposes
y_instances = sample_batched['mask_instance']
bbox = sample_batched['bbox']
mini_batch = x_.size()[0]
if mini_batch != FLAGS['batch_size']:
break
#Update discriminators - D
#Real examples
D_glob.zero_grad()
D_instance.zero_grad()
y_reduced = torch.sum(y_,1).clamp(0,1).view(y_.size(0),1,FLAGS['img_size'],FLAGS['img_size'])
x_d = torch.cat([x_,fg_mask],1)
x_instances = torch.zeros((FLAGS['batch_size'],3,FLAGS['local_patch_size'],FLAGS['local_patch_size']))
x_instances = Variable(x_instances.to(device))
y_instances = Variable(y_instances.to(device))
y_instances = pooling_instance(y_instances)
G_instances = torch.zeros((FLAGS['batch_size'],3,FLAGS['local_patch_size'],FLAGS['local_patch_size']))
G_instances = Variable(G_instances.to(device))
#Obtain instances
for t in range(x_d.size()[0]):
x_instance = x_[t,0:3,bbox[0][t]:bbox[1][t],bbox[2][t]:bbox[3][t]]
x_instance = x_instance.contiguous().view(1,x_instance.size()[0],x_instance.size()[1],x_instance.size()[2])
x_instances[t] = up_instance(x_instance)
D_result_instance = D_instance(torch.cat([x_instances,y_instances],1)).squeeze()
D_result = D_glob(x_d).squeeze()
D_real_loss = BCE_loss(D_result, y_real_) + BCE_loss(D_result_instance, y_real_)
D_real_loss.backward()
#Fake examples
z_ = torch.randn((mini_batch,FLAGS['noise_size']))
z_ = Variable(z_.to(device))
#Generate fake images
G_fg_result = G_fg(z_,y_, torch.mul(x_,(1-y_reduced)))
G_result_d = torch.cat([G_fg_result,fg_mask],1)
#Obtain fake instances
for t in range(x_d.size()[0]):
G_instance = G_result_d[t,0:3,bbox[0][t]:bbox[1][t],bbox[2][t]:bbox[3][t]]
G_instance = G_instance.contiguous().view(1,G_instance.size()[0],G_instance.size()[1],G_instance.size()[2])
G_instances[t] = up_instance(G_instance)
D_result_instance = D_instance(torch.cat([G_instances,y_instances],1).detach()).squeeze()
D_result = D_glob(G_result_d.detach()).squeeze()
D_fake_loss = BCE_loss(D_result, y_fake_) + BCE_loss(D_result_instance, y_fake_)
D_fake_loss.backward()
xm.optimizer_step(D_local_optimizer) #Modified for TPU purposes
D_train_loss = D_real_loss + D_fake_loss
D_local_losses.append(D_train_loss.data[0])
if mini_batch != FLAGS['batch_size']:
break
#Update generator G
G_fg.zero_grad()
D_result = D_glob(G_result_d).squeeze()
D_result_instance = D_instance(torch.cat([G_instances,y_instances],1)).squeeze()
G_train_loss = (1-FLAGS['trade_off_G'])*BCE_loss(D_result, y_real_) + FLAGS['trade_off_G']*BCE_loss(D_result_instance, y_real_)
#Feature matching loss between generated image and corresponding ground truth
FM_loss = criterionVGG(G_fg_result, x_)
#Reconstruction loss
Recon_loss = mse_loss(torch.mul(x_,(1-y_reduced) ), torch.mul(G_fg_result,(1-y_reduced)) )
total_loss = G_train_loss + FLAGS['lambda_FM']*FM_loss + FLAGS['lambda_recon']*Recon_loss
total_loss.backward()
xm.optimizer_step(G_local_optimizer)
G_local_losses.append(G_train_loss.data[0])
xm.master_print('loss_d: %.3f, loss_g: %.3f' % (D_train_loss.data[0],G_train_loss.data[0]))
if (num_iter % 100) == 0:
xm.master_print('%d - %d complete!' % ((epoch+1), num_iter))
xm.master_print(result_folder_name)
#Modified location of the scheduler step to avoid warning
scheduler_G.step()
scheduler_D.step()
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
xm.master_print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), FLAGS['train_epoch'], per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)), torch.mean(torch.FloatTensor(G_local_losses))))
#Save images
G_fg.eval()
if epoch == 0:
show_result(
(epoch+1),
x_fixed,
save=True,
path=root + result_folder_name+ '/' + model + str(epoch + 1 ) + '_gt.png'
)
for t in range(y_fixed.size()[1]):
show_result(
(epoch+1),
y_fixed[:,t:t+1,:,:],
save=True,
path=root + result_folder_name+ '/' + model + str(epoch + 1 ) +'_'+ str(t) +'_masked.png'
)
show_result(
(epoch+1),
G_fg(
z_fixed,
y_fixed,
torch.mul(
x_fixed,
(1-torch.sum(y_fixed,1).view(y_fixed.size(0),1,FLAGS['img_size'],FLAGS['img_size']))
)
),
save=True,
path=root + result_folder_name+ '/' + model + str(epoch + 1 ) + '_fg.png'
)
G_fg.train()
#Save model params
if FLAGS['save_models'] and (epoch>11 and epoch % 10 == 0 ):
xser.save(
G_fg.state_dict(),
root + model_folder_name + '/' + model + 'G_fg_epoch_'+str(epoch)+'.pth'
master_only=True
)
xser.save(
D_glob.state_dict(),
root + model_folder_name + '/' + model + 'D_glob_epoch_'+str(epoch)+'.pth'
master_only=True
)
xser.save(
D_instance.state_dict(),
root + model_folder_name + '/' + model + 'D_local_epoch_'+str(epoch)+'.pth'
master_only=True
)
end_time = time.time()
total_ptime = end_time - start_time
xm.master_print("Training finish!... save training results")
xm.master_print('Training time: ' + str(total_ptime))
import numpy as np
import utils
if __name__ == '__main__':
X_norm, _ = utils.create_data()
A = utils.create_affinity_matrix(X_norm)
D = np.diag(np.sum(A, axis=1))
L = D - A
eigvals, eigvecs = np.linalg.eig(L)
n_dim = eigvecs.shape[0]
p = np.zeros(n_dim)
p[eigvecs[:, 1] > 0] = 1.0
utils.show_result(X_norm, p)
if (num_iter % 100) == 0:
print('%d - %d complete!' % ((epoch+1), num_iter))
print(result_folder_name)
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
epoch_biassed = epoch + epoch_bias
print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)),
torch.mean(torch.FloatTensor(G_local_losses))))
fixed_p1 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 ) + '.png'
fixed_p3 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 ) + '_gt.png'
#Evaluate
if epoch == 0:
show_result((epoch_biassed+1),x_fixed ,save=True, path=fixed_p3)
for t in range(y_fixed.size()[1]):
fixed_p2 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 + t ) + '_gt_y.png'
show_result((epoch_biassed+1), y_fixed[:,t:t+1,:,:] ,save=True, path=fixed_p2)
show_result((epoch_biassed+1),G_local(z_fixed, y_fixed) ,save=True, path=fixed_p1)
#Save model params
if save_models and (epoch_biassed>21 and epoch_biassed % 10 == 0 ):
torch.save(G_local.state_dict(), root +model_folder_name+ '/' + model + 'G_glob_epoch_'+str(epoch_biassed)+'.pth')
torch.save(D_local.state_dict(), root + model_folder_name +'/'+ model + 'D_glob_epoch_'+str(epoch_biassed)+'.pth')
torch.save(G_local.state_dict(), root +model_folder_name+ '/' + model + 'G_glob_epoch_'+str(epoch_biassed)+'.pth')
torch.save(D_local.state_dict(), root + model_folder_name +'/'+ model + 'D_glob_epoch_'+str(epoch_biassed)+'.pth')
end_time = time.time()
fixed_p = root + 'Results/' + model + str(epoch + 1)
f0 = open('i0.txt', 'a')
f1 = open('i1.txt', 'a')
f2 = open('i2.txt', 'a')
f3 = open('i3.txt', 'a')
f4 = open('i4.txt', 'a')
f5 = open('i5.txt', 'a')
f6 = open('i6.txt', 'a')
f7 = open('i7.txt', 'a')
f8 = open('i8.txt', 'a')
f9 = open('i9.txt', 'a')
print('Generating Results')
print('0s')
r0 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y0s, save=True, path=fixed_p + '0.png')
print('1s')
r1 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y1s, save=True, path=fixed_p + '1.png')
print('2s')
r2 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y2s, save=True, path=fixed_p + '2.png')
print('3s')
r3 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y3s, save=True, path=fixed_p + '3.png')
print('4s')
r4 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y4s, save=True, path=fixed_p + '4.png')
print('5s')
r5 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y5s, save=True, path=fixed_p + '5.png')
print('6s')
r6 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y6s, save=True, path=fixed_p + '6.png')
print('7s')
r7 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y7s, save=True, path=fixed_p + '7.png')
print('8s')
pr=1,
compute_mtf=False)
#%% Call NN
print("Initializing Conv_MLP object")
model = Conv_MLP(img_size=img_size, N_Channel=2,
test_size=test_size) #if compute_mtf=False -> set N_Channel=2
print("Starting Conv_MLP training")
history, y_pred, y_true, MSE = model.train_HW(HW,
epochs=5,
bsize=32,
p_filepath=preds_filepath,
callbacks=False)
print("Finished training")
print(MSE)
print("Showing results")
show_result(y_pred, y_true, title="Conv-MLP with HW", full=False)
print("=============TESTING RAW TS============")
print("Initializing Conv_MLP object")
model = Conv_MLP(img_size=img_size, N_Channel=3, raw=True,
test_size=test_size) #if compute_mtf=False -> set N_Channel=2
print("Starting Conv_MLP training")
history, y_pred, y_true, MSE = model.train_series(serie[0:n],
serie_test[0:test_size],
epochs=5,
bsize=32,
p_filepath=preds_filepath,
callbacks=False)
print("Finished training")
print(MSE)
print("Showing results")
G_train_loss = BCE_loss(D_result, y_real_)
G_train_loss.backward()
G_optimizer.step()
G_losses.append(G_train_loss.item())
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' %
((epoch + 1), train_epoch, per_epoch_ptime,
torch.mean(torch.FloatTensor(D_losses)),
torch.mean(torch.FloatTensor(G_losses))))
fixed_p = root + 'Fixed_results/' + model + str(epoch + 1) + '.png'
show_result(G, (epoch + 1), save=True, path=fixed_p)
train_hist['D_losses'].append(torch.mean(torch.FloatTensor(D_losses)))
train_hist['G_losses'].append(torch.mean(torch.FloatTensor(G_losses)))
train_hist['per_epoch_ptimes'].append(per_epoch_ptime)
end_time = time.time()
total_ptime = end_time - start_time
train_hist['total_ptime'].append(total_ptime)
print("Avg one epoch ptime: %.2f, total %d epochs ptime: %.2f" %
(torch.mean(torch.FloatTensor(
train_hist['per_epoch_ptimes'])), train_epoch, total_ptime))
print("Training finish!... save training results")
torch.save(G.state_dict(), root + model + 'generator_param.pkl')
torch.save(D.state_dict(), root + model + 'discriminator_param.pkl')
with open(root + model + 'train_hist.pkl', 'wb') as f:
def train(epoch=10, batch_size=10, dataset_path=None, one_hot=False):
if one_hot:
loss_func = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=LR)
else:
loss_func = nn.BCELoss()
optimizer = optim.RMSprop(net.parameters(), lr=LR, alpha=0.9)
if dataset_path is not None and DEVICE != "kaggle":
if sys.platform.startswith('win'):
TRAIN_PATH = dataset_path + '\\train'
VALID_PATH = dataset_path + '\\test'
elif sys.platform.startswith('linux'):
TRAIN_PATH = dataset_path + '/train'
VALID_PATH = dataset_path + '/test'
elif DEVICE == "kaggle":
TRAIN_PATH = '../input/dogs-vs-cats/train/train'
VALID_PATH = '../input/dogs-vs-cats/test/test'
DATASET_PATH = '../input/dogs-vs-cats'
# print(TRAIN_PATH)
else:
raise ValueError("Dataset can not be None")
cat_dog_dataset = dataloader.CatVsDogDataset(TRAIN_PATH, mode="train", one_hot=one_hot)
train_loader = Data(cat_dog_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
# train_loader = Data(cat_dog_dataset, batch_size=batch_size, shuffle=True)
cat_dog_dataset_test = dataloader.CatVsDogDataset(TRAIN_PATH, mode="test", one_hot=one_hot)
test_loader = Data(cat_dog_dataset_test, batch_size=batch_size, shuffle=True, num_workers=0)
# test_loader = Data(cat_dog_dataset_test, batch_size=batch_size, shuffle=True)
cat_dog_dataset_valid = dataloader.CatVsDogValid(VALID_PATH)
valid_loader = Data(cat_dog_dataset_valid, batch_size=batch_size, shuffle=True, num_workers=0)
start_time = time.time()
print("Net: VGG%s, Total epoch: %d, Batch_size: %d, LR: %f, Device: %s"%(NET, epoch, batch_size, LR, DEVICE))
time.sleep(0.1)
for epoch in range(epoch):
print("\nEpoch: %d"%(epoch + 1))
time.sleep(0.1)
train_loss_sum, train_acc_sum, n = 0.0, 0.0, 0
for batch, (x, y) in enumerate(tqdm(train_loader)):
y_hat = net(x)
# if batch_size > 1, use sum() to calculate per batch loss
if one_hot:
loss = loss_func(y_hat, y).sum()
else:
loss = loss_func(y_hat, y)
# print("\t\tBatch #{0}/{1}".format(batch+1, len(train_loader)) + "Loss = %.6f"%float(loss))
if optimizer is not None:
optimizer.zero_grad()
elif params is not None and params[0].grad is not None:
for param in params:
param.grad.data.zero_()
loss.backward()
if optimizer is None:
optimizer = optim.SGD(net.parameters(), lr=globals(LR))
optimizer.step()
else:
optimizer.step()
# convert tensor data type to float data type
# train_loss_sum += loss.item()
# train_acc_sum += (y_hat == y).sum().item()
if one_hot:
train_loss_sum += loss_func(y_hat, y).sum().item()
train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
else:
train_loss_sum += loss.item()
train_acc_sum += (torch.round(y_hat) == y).float().mean().item()
# print(train_loss_sum)
# print(train_acc_sum)
# train_loss_sum += float(loss_func(y_hat, y))
print('Epoch: {epoch}, Loss:{loss}, Accuracy:{accuracy}, Average_loss:{average_loss}, Average_accuracy:{average_accuracy}%'.\
format(epoch=epoch+1, loss=float('%.6f' % train_loss_sum), accuracy=float('%.6f' % train_acc_sum), \
average_loss=float('%.6f' %(train_loss_sum/(batch+1))), \
average_accuracy=float('%.6f' % (train_acc_sum/(batch+1)*100))))
if (epoch+1) % RECORD_EPOCH == 0:
test_acc = evaluate_accuracy(test_loader, net)
print('Epoch: {epoch}, Valid accuracy: {valid:.6f}%'.format(epoch=epoch+1, valid=test_acc*100))
end_time = time.time()
h, m, s = second2clock(end_time - start_time)
print("Total trainning time: " + "%d hours %02d mins %.2f seconds" % (h, m, s))
start_time = time.time()
test_acc = evaluate_accuracy(test_loader, net)
end_time = time.time()
h, m, s = second2clock(end_time - start_time)
print("Test accuracy: {:.6f}".format(test_acc*100) + "%, Eval time: " + "%d hours %02d mins %.2f seconds" % (h, m, s))
test_img, test_label = iter(test_loader).__next__()
show_result(net, test_img[0:SHOW_PIC_NUM], test_label[0:SHOW_PIC_NUM], rgb=RGB)
if SHOW_VALID_PIC:
valid_img = iter(valid_loader).__next__()
show_valid(net, valid_img[0:SHOW_PIC_NUM], rgb=RGB)
if CSV:
valid_loader = Data(cat_dog_dataset_valid, batch_size=1, shuffle=False, num_workers=0)
creat_csv(net, valid_loader)
test_size=test_size) #if compute_mtf=False -> set N_Channel=2
print("Starting Conv_MLP training")
history, y_pred, y_true, MSE = model.train_series(
serie[0:n],
serie_test[0:test_size],
epochs=epochs,
bsize=bsize,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
"""
Pure LSTM
"""
if model_choice == "LSTM":
print("Initializing LSTM object")
model = noHW_LSTM(inp_window=in_window, out_window=out_window)
print("Starting LSTM training")
history, y_pred, y_true, MSE = model.fit_NN(serie[0:n],
serie_test[0:test_size],
epochs=epochs,
bsize=bsize,
p_filepath=preds_filepath,
l_filepath=l_filepath,
w_filepath=w_filepath,
h=h,
callbacks=callbacks)
show_result(y_true, y_pred, full=False)
def train(epochs, batch_size, lr, loss_fn, data_dir):
param_cuda = torch.cuda.is_available()
#check training starting time
start_time = time.time()
G, D, G_opt, D_opt = initialize(mean=0.0, std=0.02, lr=lr)
#train_hist dict will store the losses of every epoch
train_hist = {}
train_hist['D_model_mean_losses'] = []
train_hist['G_model_mean_losses'] = []
train_hist['per_epoch_ptimes'] = []
train_hist['total_ptime'] = []
#folder for saving the images
if not os.path.isdir('GAN_results'):
os.mkdir('GAN_results')
for epoch in range(epochs):
# Run one epoch
logging.info("Epoch {}/{}".format(epoch + 1, epochs))
epoch_start_time = time.time()
#One epoch of trainning over all the dataset
train_hist = epoch_train(G=G, D=D, G_opt=G_opt, D_opt=D_opt, batch_size=batch_size, lr=lr, loss_fn=loss_fn, data_dir=data_dir, train_hist=train_hist)
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
#print progress information for every epoch:
print("iteration number "+str(epoch))
print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), epochs, per_epoch_ptime, torch.mean(torch.FloatTensor(train_hist['D_model_mean_losses'])), torch.mean(torch.FloatTensor(train_hist['G_model_mean_losses']))))
#Save weights
utils.save_checkpoint({'epoch': epoch + 1,
'D_model_state_dict': D.state_dict(),
'G_model_state_dict': G.state_dict(),
'D_optim_dict': D_opt.state_dict(),
'G_optim_dict': G_opt.state_dict()},
is_best=False,
checkpoint = 'GAN_results/')
#Generate and save pictures for every epoch:
p = 'GAN_results/result_epoch_' + str(epoch + 1) + '.png'
utils.show_result(param_cuda, G, (epoch+1), p, save=True)
#add epoch time to the training history
train_hist['per_epoch_ptimes'].append(per_epoch_ptime)
end_time = time.time()
total_ptime = end_time - start_time
train_hist['total_ptime'].append(total_ptime)
print("Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f" % (torch.mean(torch.FloatTensor(train_hist['per_epoch_ptimes'])), epochs, total_ptime))
print("Training finish!... save learned parameters")
#plot training history
utils.show_train_hist(train_hist, save=True, path= 'GAN_results/_train_hist.png')
seed=None),
bias_initializer=Constant(value=0.1))) # 最终输出15个2维坐标
model.summary()
model.compile(optimizer='sgd', loss='mean_squared_error')
return model
model = bulid_model()
early_stopping = EarlyStopping(
monitor='val_loss',
patience=20, # patience: 没有进步的训练轮数，在这之后训练就会被停止。
restore_best_weights=True
) #从具有监测数量的最佳值的时期恢复模型权重。如果为 False，则使用在训练的最后一步获得的模型权重。
model.fit(X_train,
y_train,
epochs=50,
batch_size=256,
validation_split=0.1,
callbacks=[early_stopping])
ID = ''
# 保存模型
model.save(ID + 'model.h5')
# 预测
pred_y = model.predict(X_test, verbose=1)
export(pred_y,
ID + '2017211444.csv') # use complete student id as the export filename
show_result(X_test[0].reshape(96, 96), pred_y[0]) #画图
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir',
type=str,
default='log',
help='Name of the log folder')
parser.add_argument('--save_models',
type=bool,
default=True,
help='Set True if you want to save trained models')
parser.add_argument('--pre_trained_model_path',
type=str,
default=None,
help='Pre-trained model path')
parser.add_argument('--pre_trained_model_epoch',
type=str,
default=None,
help='Pre-trained model epoch e.g 200')
parser.add_argument('--train_imgs_path',
type=str,
default='/mnt/sdb/data/COCO/train2017',
help='Path to training images')
parser.add_argument(
'--train_annotation_path',
type=str,
default='/mnt/sdb/data/COCO/annotations/instances_train2017.json',
help='Path to annotation file, .json file')
parser.add_argument('--category_names',
type=str,
default='giraffe,elephant,zebra,sheep,cow,bear',
help='List of categories in MS-COCO dataset')
parser.add_argument('--num_test_img',
type=int,
default=4,
help='Number of images saved during training')
parser.add_argument('--img_size',
type=int,
default=256,
help='Generated image size')
parser.add_argument(
'--local_patch_size',
type=int,
default=256,
help='Image size of instance images after interpolation')
parser.add_argument('--batch_size',
type=int,
default=4,
help='Mini-batch size')
parser.add_argument('--train_epoch',
type=int,
default=400,
help='Maximum training epoch')
parser.add_argument('--lr',
type=float,
default=0.0002,
help='Initial learning rate')
parser.add_argument('--optim_step_size',
type=int,
default=80,
help='Learning rate decay step size')
parser.add_argument('--optim_gamma',
type=float,
default=0.5,
help='Learning rate decay ratio')
parser.add_argument(
'--critic_iter',
type=int,
default=5,
help='Number of discriminator update against each generator update')
parser.add_argument('--noise_size',
type=int,
default=256,
help='Noise vector size')
parser.add_argument('--lambda_FM',
type=float,
default=1,
help='Trade-off param for feature matching loss')
parser.add_argument('--lambda_branch',
type=float,
default=100,
help='Trade-off param for reconstruction loss')
parser.add_argument(
'--num_res_blocks',
type=int,
default=2,
help='Number of residual block in generator shared part')
parser.add_argument('--num_res_blocks_fg',
type=int,
default=2,
help='Number of residual block in non-bg branch')
parser.add_argument('--num_res_blocks_bg',
type=int,
default=0,
help='Number of residual block in generator bg branch')
opt = parser.parse_args()
print(opt)
#Create log folder
root = 'result_bg/'
model = 'coco_model_'
result_folder_name = 'images_' + opt.log_dir
model_folder_name = 'models_' + opt.log_dir
if not os.path.isdir(root):
os.mkdir(root)
if not os.path.isdir(root + result_folder_name):
os.mkdir(root + result_folder_name)
if not os.path.isdir(root + model_folder_name):
os.mkdir(root + model_folder_name)
#Save the script
copyfile(os.path.basename(__file__),
root + result_folder_name + '/' + os.path.basename(__file__))
#Define transformation for dataset images - e.g scaling
transform = transforms.Compose([
transforms.Scale((opt.img_size, opt.img_size)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
#Load dataset
category_names = opt.category_names.split(',')
dataset = CocoData(root=opt.train_imgs_path,
annFile=opt.train_annotation_path,
category_names=category_names,
transform=transform,
final_img_size=opt.img_size)
#Discard images contain very small instances
dataset.discard_small(min_area=0.0, max_area=1)
#dataset.discard_bad_examples('bad_examples_list.txt')
#Define data loader
train_loader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True)
#For evaluation define fixed masks and noises
data_iter = iter(train_loader)
sample_batched = data_iter.next()
y_fixed = sample_batched['seg_mask'][0:opt.num_test_img]
y_fixed = Variable(y_fixed.cuda())
z_fixed = torch.randn((opt.num_test_img, opt.noise_size))
z_fixed = Variable(z_fixed.cuda())
#Define networks
G_bg = Generator_BG(z_dim=opt.noise_size,
label_channel=len(category_names),
num_res_blocks=opt.num_res_blocks,
num_res_blocks_fg=opt.num_res_blocks_fg,
num_res_blocks_bg=opt.num_res_blocks_bg)
D_glob = Discriminator(channels=3 + len(category_names),
input_size=opt.img_size)
G_bg.cuda()
D_glob.cuda()
#Load parameters from pre-trained models
if opt.pre_trained_model_path != None and opt.pre_trained_model_epoch != None:
try:
G_bg.load_state_dict(
torch.load(opt.pre_trained_model_path + 'G_bg_epoch_' +
opt.pre_trained_model_epoch))
D_glob.load_state_dict(
torch.load(opt.pre_trained_model_path + 'D_glob_epoch_' +
opt.pre_trained_model_epoch))
print('Parameters are loaded!')
except:
print('Error: Pre-trained parameters are not loaded!')
pass
#Define training loss function - binary cross entropy
BCE_loss = nn.BCELoss()
#Define feature matching loss
criterionVGG = VGGLoss()
criterionVGG = criterionVGG.cuda()
#Define optimizer
G_local_optimizer = optim.Adam(G_bg.parameters(),
lr=opt.lr,
betas=(0.0, 0.9))
D_local_optimizer = optim.Adam(filter(lambda p: p.requires_grad,
D_glob.parameters()),
lr=opt.lr,
betas=(0.0, 0.9))
#Deine learning rate scheduler
scheduler_G = lr_scheduler.StepLR(G_local_optimizer,
step_size=opt.optim_step_size,
gamma=opt.optim_gamma)
scheduler_D = lr_scheduler.StepLR(D_local_optimizer,
step_size=opt.optim_step_size,
gamma=opt.optim_gamma)
#----------------------------TRAIN---------------------------------------
print('training start!')
start_time = time.time()
for epoch in range(opt.train_epoch):
scheduler_G.step()
scheduler_D.step()
D_local_losses = []
G_local_losses = []
y_real_ = torch.ones(opt.batch_size)
y_fake_ = torch.zeros(opt.batch_size)
y_real_, y_fake_ = Variable(y_real_.cuda()), Variable(y_fake_.cuda())
epoch_start_time = time.time()
data_iter = iter(train_loader)
num_iter = 0
while num_iter < len(train_loader):
j = 0
while j < opt.critic_iter and num_iter < len(train_loader):
j += 1
sample_batched = data_iter.next()
num_iter += 1
x_ = sample_batched['image']
y_ = sample_batched['seg_mask']
y_reduced = torch.sum(y_, 1).view(y_.size(0), 1, y_.size(2),
y_.size(3))
y_reduced = torch.clamp(y_reduced, 0, 1)
y_reduced = Variable(y_reduced.cuda())
#Update discriminators - D
#Real examples
D_glob.zero_grad()
mini_batch = x_.size()[0]
if mini_batch != opt.batch_size:
y_real_ = torch.ones(mini_batch)
y_fake_ = torch.zeros(mini_batch)
y_real_, y_fake_ = Variable(y_real_.cuda()), Variable(
y_fake_.cuda())
x_, y_ = Variable(x_.cuda()), Variable(y_.cuda())
x_d = torch.cat([x_, y_], 1)
D_result = D_glob(x_d).squeeze()
D_real_loss = BCE_loss(D_result, y_real_)
D_real_loss.backward()
#Fake examples
z_ = torch.randn((mini_batch, opt.noise_size))
z_ = Variable(z_.cuda())
#Generate fake images
G_result, G_result_bg = G_bg(z_, y_)
G_result_d = torch.cat([G_result, y_], 1)
D_result = D_glob(G_result_d.detach()).squeeze()
D_fake_loss = BCE_loss(D_result, y_fake_)
D_fake_loss.backward()
D_local_optimizer.step()
D_train_loss = D_real_loss + D_fake_loss
D_local_losses.append(D_train_loss.item())
#Update generator G
G_bg.zero_grad()
D_result = D_glob(G_result_d).squeeze()
G_train_loss = BCE_loss(D_result, y_real_)
#Feature matching loss between generated image and corresponding ground truth
FM_loss = criterionVGG(G_result, x_)
#Branch-similar loss
branch_sim_loss = mse_loss(torch.mul(G_result, (1 - y_reduced)),
torch.mul(G_result_bg, (1 - y_reduced)))
total_loss = G_train_loss + opt.lambda_FM * FM_loss + opt.lambda_branch * branch_sim_loss
total_loss.backward()
G_local_optimizer.step()
G_local_losses.append(G_train_loss.item())
print('loss_d: %.3f, loss_g: %.3f' %
(D_train_loss.item(), G_train_loss.item()))
if (num_iter % 100) == 0:
print('%d - %d complete!' % ((epoch + 1), num_iter))
print(result_folder_name)
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' %
((epoch + 1), opt.train_epoch, per_epoch_ptime,
torch.mean(torch.FloatTensor(D_local_losses)),
torch.mean(torch.FloatTensor(G_local_losses))))
#Save images
G_bg.eval()
G_result, G_result_bg = G_bg(z_fixed, y_fixed)
G_bg.train()
if epoch % 10 == 0:
for t in range(y_fixed.size()[1]):
show_result((epoch + 1),
y_fixed[:, t:t + 1, :, :],
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '_masked.png')
show_result((epoch + 1),
G_result,
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '.png')
show_result((epoch + 1),
G_result_bg,
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '_bg.png')
#Save model params
if opt.save_models and (epoch > 21 and epoch % 10 == 0):
torch.save(
G_bg.state_dict(), root + model_folder_name + '/' + model +
'G_bg_epoch_' + str(epoch) + '.pth')
torch.save(
D_glob.state_dict(), root + model_folder_name + '/' + model +
'D_glob_epoch_' + str(epoch) + '.pth')
end_time = time.time()
total_ptime = end_time - start_time
print("Training finish!... save training results")
print('Training time: ' + str(total_ptime))
#%% Constants
inpt_window = 100
outp_window = 1
n = 30000
dt = 0.1
#%% Create Data
tsc1 = TSC_function(savevals=True)
tsc2 = TSC_function(savevals=True)
serie_train = tsc1.get_next_N_vals(n, function_example_ma, dt, sigma=2.5)
serie_test = tsc2.get_next_N_vals(n, function_example_ma, dt, sigma=2.5)
#You can replace this below with wherever you want the predictions csv file to be
preds_filepath = "predictions_test"
print("Initializing LSTM object")
model = noHW_LSTM(inp_window=inpt_window, out_window=outp_window)
print("Starting LSTM training")
history, y_pred, y_true, MSE = model.fit_NN(serie_train[0:n],
serie_test[0:n],
epochs=2,
bsize=64,
p_filepath=preds_filepath,
callbacks=False)
show_result(y_true, y_pred, full=False, title="LSTM without HW")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir',
type=str,
default='log',
help='Name of the log folder')
parser.add_argument('--save_models',
type=bool,
default=True,
help='Set True if you want to save trained models')
parser.add_argument('--pre_trained_model_path',
type=str,
default=None,
help='Pre-trained model path')
parser.add_argument('--pre_trained_model_epoch',
type=str,
default=None,
help='Pre-trained model epoch e.g 200')
parser.add_argument('--train_imgs_path',
type=str,
default='C:/Users/motur/coco/images/train2017',
help='Path to training images')
parser.add_argument(
'--train_annotation_path',
type=str,
default='C:/Users/motur/coco/annotations/instances_train2017.json',
help='Path to annotation file, .json file')
parser.add_argument('--category_names',
type=str,
default='giraffe,elephant,zebra,sheep,cow,bear',
help='List of categories in MS-COCO dataset')
parser.add_argument('--num_test_img',
type=int,
default=16,
help='Number of images saved during training')
parser.add_argument('--img_size',
type=int,
default=128,
help='Generated image size')
parser.add_argument(
'--local_patch_size',
type=int,
default=128,
help='Image size of instance images after interpolation')
parser.add_argument('--batch_size',
type=int,
default=16,
help='Mini-batch size')
parser.add_argument('--train_epoch',
type=int,
default=400,
help='Maximum training epoch')
parser.add_argument('--lr',
type=float,
default=0.0002,
help='Initial learning rate')
parser.add_argument('--optim_step_size',
type=int,
default=80,
help='Learning rate decay step size')
parser.add_argument('--optim_gamma',
type=float,
default=0.5,
help='Learning rate decay ratio')
parser.add_argument(
'--critic_iter',
type=int,
default=5,
help='Number of discriminator update against each generator update')
parser.add_argument('--noise_size',
type=int,
default=128,
help='Noise vector size')
parser.add_argument('--lambda_FM',
type=float,
default=1,
help='Trade-off param for feature matching loss')
parser.add_argument('--lambda_recon',
type=float,
default=0.00001,
help='Trade-off param for reconstruction loss')
parser.add_argument('--num_res_blocks',
type=int,
default=5,
help='Number of residual block in generator network')
parser.add_argument(
'--trade_off_G',
type=float,
default=0.1,
help=
'Trade-off parameter which controls gradient flow to generator from D_local and D_glob'
)
opt = parser.parse_args()
print(opt)
#Create log folder
root = 'result_fg/'
model = 'coco_model_'
result_folder_name = 'images_' + opt.log_dir
model_folder_name = 'models_' + opt.log_dir
if not os.path.isdir(root):
os.mkdir(root)
if not os.path.isdir(root + result_folder_name):
os.mkdir(root + result_folder_name)
if not os.path.isdir(root + model_folder_name):
os.mkdir(root + model_folder_name)
#Save the script
copyfile(os.path.basename(__file__),
root + result_folder_name + '/' + os.path.basename(__file__))
#Define transformation for dataset images - e.g scaling
transform = transforms.Compose([
transforms.Scale((opt.img_size, opt.img_size)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
#Load dataset
category_names = opt.category_names.split(',')
dataset = CocoData(root=opt.train_imgs_path,
annFile=opt.train_annotation_path,
category_names=category_names,
transform=transform,
final_img_size=opt.img_size)
#Discard images contain very small instances
dataset.discard_small(min_area=0.03, max_area=1)
#Define data loader
train_loader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True)
#For evaluation define fixed masks and noises
data_iter = iter(train_loader)
sample_batched = data_iter.next()
x_fixed = sample_batched['image'][0:opt.num_test_img]
x_fixed = Variable(x_fixed.cuda())
y_fixed = sample_batched['single_fg_mask'][0:opt.num_test_img]
y_fixed = Variable(y_fixed.cuda())
z_fixed = torch.randn((opt.num_test_img, opt.noise_size))
z_fixed = Variable(z_fixed.cuda())
#Define networks
G_fg = Generator_FG(z_dim=opt.noise_size,
label_channel=len(category_names),
num_res_blocks=opt.num_res_blocks)
D_glob = Discriminator(channels=3 + len(category_names))
D_instance = Discriminator(channels=3 + len(category_names),
input_size=opt.local_patch_size)
G_fg.cuda()
D_glob.cuda()
D_instance.cuda()
#Load parameters from pre-trained models
if opt.pre_trained_model_path != None and opt.pre_trained_model_epoch != None:
try:
G_fg.load_state_dict(
torch.load(opt.pre_trained_model_path + 'G_fg_epoch_' +
opt.pre_trained_model_epoch))
D_glob.load_state_dict(
torch.load(opt.pre_trained_model_path + 'D_glob_epoch_' +
opt.pre_trained_model_epoch))
D_instance.load_state_dict(
torch.load(opt.pre_trained_model_path + 'D_local_epoch_' +
opt.pre_trained_model_epoch))
print('Parameters are loaded!')
except:
print('Error: Pre-trained parameters are not loaded!')
pass
#Define interpolation operation
up_instance = nn.Upsample(size=(opt.local_patch_size,
opt.local_patch_size),
mode='bilinear')
#Define pooling operation for the case that image size and local patch size are mismatched
pooling_instance = nn.Sequential()
if opt.local_patch_size != opt.img_size:
pooling_instance.add_module(
'0', nn.AvgPool2d(int(opt.img_size / opt.local_patch_size)))
#Define training loss function - binary cross entropy
BCE_loss = nn.BCELoss()
#Define feature matching loss
criterionVGG = VGGLoss()
criterionVGG = criterionVGG.cuda()
#Define optimizer
G_local_optimizer = optim.Adam(G_fg.parameters(),
lr=opt.lr,
betas=(0.0, 0.9))
D_local_optimizer = optim.Adam(
list(filter(lambda p: p.requires_grad, D_glob.parameters())) +
list(filter(lambda p: p.requires_grad, D_instance.parameters())),
lr=opt.lr,
betas=(0.0, 0.9))
#Deine learning rate scheduler
scheduler_G = lr_scheduler.StepLR(G_local_optimizer,
step_size=opt.optim_step_size,
gamma=opt.optim_gamma)
scheduler_D = lr_scheduler.StepLR(D_local_optimizer,
step_size=opt.optim_step_size,
gamma=opt.optim_gamma)
#----------------------------TRAIN-----------------------------------------
print('training start!')
start_time = time.time()
for epoch in range(opt.train_epoch):
epoch_start_time = time.time()
scheduler_G.step()
scheduler_D.step()
D_local_losses = []
G_local_losses = []
y_real_ = torch.ones(opt.batch_size)
y_fake_ = torch.zeros(opt.batch_size)
y_real_, y_fake_ = Variable(y_real_.cuda()), Variable(y_fake_.cuda())
data_iter = iter(train_loader)
num_iter = 0
while num_iter < len(train_loader):
j = 0
while j < opt.critic_iter and num_iter < len(train_loader):
j += 1
sample_batched = data_iter.next()
num_iter += 1
x_ = sample_batched['image']
y_ = sample_batched['single_fg_mask']
fg_mask = sample_batched['seg_mask']
y_instances = sample_batched['mask_instance']
bbox = sample_batched['bbox']
mini_batch = x_.size()[0]
if mini_batch != opt.batch_size:
break
#Update discriminators - D
#Real examples
D_glob.zero_grad()
D_instance.zero_grad()
x_, y_ = Variable(x_.cuda()), Variable(y_.cuda())
fg_mask = Variable(fg_mask.cuda())
y_reduced = torch.sum(y_,
1).clamp(0,
1).view(y_.size(0), 1,
opt.img_size,
opt.img_size)
x_d = torch.cat([x_, fg_mask], 1)
x_instances = torch.zeros(
(opt.batch_size, 3, opt.local_patch_size,
opt.local_patch_size))
x_instances = Variable(x_instances.cuda())
y_instances = Variable(y_instances.cuda())
y_instances = pooling_instance(y_instances)
G_instances = torch.zeros(
(opt.batch_size, 3, opt.local_patch_size,
opt.local_patch_size))
G_instances = Variable(G_instances.cuda())
#Obtain instances
for t in range(x_d.size()[0]):
x_instance = x_[t, 0:3, bbox[0][t]:bbox[1][t],
bbox[2][t]:bbox[3][t]]
x_instance = x_instance.contiguous().view(
1,
x_instance.size()[0],
x_instance.size()[1],
x_instance.size()[2])
x_instances[t] = up_instance(x_instance)
D_result_instance = D_instance(
torch.cat([x_instances, y_instances], 1)).squeeze()
D_result = D_glob(x_d).squeeze()
D_real_loss = BCE_loss(D_result, y_real_) + BCE_loss(
D_result_instance, y_real_)
D_real_loss.backward()
#Fake examples
z_ = torch.randn((mini_batch, opt.noise_size))
z_ = Variable(z_.cuda())
#Generate fake images
G_fg_result = G_fg(z_, y_, torch.mul(x_, (1 - y_reduced)))
G_result_d = torch.cat([G_fg_result, fg_mask], 1)
#Obtain fake instances
for t in range(x_d.size()[0]):
G_instance = G_result_d[t, 0:3, bbox[0][t]:bbox[1][t],
bbox[2][t]:bbox[3][t]]
G_instance = G_instance.contiguous().view(
1,
G_instance.size()[0],
G_instance.size()[1],
G_instance.size()[2])
G_instances[t] = up_instance(G_instance)
D_result_instance = D_instance(
torch.cat([G_instances, y_instances],
1).detach()).squeeze()
D_result = D_glob(G_result_d.detach()).squeeze()
D_fake_loss = BCE_loss(D_result, y_fake_) + BCE_loss(
D_result_instance, y_fake_)
D_fake_loss.backward()
D_local_optimizer.step()
D_train_loss = D_real_loss + D_fake_loss
D_local_losses.append(D_train_loss.data[0])
if mini_batch != opt.batch_size:
break
#Update generator G
G_fg.zero_grad()
D_result = D_glob(G_result_d).squeeze()
D_result_instance = D_instance(
torch.cat([G_instances, y_instances], 1)).squeeze()
G_train_loss = (1 - opt.trade_off_G) * BCE_loss(
D_result, y_real_) + opt.trade_off_G * BCE_loss(
D_result_instance, y_real_)
#Feature matching loss between generated image and corresponding ground truth
FM_loss = criterionVGG(G_fg_result, x_)
#Reconstruction loss
Recon_loss = mse_loss(torch.mul(x_, (1 - y_reduced)),
torch.mul(G_fg_result, (1 - y_reduced)))
total_loss = G_train_loss + opt.lambda_FM * FM_loss + opt.lambda_recon * Recon_loss
total_loss.backward()
G_local_optimizer.step()
G_local_losses.append(G_train_loss.data[0])
print('loss_d: %.3f, loss_g: %.3f' %
(D_train_loss.data[0], G_train_loss.data[0]))
if (num_iter % 100) == 0:
print('%d - %d complete!' % ((epoch + 1), num_iter))
print(result_folder_name)
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' %
((epoch + 1), opt.train_epoch, per_epoch_ptime,
torch.mean(torch.FloatTensor(D_local_losses)),
torch.mean(torch.FloatTensor(G_local_losses))))
#Save images
G_fg.eval()
if epoch == 0:
show_result((epoch + 1),
x_fixed,
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '_gt.png')
for t in range(y_fixed.size()[1]):
show_result((epoch + 1),
y_fixed[:, t:t + 1, :, :],
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '_' + str(t) + '_masked.png')
show_result((epoch + 1),
G_fg(
z_fixed, y_fixed,
torch.mul(x_fixed, (1 - torch.sum(y_fixed, 1).view(
y_fixed.size(0), 1, opt.img_size, opt.img_size)))),
save=True,
path=root + result_folder_name + '/' + model +
str(epoch + 1) + '_fg.png')
G_fg.train()
#Save model params
if opt.save_models and (epoch > 11 and epoch % 10 == 0):
torch.save(
G_fg.state_dict(), root + model_folder_name + '/' + model +
'G_fg_epoch_' + str(epoch) + '.pth')
torch.save(
D_glob.state_dict(), root + model_folder_name + '/' + model +
'D_glob_epoch_' + str(epoch) + '.pth')
torch.save(
D_instance.state_dict(), root + model_folder_name + '/' +
model + 'D_local_epoch_' + str(epoch) + '.pth')
end_time = time.time()
total_ptime = end_time - start_time
print("Training finish!... save training results")
print('Training time: ' + str(total_ptime))
def train_and_evaluate(param_cuda,
dataset,
G_model,
D_model,
G_optimizer,
D_optimizer,
loss_fn,
train_loader,
train_epoch,
model_dir,
restore_file=None):
'''Train the model and evaluate every epoch'''
# reload weights from restore_file if specified
if restore_file is not None:
restore_path = os.path.join(model_dir, restore_file + '.pth.tar')
logging.info("Restoring parameters from {}".format(restore_path))
utils.load_checkpoint(restore_path, D_model, G_model, D_optimizer,
G_optimizer)
# check training starting time
start_time = time.time()
# here we are going to save the losses of every epoch
train_hist = {}
train_hist['D_model_mean_losses'] = []
train_hist['G_model_mean_losses'] = []
train_hist['per_epoch_ptimes'] = []
train_hist['total_ptime'] = []
# folder for saving the images
if not os.path.isdir(dataset + '_results'):
os.mkdir(dataset + '_results')
for epoch in range(train_epoch):
# Run one epoch
logging.info("Epoch {}/{}".format(epoch + 1, train_epoch))
epoch_start_time = time.time()
# compute number of batches in one epoch (one full pass over the training set)
train_hist = train(G_model, D_model, G_optimizer, D_optimizer, loss_fn,
train_loader, param_cuda, train_hist)
epoch_end_time = time.time()
per_epoch_ptime = epoch_end_time - epoch_start_time
#prints in every epoch:
print("iteration number " + str(epoch))
print(
'[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' %
((epoch + 1), train_epoch, per_epoch_ptime,
torch.mean(torch.FloatTensor(train_hist['D_model_mean_losses'])),
torch.mean(torch.FloatTensor(train_hist['G_model_mean_losses']))))
# Save weights
utils.save_checkpoint(
{
'epoch': epoch + 1,
'D_model_state_dict': D_model.state_dict(),
'G_model_state_dict': G_model.state_dict(),
'D_optim_dict': D_optimizer.state_dict(),
'G_optim_dict': G_optimizer.state_dict()
},
is_best=False,
checkpoint=dataset + '_results/')
#save test pictures after every epoch:
p = dataset + '_results/result_epoch_' + str(epoch + 1) + '.png'
utils.show_result(param_cuda, G_model, (epoch + 1), p, save=True)
# add epoch time to the training history
train_hist['per_epoch_ptimes'].append(per_epoch_ptime)
end_time = time.time()
total_ptime = end_time - start_time
train_hist['total_ptime'].append(total_ptime)
print("Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f" %
(torch.mean(torch.FloatTensor(
train_hist['per_epoch_ptimes'])), train_epoch, total_ptime))
print("Training finish!... save learned parameters")
# plot training history
utils.show_train_hist(train_hist,
save=True,
path=dataset + '_results/_train_hist.png')
- Conv_LSTM without HW
- Conv_MLP with HW
- Conv_MLP without HW
- pure LSTM
"""
p_filepath = "predictions_lorenz"
w_filepath = "weights_lorenz"
print("======================Conv_LSTM with HW====================")
data = pd.read_csv(os.path.join(p_filepath, "Conv-LSTM_20200109-0009.csv"))
preds = data['Predictions']
real = data['True value']
MSE_test = ((real - preds)**2).mean()
print("MSE Test loss: ", MSE_test)
show_result(real, preds, full=False, title="Conv_LSTM with HW")
#Model path:
#model = load_model(os.path.join(w_filepath,"Conv_LSTM-weights-improvement-10-0.0016-bigger.hdf5"))
print("======================Conv_LSTM without HW====================")
data = pd.read_csv(os.path.join(p_filepath, "Conv-LSTM_raw_20200106-2051.csv"))
preds = data['Predictions']
real = data['True value']
MSE_test = ((real - preds)**2).mean()
print("MSE Test loss: ", MSE_test)
show_result(real, preds, full=False, title="Conv_LSTM without HW")
#Model path:
#model = load_model(os.path.join(w_filepath,"Conv_LSTM_raw_weights-18.4356.hdf5"))
print("======================Conv_MLP with HW====================")
data = pd.read_csv(os.path.join(p_filepath, "Conv_MLP-20200108-2118.csv"))
in_window = 100
test_size = 10000
tsc = TSC_lorenz(savevals=True)
serie = tsc.get_next_N_vals(n)
serie_test = tsc.get_next_N_vals(n)
# ==============CONSTANTS END=============
print("=============TESTING HW============")
#%%create holt winter object
print("Initializing Holt Winter")
HW=Holt_Winters_NN(serie,serie_test,1,h=6,windowsize=img_size,stride=1,alpha=0.25,beta=0,gamma=0.35)
print("Initializing Conv_LSTM object")
Conv_LSTM_HW = Conv_LSTM(img_size, seq_len, in_window=in_window, out_window=out_window, conv_layers=0, lstm_layers=2, dropout=0.4, pre_loaded=False, bidirectional=True, channels=2, test_size=test_size)
print("Starting Conv_LSTM training")
model_hw, y_true, y_pred = Conv_LSTM_HW.train_HW(HW, epochs=5, bsize=64, p_filepath=preds_filepath, callbacks=False)
print("Finished training")
print("Showing results")
show_result(y_pred, y_true, title="Conv-LSTM With HW", full=False)
print("=============TESTING RAW TS============")
#%%
#create NN model
print("Initializing Conv_LSTM object")
Conv_LSTM_HW = Conv_LSTM(img_size, seq_len, in_window=in_window, out_window=out_window, conv_layers=0, lstm_layers=2, dropout=0.4, pre_loaded=False, bidirectional=True, channels=3, test_size=test_size)
print("Starting Conv_LSTM training")
model_hw, y_true, y_pred = Conv_LSTM_HW.train_series(serie,serie_test, epochs=5, bsize=64, p_filepath=preds_filepath, callbacks=False)
print("Finished training")
print("Showing results")
show_result(y_pred, y_true, title="Conv-LSTM Without HW")
