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())