我们从Python开源项目中，提取了以下9个代码示例，用于说明如何使用model.loss()。
def create_model(name, batch_size, learning_rate = 0.0001, wd = 0.00001, concat = False, l2_loss = False, penalty = False, coef = 0.4, verbosity = 0): """ Create a model from model.py with the given configuration Args: name : name of the model (used to create a specific folder to save/load parameters) batch_size : batch size learning_rate : learning_rate (cross entropy is arround 100* bigger than l2) wd : weight decay factor concat : does this model include direct connections? l2_loss : does this model use l2 loss (if not then cross entropy) penalty : whether to use the edge contrast penalty coef : coef for the edge contrast penalty verbosity : level of details to display Returns: my_model : created model """ my_model = model.MODEL(name, batch_size, learning_rate, wd, concat, l2_loss, penalty, coef) my_model.display_info(verbosity) return my_model
def train(tfrecord_file, train_dir, batch_size, num_epochs): _, vectors, labels = data_loader.inputs( [tfrecord_file], batch_size=batch_size, num_threads=16, capacity=batch_size*4, min_after_dequeue=batch_size*2, num_epochs=num_epochs, is_training=True) loss = model.loss(vectors, labels) global_step = tf.Variable(0, name='global_step', trainable=False) # Create training op with dependencies on update ops for batch norm update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = tf.train.AdamOptimizer(learning_rate=0.001). \ minimize(loss, global_step=global_step) # Create training supervisor to manage model logging and saving sv = tf.train.Supervisor(logdir=train_dir, global_step=global_step, save_summaries_secs=60, save_model_secs=600) with sv.managed_session() as sess: while not sv.should_stop(): _, loss_out, step_out = sess.run([train_op, loss, global_step]) if step_out % 100 == 0: print('Step {}: Loss {}'.format(step_out, loss_out))
def train(): with tf.Graph().as_default(): global_step = tf.Variable(0, trainable=False) image, label = input.get_input(LABEL_PATH, LABEL_FORMAT, IMAGE_PATH, IMAGE_FORMAT) logits = model.inference(image) loss = model.loss(logits, label) train_op = model.train(loss, global_step) saver = tf.train.Saver(tf.all_variables()) summary_op = tf.merge_all_summaries() init = tf.initialize_all_variables() sess = tf.Session(config=tf.ConfigProto(log_device_placement=input.FLAGS.log_device_placement)) sess.run(init) # Start the queue runners. tf.train.start_queue_runners(sess=sess) summary_writer = tf.train.SummaryWriter(input.FLAGS.train_dir, graph_def=sess.graph_def) for step in xrange(input.FLAGS.max_steps): start_time = time.time() _, loss_value = sess.run([train_op, loss]) duration = time.time() - start_time assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % 1 == 0: num_examples_per_step = input.FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)') print (format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) if step % 10 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) # Save the model checkpoint periodically. if step % 25 == 0: checkpoint_path = os.path.join(input.FLAGS.train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
def get_criterion(exp_name): ''' create loss function based on parameters loaded from config ''' cfg = config.load_config_file(exp_name) criterion_name = cfg['criterion'] loss_method = getattr(loss, criterion_name) criterion = loss_method() return criterion
def tower_loss(scope): """Calculate the total loss on a single tower running the MNIST model. Args: scope: unique prefix string identifying the MNIST tower, e.g. 'tower_0' Returns: Tensor of shape [] containing the total loss for a batch of data """ # Get images and labels for MSNIT. images, labels = model.inputs(FLAGS.batch_size) # Build inference Graph. logits = model.inference(images, keep_prob=0.5) # Build the portion of the Graph calculating the losses. Note that we will # assemble the total_loss using a custom function below. _ = model.loss(logits, labels) # Assemble all of the losses for the current tower only. losses = tf.get_collection('losses', scope) # Calculate the total loss for the current tower. total_loss = tf.add_n(losses, name='total_loss') # Attach a scalar summary to all individual losses and the total loss; do # the same for the averaged version of the losses. if (FLAGS.tb_logging): for l in losses + [total_loss]: # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU # training session. This helps the clarity of presentation on # tensorboard. loss_name = re.sub('%s_[0-9]*/' % model.TOWER_NAME, '', l.op.name) tf.summary.scalar(loss_name, l) return total_loss
def __init__(self, model_dir=None, gpu_fraction=0.7): config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.per_process_gpu_memory_fraction=gpu_fraction self.sess = tf.Session(config=config) self.imgs_ph, self.bn, self.output_tensors, self.pred_labels, self.pred_locs = model.model(self.sess) total_boxes = self.pred_labels.get_shape().as_list()[1] self.positives_ph, self.negatives_ph, self.true_labels_ph, self.true_locs_ph, self.total_loss, self.class_loss, self.loc_loss = \ model.loss(self.pred_labels, self.pred_locs, total_boxes) out_shapes = [out.get_shape().as_list() for out in self.output_tensors] c.out_shapes = out_shapes c.defaults = model.default_boxes(out_shapes) # variables in model are already initialized, so only initialize those declared after with tf.variable_scope("optimizer"): self.global_step = tf.Variable(0) self.lr_ph = tf.placeholder(tf.float32, shape=[]) self.optimizer = tf.train.AdamOptimizer(1e-3).minimize(self.total_loss, global_step=self.global_step) new_vars = tf.get_collection(tf.GraphKeys.VARIABLES, scope="optimizer") self.sess.run(tf.initialize_variables(new_vars)) if model_dir is None: model_dir = FLAGS.model_dir ckpt = tf.train.get_checkpoint_state(model_dir) self.saver = tf.train.Saver() if ckpt and ckpt.model_checkpoint_path: self.saver.restore(self.sess, ckpt.model_checkpoint_path) print("restored %s" % ckpt.model_checkpoint_path)
def __init__(self, model_dir=None): self.sess = tf.Session() self.imgs_ph, self.bn, self.output_tensors, self.pred_labels, self.pred_locs = model.model(self.sess) total_boxes = self.pred_labels.get_shape().as_list()[1] self.positives_ph, self.negatives_ph, self.true_labels_ph, self.true_locs_ph, self.total_loss, self.class_loss, self.loc_loss = \ model.loss(self.pred_labels, self.pred_locs, total_boxes) out_shapes = [out.get_shape().as_list() for out in self.output_tensors] c.out_shapes = out_shapes c.defaults = model.default_boxes(out_shapes) # variables in model are already initialized, so only initialize those declared after with tf.variable_scope("optimizer"): self.global_step = tf.Variable(0) self.lr_ph = tf.placeholder(tf.float32) self.optimizer = tf.train.AdamOptimizer(1e-3).minimize(self.total_loss, global_step=self.global_step) new_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="optimizer") init = tf.variables_initializer(new_vars) self.sess.run(init) if model_dir is None: model_dir = FLAGS.model_dir ckpt = tf.train.get_checkpoint_state(model_dir) self.saver = tf.train.Saver() if ckpt and ckpt.model_checkpoint_path: self.saver.restore(self.sess, ckpt.model_checkpoint_path) print("restored %s" % ckpt.model_checkpoint_path)
def do_eval(sess, eval_loss, images_placeholder, labels_placeholder, training_time_placeholder, images, labels, batch_size): ''' Function for running the evaluations every X iterations on the training and validation sets. :param sess: The current tf session :param eval_loss: The placeholder containing the eval loss :param images_placeholder: Placeholder for the images :param labels_placeholder: Placeholder for the masks :param training_time_placeholder: Placeholder toggling the training/testing mode. :param images: A numpy array or h5py dataset containing the images :param labels: A numpy array or h45py dataset containing the corresponding labels :param batch_size: The batch_size to use. :return: The average loss (as defined in the experiment), and the average dice over all `images`. ''' loss_ii = 0 dice_ii = 0 num_batches = 0 for batch in BackgroundGenerator(iterate_minibatches(images, labels, batch_size=batch_size, augment_batch=False)): # No aug in evaluation # As before you can wrap the iterate_minibatches function in the BackgroundGenerator class for speed improvements # but at the risk of not catching exceptions x, y = batch if y.shape[0] < batch_size: continue feed_dict = { images_placeholder: x, labels_placeholder: y, training_time_placeholder: False} closs, cdice = sess.run(eval_loss, feed_dict=feed_dict) loss_ii += closs dice_ii += cdice num_batches += 1 avg_loss = loss_ii / num_batches avg_dice = dice_ii / num_batches logging.info(' Average loss: %0.04f, average dice: %0.04f' % (avg_loss, avg_dice)) return avg_loss, avg_dice
def main(ckpt = None): with tf.Graph().as_default(): keep_prob = tf.placeholder("float") images, labels, _ = input.load_data([FLAGS.train], FLAGS.batch_size, shuffle = True, distored = True) logits = model.inference_deep(images, keep_prob, input.DST_INPUT_SIZE, input.get_count_member()) # ?? loss_value = model.loss(logits, labels) # ?? train_op = model.training(loss_value, FLAGS.learning_rate) # ?? acc = model.accuracy(logits, labels) saver = tf.train.Saver(max_to_keep = 0) sess = tf.Session() sess.run(tf.initialize_all_variables()) if ckpt: print 'restore ckpt', ckpt saver.restore(sess, ckpt) tf.train.start_queue_runners(sess) summary_op = tf.merge_all_summaries() summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph) # summary_writer = tf.train.SummaryWriter(FLAGS.train_dir) for step in range(FLAGS.max_steps): start_time = time.time() _, loss_result, acc_res = sess.run([train_op, loss_value, acc], feed_dict={keep_prob: 0.99}) duration = time.time() - start_time if step % 10 == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)') print (format_str % (datetime.now(), step, loss_result, examples_per_sec, sec_per_batch)) print 'acc_res', acc_res if step % 100 == 0: summary_str = sess.run(summary_op,feed_dict={keep_prob: 1.0}) summary_writer.add_summary(summary_str, step) checkpoint_path = os.path.join(FLAGS.model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step % 1000 == 0 or (step + 1) == FLAGS.max_steps or loss_result == 0: checkpoint_path = os.path.join(FLAGS.model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if loss_result == 0: print('loss is zero') break
