def train(model, opt, scheduler, train_loader, dev):
scheduler.step()
model.train()
total_loss = 0
num_batches = 0
total_correct = 0
count = 0
with tqdm.tqdm(train_loader, ascii=True) as tq:
for i, (data, label) in enumerate(tq):
num_examples = label.shape[0]
data, label = data.to(dev), label.to(dev).squeeze().long()
opt.zero_grad()
logits = model(data)
loss = compute_loss(logits, label)
loss.backward()
opt.step()
_, preds = logits.max(1)
num_batches += 1
count += num_examples
loss = loss.item()
correct = (preds == label).sum().item()
total_loss += loss
total_correct += correct
tq.set_postfix({
'Loss': '%.5f' % loss,
'AvgLoss': '%.5f' % (total_loss / num_batches),
'Acc': '%.5f' % (correct / num_examples),
'AvgAcc': '%.5f' % (total_correct / count)})
if (i+1) % 100 == 0:
torch.save(model.state_dict(), args.save_model_path)
def build_model(input, is_train=True, reuse=False):
with tf.variable_scope('model'):
left_res = Res_bone(input[0], is_train=is_train, reuse=reuse)
right_res = Res_bone(input[1], is_train=is_train, reuse=True)
left_cost_volume, right_cost_volume = create_costVolume(left_res.disp_feature, right_res.disp_feature, a.max_num_disparity)
with tf.variable_scope('Initial'):
# initial disparity estimation
left_initial_disp_logits = modual3D(left_cost_volume, is_train=is_train, reuse=reuse)
right_initial_disp_logits = modual3D(right_cost_volume, is_train=is_train, reuse=True)
# disparity estimation, same size of original stereo images
left_initial_disp = predict(left_initial_disp_logits, TARGET_SHAPE, name='left_disp')
right_initial_disp = predict(right_initial_disp_logits, TARGET_SHAPE, name='right_disp')
L1 = compute_loss(
input[0], input[1],
left_initial_disp,
right_initial_disp,
left_res.seg_embedding,
right_res.seg_embedding,
WEIGHTS_LIST,
name='Initial_loss'
)
with tf.variable_scope('Refined'):
# refinement
left_refined_disp_logits = refinement(left_initial_disp_logits, left_res.seg_embedding, is_train=is_train, reuse=reuse)
right_refined_disp_logits = refinement(right_initial_disp_logits, right_res.seg_embedding, is_train=is_train, reuse=True)
# disparity estimation, same size of original stereo images
left_refined_disp = predict(left_refined_disp_logits, TARGET_SHAPE, name='left_disp')
right_refined_disp = predict(right_refined_disp_logits, TARGET_SHAPE, name='right_disp')
L2 = compute_loss(
input[0], input[1],
left_refined_disp,
right_refined_disp,
left_res.seg_embedding,
right_res.seg_embedding,
WEIGHTS_LIST,
name='Refined_loss'
)
loss = a.w1*L1 + a.w2*L2
return loss, L1, L2, left_initial_disp, right_initial_disp, left_refined_disp, right_refined_disp
def build_graph(x, y, learning_rate, is_training, latent_var_dim, tau,
batch_size, inf_layers, gen_layers):
latent_vars, inf_mean_list, inf_var_list, q_lls = inference_model(
x, is_training, latent_var_dim, tau, batch_size, inf_layers)
img_vec, gen_imgs, log_px, gen_mean_list, gen_var_list = generative_model(
x, latent_vars, is_training, latent_var_dim, gen_layers)
elbo, mean_rec, mean_KL = compute_loss(inf_mean_list, inf_var_list,
gen_mean_list, gen_var_list,
q_lls[-1], log_px, batch_size)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(-elbo)
return elbo, mean_rec, mean_KL, optimizer, latent_vars, img_vec, gen_imgs
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--epochs',
type=int,
default=1,
help='number of epochs')
parser.add_argument('--batch_size',
type=int,
default=32,
help='batch size')
parser.add_argument('--dim',
'-d',
type=int,
default=2,
help='size of latent space')
args = parser.parse_args()
(x_train, _), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype(np.float32).reshape((x_train.shape[0], -1))
x_train = x_train / 255.
x_test = x_test.astype(np.float32).reshape((x_test.shape[0], -1))
x_test = x_test / 255.
encoder = Encoder(latent_dim=args.dim)
decoder = Decoder(output_size=28 * 28)
vae = VAE(encoder, decoder)
dataset = tf.data.Dataset.from_tensor_slices(x_train).shuffle(
args.batch_size * 10).batch(args.batch_size)
optimizer = tf.train.AdamOptimizer()
global_step = tf.train.get_or_create_global_step()
for epoch in range(args.epochs):
for i, x in enumerate(dataset):
with tf.GradientTape() as tape:
loss = compute_loss(vae, x)
gradient = tape.gradient(loss, vae.trainable_variables)
optimizer.apply_gradients(zip(gradient, vae.trainable_variables),
global_step)
if i % 1000 == 0:
print('Epochs: {}, Iters: {} loss: {}'.format(
epoch, i, loss.numpy()))
data = (x_test, y_test)
plot_results(vae, data, batch_size=args.batch_size)
def validation_step(self, batch, batch_idx):
x, y = batch
outputs = self(x.float(), n_batches=len(y))
loss = compute_loss(outputs, y, self.parameters())
acc = FM.accuracy(outputs > 0, y)
self.log_dict(
{
"validation_loss": loss.item(),
"validation_acc": acc,
},
prog_bar=False,
on_step=True,
on_epoch=True,
)
return acc
def training_step(self, batch, batch_idx):
x, y = batch
outputs = self(x.float(), n_batches=len(y))
torch.nn.utils.clip_grad_norm_(self.parameters(), 0.5)
loss = compute_loss(outputs, y, self.parameters())
self.log_dict(
{
"train_loss": loss.item(),
"train_acc": self.train_accuracy(outputs > 0, y),
},
prog_bar=True,
on_step=True,
on_epoch=True,
)
return loss
def calculate_loss(self, data, dec_logits):
x, x_lens, ys_i, ys_t, ys_lens, xys_idx = data
if self.batch_first:
cdata = [ys_t, ys_lens, dec_logits]
cdata = [d.transpose(1, 0).contiguous() for d in cdata]
ys_t, ys_lens, dec_logits = cdata
losses_b = []
losses_s = []
for logits, y, lens in zip(dec_logits, ys_t, ys_lens):
loss_batch, loss_step = compute_loss(logits, y, lens)
losses_b.append(loss_batch)
losses_s.append(loss_step)
return losses_b, losses_s
def run_train(train_dataset, model, optimizer, epoch, args):
model.zero_grad()
model = model.train()
dataloader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True)
total = len(dataloader)
accu_loss = 0.
for idx, batch in enumerate(dataloader):
loss = compute_loss(model, batch)
loss.backward()
optimizer.step()
model.zero_grad()
accu_loss += loss.item()
if (idx + 1) % args.log_every == 0:
avg_loss = accu_loss / args.log_every
info = f"Epoch: {epoch} | Step: {idx+1}/{total} | Loss: {avg_loss:.4f}"
accu_loss = 0.
LOG.info(info)
epochs = 10000
model = m.MODEL()
optimizer = tf.keras.optimizers.Adam(5e-4)
for epoch in range(1, epochs + 1):
for train_x in train_dataset:
m.compute_apply_gradients(
model, train_x, optimizer,
tf.constant(1. - 0.95 * np.exp(-epoch / 1000), dtype=tf.float32))
if epoch % 500 == 0:
loss = tf.keras.metrics.Mean()
for test_x in train_dataset:
loss(
m.compute_loss(model, test_x, tf.constant(1.0,
dtype=tf.float32)))
elbo = -loss.result()
print('Epoch: {}, Training set ELBO: {} '.format(epoch, elbo))
#Gradually decrease the variance of the residual constraint to the final value
model.Sigma.assign(tf.constant(-8., shape=(1, 1)))
for epoch in range(1, epochs + 1):
for train_x in train_dataset:
m.compute_apply_gradients(
model, train_x, optimizer,
tf.constant(1. - 0.95 * np.exp(-epoch / 1000), dtype=tf.float32))
#Closed-form update law for ARD-Prior. Closed form updates for other parameters are also possible
tmp = []
for i in range(101):
tmp.append((1e-8 + 0.5) / (1e-8 + 0.5 * (model.Theta.numpy()[i]**2)))
def evaluate_model():
"""Evaluate model with calculating test accuracy
"""
sess = setup_tensorflow()
# SetUp Input PipeLine for queue inputs
with tf.name_scope('train_input'):
evaluate_features, evaluate_labels = input_pipeline.get_files(
evaluate_dir)
# Create Model creating graph
output, var_list, is_training1 = model.create_model(
sess, evaluate_features, evaluate_labels)
# Create Model loss & optimizer
with tf.name_scope("loss"):
total_loss, softmax_loss = model.compute_loss(output, evaluate_labels)
(global_step, learning_rate,
minimize) = model.create_optimizer(total_loss, var_list)
# Acurracy setup
out_eval, eval_input, eval_label, accuracy, is_training2 = model.compute_accuracy(
sess)
sess.run(tf.global_variables_initializer())
# Basic stuff for input pipeline
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
# Calculate number of batches to run
num_batches = EVALUATE_DATASET_SIZE / FLAGS.BATCH_SIZE
# Add ops to restore all the variables.
saver = tf.train.Saver()
# Give the path of model with weights u wanna load
saver.restore(sess, "./model/model100.ckpt")
# Calculate acurracy for whole evaluate data
total_accuracy = 0
for batch in range(1, num_batches + 1):
# Load input from the pipeline in batches , batch by batch
input_batch, label_batch = sess.run(
[evaluate_features, evaluate_labels])
feed_dict = {
eval_input: input_batch,
eval_label: label_batch,
is_training2: False
}
ops = [out_eval, accuracy]
# Get the accuracy on evaluate batch run
_, acc = sess.run(ops, feed_dict=feed_dict)
print(" batch /" + str(batch) + " /" + str(num_batches) + " acc: " +
str(acc))
total_accuracy += acc
total_accuracy /= (num_batches + 1)
# Total Accuracy for Evaluate dataset
print(" ACCURACY : " + str(total_accuracy))
def main():
parser = argparse.ArgumentParser()
_.parse_file(BASE_DIR)
hpargparse.bind(parser, _)
parser.parse_args() # we need not to use args
# print all hyperparameters
print("-" * 10 + " Hyperparameters " + "-" * 10)
print(yaml.dump(_.get_values()))
optimizer_cls = {
"adam": optim.Adam,
"sgd": functools.partial(optim.SGD, momentum=0.9),
}[_("optimizer", "adam") # <-- hyperparameter
]
import model
net = model.get_model()
if torch.cuda.is_available():
net.cuda()
optimizer = optimizer_cls(
net.parameters(),
lr=_("learning_rate", 1e-3), # <-- hyperparameter
weight_decay=_("weight_decay", 1e-5), # <-- hyperparameter
)
import dataset
train_ds = dataset.get_data_and_labels("train")
test_ds = dataset.get_data_and_labels("test")
if torch.cuda.is_available():
# since mnist is a small dataset, we store the test dataset all in the
# gpu memory
test_ds = {k: v.cuda() for k, v in test_ds.items()}
rng = np.random.RandomState(_("seed", 42)) # <-- hyperparameter
for epoch in range(_("num_epochs", 30)): # <-- hyperparameter
net.train()
tq = tqdm(
enumerate(
dataset.iter_dataset_batch(
rng,
train_ds,
_("batch_size", 256), # <-- hyperparameter
cuda=torch.cuda.is_available(),
)))
for step, minibatch in tq:
optimizer.zero_grad()
Y_pred = net(minibatch["data"])
loss = model.compute_loss(Y_pred, minibatch["labels"])
loss.backward()
optimizer.step()
metrics = model.compute_metrics(Y_pred, minibatch["labels"])
metrics["loss"] = loss.detach().cpu().numpy()
tq.desc = "e:{} s:{} {}".format(
epoch,
step,
" ".join([
"{}:{}".format(k, v) for k, v in sorted(metrics.items())
]),
)
net.eval()
# since mnist is a small dataset, we predict all values at once.
Y_pred = net(test_ds["data"])
metrics = model.compute_metrics(Y_pred, test_ds["labels"])
print("eval: {}".format(" ".join(
["{}:{}".format(k, v) for k, v in sorted(metrics.items())])))
def train(exp_dir, model, dataloaders, meta_data, opt_all, sch_all, opt_img,
sch_img, opt_dyn, sch_dyn, n_epochs, es_patience, rollout_seq_len,
overlay_alpha, overlay_eps, overlay_n, _config):
best_model = copy.deepcopy(model.state_dict())
val_best_score = np.inf
val_best_results = None
val_best_epoch = -1
valid_pred_imgs_dir = os.path.join(exp_dir, 'valid_pred_imgs')
valid_pred_imgs_dir_wo_objs = os.path.join(exp_dir,
'valid_pred_imgs_wo_objs')
valid_pred_imgs_dir_overlay = os.path.join(exp_dir,
'valid_pred_imgs_overlay')
os.makedirs(valid_pred_imgs_dir, exist_ok=True)
os.makedirs(valid_pred_imgs_dir_wo_objs, exist_ok=True)
os.makedirs(valid_pred_imgs_dir_overlay, exist_ok=True)
do_early_stopping = False
for epoch in range(n_epochs):
if do_early_stopping:
break
for phase in dataloaders.keys():
first_batch = True
epoch_time = time.time()
if phase == 'train':
model.train()
else:
model.eval()
results = {
'loss': [],
'traj_nll': [],
'traj_nll_partial': [],
'sf_traj_nll': [],
'traj_mse': [],
# 'traj_pred_mse': [], # this we don't need in train and valid
'kl_edge': [],
'kl_obj': [],
'edge_acc': [],
'edge_acc_sparse': [],
'graph_acc': [],
'imgs_nll': [],
'imgs_mse': [],
'imgs_pred_mse': [],
'imgs_pred_nll': [],
}
model.update_loss_coefficients(epoch)
for i_batch, batch in enumerate(dataloaders[phase]):
for key in batch.keys():
batch[key] = batch[key].cuda()
batch['imgs'] = batch['imgs'].float() / 255.0
batch['imgs'] = batch['imgs'].transpose(-1, -3)
if opt_img is not None:
# Case where we deal only with trajectories
opt_img.zero_grad()
opt_all.zero_grad()
if phase == 'valid' and first_batch:
model.first_batch = True
with torch.set_grad_enabled(phase == 'train'):
# Forward pass
outputs = model(batch, epoch)
# Calculate the loss
loss, loss_report = compute_loss(batch, outputs, meta_data,
model)
for key in results.keys():
results[key].append(loss_report[key])
# Backprop
if phase == 'train':
loss.backward()
if model.params_to_optimize(n_epochs) == 'all':
opt_all.step()
elif model.params_to_optimize(n_epochs) == 'img':
opt_img.step()
elif model.params_to_optimize(n_epochs) == 'dyn':
opt_dyn.step()
if phase == 'valid' and first_batch:
if outputs['imgs_pred'] is not None:
# Write the predicted images
img_dir = os.path.join(valid_pred_imgs_dir, str(epoch))
os.makedirs(img_dir)
img_dir_wo = os.path.join(valid_pred_imgs_dir_wo_objs,
str(epoch))
img_dir_ov = os.path.join(valid_pred_imgs_dir_overlay,
str(epoch))
os.makedirs(img_dir_wo)
os.makedirs(img_dir_ov)
concat_pred_imgs_and_save(
batch['imgs'][:, 1:, :, :, :],
outputs['imgs_pred'], outputs['imgs_pred_objs'],
img_dir, rollout_seq_len)
concat_pred_imgs_and_save(batch['imgs'][:,
1:, :, :, :],
outputs['imgs_pred'],
outputs['imgs_pred_objs'],
img_dir_wo,
rollout_seq_len,
draw_objs=False)
concat_pred_imgs_and_save(batch['imgs'][:,
1:, :, :, :],
outputs['imgs_pred'],
outputs['imgs_pred_objs'],
img_dir_ov,
rollout_seq_len,
draw_objs=False,
overlay_rollouts=True,
overlay_alpha=overlay_alpha,
overlay_eps=overlay_eps,
overlay_n=overlay_n)
first_batch = False
model.first_batch = False
if phase == 'train':
if model.params_to_optimize(n_epochs) == 'all':
sch_all.step()
elif model.params_to_optimize(n_epochs) == 'img':
sch_img.step()
elif model.params_to_optimize(n_epochs) == 'dyn':
sch_dyn.step()
epoch_t = (time.time() - epoch_time) / 60
eta = (n_epochs - epoch - 1) * epoch_t / 60
# Print
log_results(results, epoch, phase)
info = "[%d/%d] %s epoch: %.3fmins eta: %.3fhrs" % (
epoch, n_epochs, phase, epoch_t, eta)
for key, value in results.items():
if not isinstance(value[0], np.ndarray):
info += " %s: %.3f" % (key, float(np.mean(value)))
print(info)
# ES
if phase == 'valid':
if model.reset_best_valid_loss(epoch):
val_best_score = np.inf
if np.mean(results['loss']) < val_best_score:
# Save the best model or early stopping
print('Best model so far, saving...')
model.save(exp_dir)
best_model = copy.deepcopy(model.state_dict())
val_best_score = np.mean(results['loss'])
val_best_epoch = epoch
val_best_results = results
elif epoch - val_best_epoch >= es_patience:
print('Validation score did not improve for {} epochs. '
'Early stopping.'.format(es_patience))
do_early_stopping = True
print()
log_results(val_best_results, val_best_epoch, "best.valid")
info = 'Training complete. Best val acc: {:4f}'.format(val_best_score)
print(info)
model.load_state_dict(best_model)
return model, val_best_epoch
def evaluate(exp_dir, model, val_best_epoch, test_loader, meta_data,
render_traj_test, rollout_seq_len, overlay_alpha, overlay_eps,
overlay_n, seed, _config):
# Set random seed
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
# Set up dirs
eval_graph_dir = os.path.join(exp_dir, 'eval_graphs')
eval_traj_render_dir = os.path.join(exp_dir, 'eval_traj_render')
eval_traj_render_overlay_dir = os.path.join(exp_dir,
'eval_traj_render_overlay')
eval_pred_imgs_dir = os.path.join(exp_dir, 'eval_pred_imgs')
eval_pred_imgs_dir_wo_objs = os.path.join(exp_dir,
'eval_pred_imgs_wo_objs')
eval_pred_imgs_dir_overlay = os.path.join(exp_dir,
'eval_pred_imgs_overlay')
eval_test_pred_imgs_dir = os.path.join(exp_dir, 'eval_test_pred_imgs')
eval_test_pred_imgs_dir_wo_objs = os.path.join(
exp_dir, 'eval_test_pred_imgs_wo_objs')
eval_test_pred_imgs_dir_overlay = os.path.join(
exp_dir, 'eval_test_pred_imgs_overlay')
os.makedirs(eval_graph_dir, exist_ok=True)
os.makedirs(eval_traj_render_dir, exist_ok=True)
os.makedirs(eval_traj_render_overlay_dir, exist_ok=True)
os.makedirs(eval_pred_imgs_dir, exist_ok=True)
os.makedirs(eval_pred_imgs_dir_wo_objs, exist_ok=True)
os.makedirs(eval_pred_imgs_dir_overlay, exist_ok=True)
os.makedirs(eval_test_pred_imgs_dir, exist_ok=True)
os.makedirs(eval_test_pred_imgs_dir_wo_objs, exist_ok=True)
os.makedirs(eval_test_pred_imgs_dir_overlay, exist_ok=True)
# Load the best model
model.eval()
model.first_batch = True
start_time = time.time()
results = {
'loss': [],
'traj_nll': [],
'traj_nll_partial': [],
'sf_traj_nll': [],
'traj_mse': [],
'traj_pred_mse': [],
'kl_edge': [],
'kl_obj': [],
'edge_acc': [],
'edge_acc_sparse': [],
'graph_acc': [],
'imgs_nll': [],
'imgs_mse': [],
'imgs_pred_mse': [],
'imgs_pred_nll': [],
}
for i_batch, batch in enumerate(test_loader):
for key in batch.keys():
batch[key] = batch[key].cuda()
batch['imgs'] = batch['imgs'].float() / 255.0
batch['imgs'] = batch['imgs'].transpose(-1, -3)
# Forward pass
outputs = model(batch, val_best_epoch, is_test=True)
# Calculate the loss
loss, loss_report = compute_loss(batch, outputs, meta_data, model)
for key in results.keys():
results[key].append(loss_report[key])
# Debug rendering stuff
if model.first_batch:
# Write the predicted images
if outputs['imgs_pred'] is not None:
concat_pred_imgs_and_save(batch['imgs'][:, 1:, :, :, :],
outputs['imgs_pred'],
outputs['imgs_pred_objs'],
eval_pred_imgs_dir, rollout_seq_len)
concat_pred_imgs_and_save(batch['imgs'][:, 1:, :, :, :],
outputs['imgs_pred'],
outputs['imgs_pred_objs'],
eval_pred_imgs_dir_wo_objs,
rollout_seq_len,
draw_objs=False)
concat_pred_imgs_and_save(batch['imgs'][:, 1:, :, :, :],
outputs['imgs_pred'],
outputs['imgs_pred_objs'],
eval_pred_imgs_dir_overlay,
rollout_seq_len,
draw_objs=False,
overlay_rollouts=True,
overlay_alpha=overlay_alpha,
overlay_eps=overlay_eps,
overlay_n=overlay_n)
# Write the predicted (unrolled - for 20 steps!) images
if outputs['test_imgs_pred'] is not None:
concat_pred_imgs_and_save(outputs['test_imgs_target'],
outputs['test_imgs_pred'],
outputs['test_imgs_pred_objs'],
eval_test_pred_imgs_dir,
rollout_seq_len)
concat_pred_imgs_and_save(outputs['test_imgs_target'],
outputs['test_imgs_pred'],
outputs['test_imgs_pred_objs'],
eval_test_pred_imgs_dir_wo_objs,
rollout_seq_len,
draw_objs=False)
concat_pred_imgs_and_save(outputs['test_imgs_target'],
outputs['test_imgs_pred'],
outputs['test_imgs_pred_objs'],
eval_test_pred_imgs_dir_overlay,
rollout_seq_len,
draw_objs=False,
overlay_rollouts=True,
overlay_alpha=overlay_alpha,
overlay_eps=overlay_eps,
overlay_n=overlay_n)
# Render the images from trajectories
if render_traj_test:
render_traj_and_save(
outputs['traj_target'],
outputs["traj_pred"],
eval_traj_render_dir,
eval_traj_render_overlay_dir,
n_children=meta_data["n_children"],
rollout_seq_len=rollout_seq_len,
last_level_nodes=meta_data["hierarchy_nodes_list"][-1],
tedges=batch['edges'],
pedges=outputs['latent_edge_samples'],
overlay_alpha=overlay_alpha,
overlay_eps=overlay_eps,
overlay_n=overlay_n)
# Plot the inferred latent graphs
if outputs['latent_edge_samples'] is not None:
plot_batch_graphs(batch['edges'].cpu(),
outputs['latent_edge_samples'].cpu(),
eval_graph_dir, model.mp_full_adj)
model.first_batch = False
# Print
log_results(results, val_best_epoch, 'test')
duration = time.time() - start_time
# Print
info = "TEST epoch/min: %.3f" % (1. / (duration / 60.))
for key, value in results.items():
if not isinstance(value[0], np.ndarray):
info += " %s: %.3f" % (key, float(np.mean(value)))
else:
# list of arrays (for example prediction mse for t=1,2,..,20 steps)
v = np.array(value.copy())
v = np.mean(v, axis=0)
info += " %s: %s" % (key, v)
print(info)
log_results(results, val_best_epoch, "best.test")
return np.mean(results['loss'])
def train_model():
"""Training model with calculating training and dev accuracy
"""
sess = setup_tensorflow()
# SetUp Input PipeLine for queue inputs
with tf.name_scope('train_input'):
train_features, train_labels = input_pipeline.get_files(train_dir)
with tf.name_scope('dev_input'):
dev_features , dev_labels = input_pipeline.get_files(dev_dir)
# Create Model creating graph
output, var_list, is_training1 = model.create_model(sess, train_features, train_labels)
# Create Model loss & optimizer
with tf.name_scope("loss"):
total_loss, softmax_loss = model.compute_loss(output, train_labels )
tf.summary.scalar("loss",total_loss)
(global_step, learning_rate, minimize) = model.create_optimizer(total_loss, var_list)
# Adds summary tensorboard
tf.summary.scalar("loss",total_loss)
# Acurracy setup
out_eval,eval_input, eval_label, accuracy, is_training2 = model.compute_accuracy(sess)
sess.run(tf.global_variables_initializer())
# Basic stuff for input pipeline
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess,coord=coord)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
num_batches = TRAINING_DATASET_SIZE/FLAGS.BATCH_SIZE
num_batches_dev = DEV_DATASET_SIZE/FLAGS.BATCH_SIZE
#add computation graph to summary writer
writer = tf.summary.FileWriter(summary_dir)
writer.add_graph(sess.graph)
merged_summaries = tf.summary.merge_all()
for epoch in range(1,EPOCHS+1):
# Train Model feeding data in batches calculating total loss
Tsloss = 0
Tloss = 0
for batch in range(1,num_batches+1 ):
feed_dict = {learning_rate: LEARNING_RATE,is_training1:True}
ops = [minimize, softmax_loss, total_loss, merged_summaries]
_, sloss, loss, summaries = sess.run(ops, feed_dict=feed_dict)
#print ("Epoch /" + str (epoch) + " /" + str(EPOCHS)+" batch /" + str (batch) + " /" + str(num_batches) + " ; Loss " + str(loss)+ " softmax Loss " + str(sloss))
Tsloss += sloss
Tloss += loss
Tsloss /= (num_batches+1)
Tloss /= (num_batches+1)
print ("Epoch /" + str (epoch) + " /" + str(EPOCHS) + " ; Loss " + str(Tloss)+ " softmax Loss " + str(Tsloss))
# Calculate training acurracy for whole training data
total_accuracy = 0
for batch in range(1,num_batches+1 ):
input_batch, label_batch = sess.run([train_features, train_labels])
feed_dict = {eval_input:input_batch,eval_label:label_batch,is_training2:False}
ops = [out_eval,accuracy]
_,acc = sess.run(ops, feed_dict=feed_dict)
#print("Epoch /" + str (epoch) + " /" + str(EPOCHS)+" batch /" + str (batch) + " /" + str(num_batches) + " acc: " + str( acc ) )
total_accuracy += acc
total_accuracy /= (num_batches+1)
print(" TRAINING ACCURACY : " + str( total_accuracy ) )
# Calculate dev acurracy
total_accuracy = 0
for batch in range(1,num_batches_dev+1 ):
input_batch, label_batch = sess.run([dev_features, dev_labels])
feed_dict = {eval_input:input_batch,eval_label:label_batch,is_training2:False}
ops = [out_eval,accuracy]
_,acc = sess.run(ops, feed_dict=feed_dict)
#print("Epoch /" + str (epoch) + " /" + str(EPOCHS)+" batch /" + str (batch) + " /" + str(num_batches_dev) + " acc: " + str( acc ) )
total_accuracy += acc
total_accuracy /= (num_batches_dev+1)
print(" DEV ACCURACY : " + str( total_accuracy ) )
# Write summary to logdir
writer.add_summary(summaries)
print "Summary Written to Logdir"
# Save model for each eopch
make_dir_if_not_exists(model_dir)
save_path = saver.save(sess, model_dir + "model" + str(epoch) +".ckpt")
print("Model saved in path: %s" % save_path)
# build the graph
Z = model.generator(Y, is_training=True)
X_gen = Y - Z
Y_gen = X2 + Z
D1_logits_real, D1_prob_real = model.discriminator1(X1, is_training=True)
D2_logits_real, D2_prob_real = model.discriminator2(Y, is_training=True)
D1_logits_fake, D1_prob_fake = model.discriminator1(X_gen,
is_training=True,
reuse=True)
D2_logits_fake, D2_prob_fake = model.discriminator2(Y_gen,
is_training=True,
reuse=True)
# compute the loss
D1_loss, D2_loss, G_loss = model.compute_loss(D1_logits_real, D1_prob_real,
D2_logits_real, D2_prob_real,
D1_logits_fake, D1_prob_fake,
D2_logits_fake, D2_prob_fake)
# to record the iteration number
G_steps = tf.Variable(0, trainable=False, name='G_steps')
D_steps = tf.Variable(0, trainable=False, name='D_steps')
# initialize the solvers
D1_solver, D2_solver, G_solver, clip_D1, clip_D2 = \
model.initilize_solvers(
D1_loss, D2_loss, G_loss, D_steps, G_steps)
# initialize the graph
sess = tf.Session()
sess.run(tf.global_variables_initializer())
