def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [ inp.save_state(state) for (inp, state) in zip(inputs, next_states) ] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), labels, weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
sys.path.append(path + '/segmentation/datasets/') sys.path.append(path + '/segmentation/models') sys.path.append(path + '/segmentation/notebooks') import layers import fcn8s import util import cityscapes from colorize import colorize from class_mean_iou import class_mean_iou image_shape = [1, 256, 512, 3] sess = tf.InteractiveSession() image_op = tf.placeholder(tf.float32, shape=image_shape) logits_op = fcn8s.inference(image_op) predictions_op = layers.predictions(logits_op) predictions_op_prob = tf.nn.softmax(logits_op) init_op = tf.global_variables_initializer() sess.run(init_op) bridge = CvBridge() saver = tf.train.Saver() saver.restore( sess, path + '/tf_models/fcn8s_augment_finetune/' + 'fcn8s_augment.checkpoint-30') # prediction_publisher = rospy.Publisher('/prediction_color', Image, queue_size=1) def predice_image(img_msg):
def run(self, run_type): is_training = True if run_type == 'train' else False self.log('{} epoch: {}'.format(run_type, self.epoch)) image_filenames, label_filenames = self.dataset.load_filenames( run_type) global_step = tf.Variable(1, name='global_step', trainable=False) images, labels = inputs.load_batches(image_filenames, label_filenames, shape=self.dataset.SHAPE, batch_size=self.batch_size, resize_shape=self.dataset.SHAPE, crop_shape=(256, 512), augment=True) with tf.name_scope('labels'): color_labels = util.colorize(labels, self.dataset.augmented_labels) labels = tf.cast(labels, tf.int32) ignore_mask = util.get_ignore_mask(labels, self.dataset.augmented_labels) tf.summary.image('label', color_labels, 1) tf.summary.image('weights', tf.cast(ignore_mask * 255, tf.uint8), 1) tf.summary.image('image', images, 1) logits = self.model.inference(images, num_classes=self.num_classes, is_training=is_training) with tf.name_scope('outputs'): predictions = layers.predictions(logits) color_predictions = util.colorize(predictions, self.dataset.augmented_labels) tf.summary.image('prediction', color_predictions, 1) # Add some metrics with tf.name_scope('metrics'): accuracy_op, accuracy_update_op = tf.contrib.metrics.streaming_accuracy( predictions, labels, weights=ignore_mask) mean_iou_op, mean_iou_update_op = tf.contrib.metrics.streaming_mean_iou( predictions, labels, num_classes=self.num_classes, weights=ignore_mask) if is_training: loss_op = layers.loss(logits, labels, mask=ignore_mask, weight_decay=self.weight_decay) train_op = layers.optimize(loss_op, learning_rate=self.learning_rate, global_step=global_step) # Merge all summaries into summary op summary_op = tf.summary.merge_all() # Create restorer for restoring saver = tf.train.Saver() # Initialize session and local variables (for input pipeline and metrics) sess = tf.Session() sess.run(tf.local_variables_initializer()) if self.checkpoint is None: sess.run(tf.global_variables_initializer()) self.log('{} {} from scratch.'.format(run_type, self.model_name)) else: start_time = time.time() saver.restore(sess, self.checkpoint) duration = time.time() - start_time self.log('{} from previous checkpoint {:s} ({:.2f}s)'.format( run_type, self.checkpoint, duration)) # Create summary writer summary_path = os.path.join(self.model_path, run_type) step_writer = tf.summary.FileWriter(summary_path, sess.graph) # Start filling the input queues coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) num_examples = self.dataset.NUM_TRAIN_EXAMPLES if is_training else self.dataset.NUM_VALID_EXAMPLES for local_step in range(num_examples // self.batch_size): # Take time! start_time = time.time() if is_training: _, loss, accuracy, mean_iou, summary = sess.run([ train_op, loss_op, accuracy_update_op, mean_iou_update_op, summary_op ]) duration = time.time() - start_time self.log('Epoch: {} train step: {} loss: {:.4f} accuracy: {:.2f}% duration: {:.2f}s' \ .format(self.epoch, local_step + 1, loss, accuracy * 100, duration)) else: accuracy, mean_iou, summary = sess.run( [accuracy_update_op, mean_iou_update_op, summary_op]) duration = time.time() - start_time self.log('Epoch: {} eval step: {} accuracy: {:.2f}% duration: {:.2f}s'\ .format(self.epoch, local_step + 1, accuracy * 100, duration)) # Save summary and print stats step_writer.add_summary(summary, global_step=global_step.eval(session=sess)) # Write additional epoch summaries epoch_writer = tf.summary.FileWriter(summary_path) epoch_summaries = [] if is_training: epoch_summaries.append( tf.summary.scalar('params/weight_decay', self.weight_decay)) epoch_summaries.append( tf.summary.scalar('params/learning_rate', self.learning_rate)) epoch_summaries.append( tf.summary.scalar('params/batch_size', self.batch_size)) epoch_summaries.append( tf.summary.scalar('metrics/accuracy', accuracy_op)) epoch_summaries.append( tf.summary.scalar('metrics/mean_iou', mean_iou_op)) epoch_summary_op = tf.summary.merge(epoch_summaries) summary = sess.run(epoch_summary_op) epoch_writer.add_summary(summary, global_step=self.epoch) # Save after each epoch when training if is_training: checkpoint_path = os.path.join(self.model_path, self.model_name + '.checkpoint') start_time = time.time() self.checkpoint = saver.save(sess, checkpoint_path, global_step=self.epoch) duration = time.time() - start_time self.log('Model saved as {:s} ({:.2f}s)'.format( self.checkpoint, duration)) # Stop queue runners and reset the graph coord.request_stop() coord.join(threads) sess.close() tf.reset_default_graph()