def train_step_fn(sess, train_op, global_step, train_step_kwargs): """Function that takes a gradient step and specifies whether to stop. (Wrapper function for train_step in learning.py) Args: sess: The current session. train_op: An `Operation` that evaluates the gradients and returns the total loss. global_step: A `Tensor` representing the global training step. train_step_kwargs: A dictionary of keyword arguments (using this here to pass in my eval_op for validation set evaluation, so we can do evaluation during training). Returns: The total loss and a boolean indicating whether or not to stop training. """ total_loss, should_stop = learning.train_step(sess, train_op, global_step, train_step_kwargs) should_val = sess.run(train_step_kwargs['should_val']) global_step = sess.run(global_step) if should_val: # validate print('validating model on step %d' % global_step) sess.run([train_step_kwargs['eval_op']]) # train_step_kwargs['curr_step'] += 1 return [total_loss, should_stop]
def sequential_train_steps(sess, train_ops, global_step, train_step_kwargs): """A thin wrapper around slim.learning.train_step, for GANs. Args: sess: A Tensorflow session. train_ops: A GANTrainOps tuple of train ops to run. global_step: The global step. train_step_kwargs: Dictionary controlling `train_step` behavior. Returns: A scalar final loss and a bool whether or not the train loop should stop. """ # Only run `should_stop` at the end, if required. Make a local copy of # `train_step_kwargs`, if necessary, so as not to modify the caller's # dictionary. should_stop_op, train_kwargs = None, train_step_kwargs if 'should_stop' in train_step_kwargs: should_stop_op = train_step_kwargs['should_stop'] train_kwargs = train_step_kwargs.copy() del train_kwargs['should_stop'] # Run generator training steps. gen_loss = 0 for _ in range(train_steps.generator_train_steps): cur_gen_loss, _ = slim_learning.train_step( sess, train_ops.generator_train_op, global_step, train_kwargs) gen_loss += cur_gen_loss # Run discriminator training steps. dis_loss = 0 for _ in range(train_steps.discriminator_train_steps): cur_dis_loss, _ = slim_learning.train_step( sess, train_ops.discriminator_train_op, global_step, train_kwargs) dis_loss += cur_dis_loss sess.run(train_ops.global_step_inc_op) # Run the `should_stop` op after the global step has been incremented, so # that the `should_stop` aligns with the proper `global_step` count. if should_stop_op is not None: should_stop = sess.run(should_stop_op) else: should_stop = False return gen_loss + dis_loss, should_stop
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if session.run(train_step_fn.step) % num_per_valid == 0: accuracy = session.run(train_step_fn.accuracy_validation) step = session.run(train_step_fn.step) print('step', step, 'valid accuracy:', accuracy) return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % train_step_fn.test_step == 0: session.run(train_step_fn.accuracy_test) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % FLAGS.validation_check == 0: #accuracy = session.run(train_step_fn.accuracy_validation) print('Step %s - Loss: %.2f ' % (str(train_step_fn.step).rjust(6, '0'), total_loss)) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): # Decaying learning rate every epoch if train_step_fn.step % (nb_batches) == 0: lr_decay = decay_factor ** train_step_fn.epoch session.run(model.lr_rate_assign, feed_dict={model.lr_rate_placeholder: initial_lr * lr_decay}) print('New learning rate: {0}'. format(initial_lr * lr_decay)) train_step_fn.epoch += 1 total_loss, should_stop = train_step(session, *args, **kwargs) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(sess, *args, **kwargs): total_loss, should_stop = train_step(sess, *args, **kwargs) accuracy = sess.run([train_step_fn.accuracy]) if train_step_fn.step % 50 == 0: # sess.run(assignment) accuracy_validation = sess.run( [train_step_fn.accuracy_validation]) # print('Step %s - Loss: %.2f Validation Accuracy: %.2f%%' % # (str(train_step_fn.step).rjust(6, '0'), total_loss, accuracy * 100)) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if session.run(train_step_fn.step) % num_per_valid == 0: accuracy = session.run(train_step_fn.accuracy_validation) step = session.run(train_step_fn.step) with open("./test/test_" + str(step) + ".csv", "w") as datacsv: csvwriter = csv.writer(datacsv, delattr) for i in range(len(accuracy)): csvwriter.writerow(accuracy[i]) return [total_loss, should_stop]
def train_step_fn(sess, my_train_op, global_step, train_step_kwargs): total_loss, should_stop = train_step(sess, my_train_op, global_step, train_step_kwargs) step = sess.run(global_step) if step % FLAGS.log_every_n_steps == 0: accuracy = sess.run(accuracy_validation) print( 'Step %s - Loss: %.4f hold-out validation accuracy: %.4f' % (str(step).rjust(6, '0'), total_loss, accuracy)) return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): # visualizer = Beholder(session=session, logdir=FLAGS.train_dir) total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % FLAGS.validation_check == 0: _mean_iou = session.run(train_step_fn.mean_iou) print('evaluation step %d - loss = %.4f mean_iou = %.2f%%' %\ (train_step_fn.step, total_loss, _mean_iou )) # evaluated_tensors = session.run([end_points['conv4'], end_points['up1']]) # example_frame = session.run(end_points['up2']) # visualizer.update(arrays=evaluated_tensors, frame=example_frame) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % validation_every_n_step == 0: accuracy = sess.run(train_step_fn.accuracy_validation) print("Validation Accuracy:", accuracy) if accuracy >= 0.993: print("准确率达到了99.3%,退出训练") if train_step_fn.step % test_every_n_step == 0: accuracy = session.run(train_step_fn.accuracy_test) print("Test Accuracy:", accuracy) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % FLAGS.validation_check == 0: pass # throws OutOfRange error after some time # accuracy = session.run(train_step_fn.accuracy_validation) # print('Step %s - Loss: %.2f Accuracy: %.2f%%' % ( # str(train_step_fn.step).rjust(6, '0'), total_loss, accuracy * 100)) # if train_step_fn.step == (FLAGS.max_steps - 1): # accuracy = session.run(accuracy_test) # print('%s - Loss: %.2f Accuracy: %.2f%%' % ('FINAL TEST', total_loss, accuracy * 100)) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(session, *args, **kwargs): def softmax(x): """Compute softmax values for each sets of scores in x.""" x=np.transpose(x); return np.transpose(np.exp(x) / np.sum(np.exp(x), axis=0)) total_loss, should_stop = train_step(session, *args, **kwargs) if train_step_fn.step % FLAGS.eval_every_n_steps == 0: start = time.time() tp = 0; fp = 0; tn = 0; fn = 0; y_true = []; y_scores = []; for eval_iter in range(num_batches_val): # pred, lab, logis = session.run([train_step_fn.predictions_val, train_step_fn.labels_val, train_step_fn.logits_val]) pred, lab, logis, scs = session.run([train_step_fn.predictions_val, train_step_fn.labels_val, train_step_fn.logits_val, train_step_fn.scs_val]) # scs = softmax(logis); scs = scs[:, 1]; y_true = np.append(y_true,lab); y_scores = np.append(y_scores, scs); pos = np.equal(lab, 1); neg = np.invert(pos); pred_pos = np.equal(pred, 1); pred_neg = np.invert(pred_pos); tp += np.sum(np.multiply(pos, pred_pos)); tn += np.sum(np.multiply(neg, pred_neg)); fp += np.sum(np.multiply(neg, pred_pos)); fn += np.sum(np.multiply(pos, pred_neg)); auc = roc_auc_score(y_true, y_scores); accuracy = (tp+tn)/(tp+tn+fp+fn); logging.info('Step %s - Loss: %.2f Accuracy: %.2f%%, TP: %d, FP: %d, TN: %d, FN: %d, AUC: %.2f%%', str(train_step_fn.step).rjust(6, '0'), total_loss, accuracy * 100, tp, fp, tn, fn, auc*100) of.write('Step %s - Loss: %.2f Accuracy: %.2f%%, TP: %d, FP: %d, TN: %d, FN: %d, AUC: %.2f%% \n'% (str(train_step_fn.step).rjust(6, '0'), total_loss, accuracy * 100, tp, fp, tn, fn, auc*100)) end = time.time() logging.info('Took %f seconds for evaluation', end-start); train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(sess, train_tensor, global_step, train_step_kwargs): total_loss, should_stop = train_step(sess, train_tensor, global_step, train_step_kwargs) if train_step_fn.step % FLAGS.log_every_n_steps == 0: accuracy = sess.run(train_step_fn.accuracy) print('Accuracy: %.2f%%' % (accuracy * 100)) csv_writerow(test_csv_file, [FLAGS.loss] + [train_step_fn.step] + [accuracy * 100]) #print('Accuracy: %.2f%%' % accuracy) #print('Accuracy: % g' % accuracy) # if train_step_fn.step == (FLAGS.max_steps - 1): # accuracy = sess.run(accuracy_test) # print('%s - Loss: %.2f Accuracy: %.2f%%' % ('FINAL TEST', total_loss, accuracy * 100)) train_step_fn.step += 1 return [total_loss, should_stop]
def train_step_fn(sess, train_op, global_step, train_step_kwargs): """Function that takes a gradient step and specifies whether to stop. (Wrapper function for train_step in learning.py) Args: sess: The current session. train_op: An `Operation` that evaluates the gradients and returns the total loss. global_step: A `Tensor` representing the global training step. train_step_kwargs: A dictionary of keyword arguments (using this here to pass in my eval_op for validation set evaluation, so we can do evaluation during training). Returns: The total loss and a boolean indicating whether or not to stop training. """ # first, run the normal training step (happens every single step) total_loss, should_stop = learning.train_step(sess, train_op, global_step, train_step_kwargs) # get global step as a value i can log global_step = sess.run(global_step) # decide whether to reset the streaming evaluation metrics should_reset = sess.run(train_step_kwargs['should_reset_eval_metrics']) if should_reset: # reset counter and total logging.info('RESETTING STREAMING EVAL METRICS AT STEP %d\n'% (global_step)) sess.run([train_step_kwargs['reset_op']]) # decide whether to run evaluation should_val = sess.run(train_step_kwargs['should_val']) if should_val: # validate logging.info('EVALUATING MODEL AT STEP %d\n'% (global_step)) sess.run([train_step_kwargs['eval_op']] ) return [total_loss, should_stop]