def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, save_dir): (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] i = 0 image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT.format( image_names[i].decode("utf-8")), add_colormap=False) save_annotation.save_annotation(crop_semantic_prediction, save_dir, _PREDICTION_FORMAT.format( image_names[i].decode("utf-8")), add_colormap=True, colormap_type=A_colormap_type)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([original_images, semantic_predictions, image_names, image_heights, image_widths]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] # Save image. # save_annotation.save_annotation( # original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), # add_colormap=False) # Save prediction. # print("*"*20) # print(crop_semantic_prediction) # print("*"*20) # save_annotation.save_annotation( # crop_semantic_prediction, save_dir, # _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, # colormap_type=FLAGS.colormap_type) save_annotation.save_annotation_on_original_image([original_image,crop_semantic_prediction], save_dir, _PREDICTION_FORMAT % (image_id_offset + i),FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] input('num_image: %d' % num_image) for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] input('save_dir: %s' % save_dir) # Save image. print(image_names[i].decode("utf-8")) save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT.format( image_names[i].decode("utf-8")), add_colormap=False) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, save_dir, _PREDICTION_FORMAT.format( image_names[i].decode("utf-8")), add_colormap=True, colormap_type=FLAGS.colormap_type)
def predict(self, input_npy, save_path=None): start = time.time() semantic_predictions_value, logits_predictions_value = self.sess.run( [self.semantic_predictions, self.logits], feed_dict={self.image_placeholder: input_npy} ) print("Time needed: {:.2f}s".format(time.time()-start)) if save_path != None: save_annotation.save_annotation(semantic_predictions_value, os.path.dirname(save_path), os.path.splitext(os.path.basename(save_path))[0], add_colormap=False) return semantic_predictions_value, logits_predictions_value
def _process_batch(sess, original_images, resize_images, image_names, mask, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, resize_images, image_names, mask, image_heights, image_widths) = sess.run([ original_images, resize_images, image_names, mask, image_heights, image_widths ]) print(original_images.shape) print(mask.shape) # Save image. save_annotation.save_annotation(resize_images, save_dir, _IMAGE_FORMAT % (image_id_offset), add_colormap=False) # Save prediction. save_annotation.save_annotation(mask, save_dir, _PREDICTION_FORMAT % (image_id_offset), add_colormap=True, colormap_type=FLAGS.colormap_type) write_file( os.path.join(save_dir, _PREDICTION_FORMAT % (image_id_offset) + ".csv"), mask)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([original_images, semantic_predictions, image_names, image_heights, image_widths]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] # Save image. save_annotation.save_annotation( original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, semantic_predictions, instance_predictions, regression_predictions, panoptic_prediction, image_names, image_heights, image_widths, image_id_offset, save_dir, instance_save_dir, instance_seg_save_dir, panoptic_save_dir, instance_offset_save_dir): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. instance_predictions: One batch of instance predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. instance_save_dir : The directory where the instance predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, instance_predictions, regression_predictions, instance_segmentation, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, instance_predictions, regression_predictions, panoptic_prediction, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) instance_predictions = np.squeeze(instance_predictions[i]) regression_predictions = np.squeeze(regression_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] crop_instance_prediction = instance_predictions[:image_height, : image_width] crop_regression_prediction = regression_predictions[:image_height, : image_width, :] instance_segmentation = np.squeeze(instance_segmentation) unique_elements = np.unique(instance_segmentation) instance_segmentation_scaled = np.array(instance_segmentation) * ( 255 // len(unique_elements)) #################### Heatmaps ############################ crop_instance_prediction = np.multiply( crop_instance_prediction / np.amax(crop_instance_prediction), 255) #crop_instance_prediction_mask = np.greater_equal(crop_instance_prediction, 100) crop_instance_prediction_mask = np.greater_equal( crop_instance_prediction, 10) crop_instance_prediction = crop_instance_prediction * crop_instance_prediction_mask mask_single_channel = np.not_equal(crop_instance_prediction, 0) mask_rgb = np.dstack( (mask_single_channel, mask_single_channel, mask_single_channel)) instance_heatmap = cv2.applyColorMap( crop_instance_prediction.astype('uint8'), cv2.COLORMAP_HSV) #instance_heatmap = Image.blend(Image.fromarray(original_image), Image.fromarray(instance_heatmap), 0.2) instance_heatmap = Image.fromarray( np.where(mask_rgb, instance_heatmap, original_image)) ##################### Offset Vectors Prediction ######################### red, green = np.dsplit(crop_regression_prediction, 2) blue = np.zeros_like(red) crop_regression_prediction = np.dstack((red, green, blue)) crop_regression_prediction = np.multiply( np.divide(crop_regression_prediction, np.amax(crop_regression_prediction)), 255) ########## VIS PANOPTIC OUTPUT ################## inst_color = cv2.applyColorMap( instance_segmentation_scaled.astype('uint8'), cv2.COLORMAP_JET) instance_segmentation_coloured = Image.blend( Image.fromarray(original_image), Image.fromarray(inst_color), 0.4) # For Creating boundries around instances # Add boundry to Image colormap_type = FLAGS.colormap_type instance_boundry = np.zeros_like(semantic_prediction) instances = np.delete(unique_elements, 0) for index, i in enumerate(instances): local_instance_mask = instance_segmentation == i kernel = np.ones((5, 5), np.uint8) dilation = cv2.dilate(local_instance_mask.astype('uint8'), kernel, iterations=1) erosion = cv2.erode(local_instance_mask.astype('uint8'), kernel, iterations=1) boundry = (dilation - erosion) * 255 instance_boundry += boundry colored_label = get_dataset_colormap.label_to_color_image( semantic_prediction.astype('uint8'), colormap_type) colored_label = colored_label + np.dstack( (instance_boundry, instance_boundry, instance_boundry)) colored_label = Image.fromarray(colored_label.astype(dtype=np.uint8)) panoptic_output = Image.blend(Image.fromarray(original_image), colored_label, 0.7) # Save image. save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save instance heatmap prediction. save_annotation.save_annotation_heatmaps( instance_heatmap, instance_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), scale_values=False, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save regression prediction. save_annotation.save_annotation_instance_segmentation( instance_segmentation_coloured, instance_seg_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), normalize_values=False, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save prediction. save_annotation.save_annotation_overlayed( crop_semantic_prediction, original_image, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) # Save panoptic prediction. save_annotation.save_annotation_panoptic( panoptic_output, panoptic_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=False, colormap_type=FLAGS.colormap_type) # Save instance_segmentation prediction. save_annotation.save_annotation_offset_vectors( crop_regression_prediction, instance_offset_save_dir, _PREDICTION_FORMAT % (image_id_offset + i))
def _process_batch(sess, original_images, labels, semantic_predictions, image_names, image_heights, image_widths, perf_metrics, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ global perf_all global filename_list (original_images, labels, semantic_predictions, image_names, image_heights, image_widths, m_iou, m_accu, accu ) = sess.run([original_images, labels, semantic_predictions, image_names, image_heights, image_widths, *perf_metrics]) print(m_iou, m_accu, accu) num_image = semantic_predictions.shape[0] for i in range(num_image): name = image_names[i].decode('utf-8') idx = filename_list.index(name) perf_all[idx, 0] = m_iou perf_all[idx, 1] = m_accu perf_all[idx, 2] = accu idx += 1 image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) # label = np.squeeze(labels[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] # Save image. # save_annotation.save_annotation( # original_image, save_dir, _IMAGE_FORMAT % idx, # add_colormap=False) # save_annotation.save_annotation( # label, save_dir, # _LABEL_FORMAT % idx, add_colormap=True, # colormap_type=FLAGS.colormap_type) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % idx, add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = _PREDICTION_FORMAT % idx if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, stacked_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] # Save image. # save_annotation.save_annotation( # original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), # add_colormap=False) image_filename = os.path.splitext(os.path.basename(image_names[i]))[0] # print('image_filename: ', image_filename) stacked_path = os.path.join(stacked_save_dir, image_filename + '.jpg') mask_img = (crop_semantic_prediction * (255.0 / np.max(crop_semantic_prediction))).astype( np.uint8) mask_img = cv2.cvtColor(mask_img, cv2.COLOR_GRAY2BGR) stacked_img = np.concatenate((original_image, mask_img), axis=1) cv2.imwrite(stacked_path, stacked_img) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False) # Save prediction. if FLAGS.also_save_vis_predictions: save_annotation.save_annotation( crop_semantic_prediction, save_dir, image_filename, # _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, logit_save_dir, uncertainty_save_dir, train_id_to_eval_id=None, save_logits=False, logits=None, fixed_features=None, extra_to_run={}, samples_placeholders=None, samples_orig=None, compute_uncertainty=False, num_forward_passes=1): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. Input generator and network are decoupled so that multiple passes through the network can made with the same batch. Useful for MC dropout (computing uncertainty). samples_orig: run this to get a new batch from the input generator samples_placeholders: set the tensor values to data in samples_orig batch. predictions, etc are run with samples_placeholders as the input. To compute uncertainty by only running later layers of network... fixed_features: tensor of fixed features from network which only needs to be computed once extra_to_run[accumulated_softmax, accumulated_softmax_sq]: accumulated softmax from fixed feature logits. Requires samples_placeholders['fixed_features'] to be set. """ #### def softmax(arr): return np.exp(arr) / (np.sum(np.exp(arr), axis=-1)[..., np.newaxis]) #### # Run samples_orig to get samples samples = sess.run([samples_orig])[0] # Map placeholders values to samples feed_dict = { v: samples[k] for k, v in samples_placeholders.items() if k in samples.keys() } # Skip processing if already processed. image_names_ = sess.run([image_names], feed_dict=feed_dict)[0] assert len(image_names_) == 1 image_filename = os.path.basename( image_names_[0]).split('.png')[0].split('.jpg')[0] savename = os.path.join(save_dir, image_filename + ".png") if os.path.exists(savename) and not FLAGS.overwrite_vis: print(" {} exists.".format(savename)) print(">>> SKIPPING <<<<") return # Build tensors run list to_run = [original_images, image_names, image_heights, image_widths] semantic_predictions_idx = None if semantic_predictions is not None: semantic_predictions_idx = len(to_run) to_run.append(semantic_predictions) logits_idx = None if logits is not None: logits_idx = len(to_run) to_run.append(logits) fixed_features_idx = None if fixed_features is not None: fixed_features_idx = len(to_run) to_run.append(fixed_features) run_output = sess.run(to_run, feed_dict=feed_dict) # Gather run outputs original_images = run_output[0] image_names = run_output[1] image_heights = run_output[2] image_widths = run_output[3] if semantic_predictions is not None: semantic_predictions = run_output[semantic_predictions_idx] if logits is not None: logits_i = run_output[logits_idx] if fixed_features is not None: fixed_features = run_output[fixed_features_idx] # pred mean softmax_logits is mu = sum(softmax_logits, axis=newaxis) / num_forward_passes # pred var semantic_pred is sigma = sqrt(1 / (num_forward_passes - 1)) sqrt( # sum(softmax_logits**2, axis=newaxis) # - 2*mu*sum(softmax_logits, axis=newaxis) # + num_forward_passes * mu**2) # sum( (y - mu)^2 ) = sum(y**2) - 2mu*sum(y) + 2*N*mu**2 if compute_uncertainty: if fixed_features is not None: feed_dict = { samples_placeholders['fixed_features']: fixed_features, samples_placeholders['image']: samples['image'], #samples_placeholders['accumulated_softmax']: np.zeros((1,1025, 2049, 19)), #samples_placeholders['accumulated_softmax_sq']: np.zeros((1,1025, 2049, 19)), #samples_placeholders['accumulated_softmax']: np.zeros((1,513, 513, 23)), #samples_placeholders['accumulated_softmax_sq']: np.zeros((1,513, 513, 23)), samples_placeholders['accumulated_softmax']: np.zeros(FLAGS.vis_placeholder_size), samples_placeholders['accumulated_softmax_sq']: np.zeros(FLAGS.vis_placeholder_size), } for i in tqdm.tqdm(range(num_forward_passes)): (accumulated_softmax, accumulated_softmax_sq) = sess.run([ extra_to_run['accumulated_softmax'], extra_to_run['accumulated_softmax_sq'] ], feed_dict=feed_dict) feed_dict[samples_placeholders[ 'accumulated_softmax']] = accumulated_softmax feed_dict[samples_placeholders[ 'accumulated_softmax_sq']] = accumulated_softmax_sq else: assert not save_logits, "Do not save logits when computing uncertainty." assert logits is not None, "Logits are required to compute uncertainty." feed_dict.update({ #samples_placeholders['accumulated_softmax']: np.zeros((1,1025, 2049, 19)), #samples_placeholders['accumulated_softmax_sq']: np.zeros((1,1025, 2049, 19)), #samples_placeholders['accumulated_softmax']: np.zeros((1,513, 513, 23)), #samples_placeholders['accumulated_softmax_sq']: np.zeros((1,513, 513, 23)), samples_placeholders['accumulated_softmax']: np.zeros(FLAGS.vis_placeholder_size), samples_placeholders['accumulated_softmax_sq']: np.zeros(FLAGS.vis_placeholder_size), }) # Run forward passes and compute softmax mean and variances. # TODO: This is numerically unstable. print( ' Accumulating {} forward passes to compute uncertainty...'. format(num_forward_passes)) for i in tqdm.tqdm(range(num_forward_passes)): #start_time_log = time.time() (accumulated_softmax, accumulated_softmax_sq) = sess.run([ extra_to_run['accumulated_softmax'], extra_to_run['accumulated_softmax_sq'] ], feed_dict=feed_dict) feed_dict[samples_placeholders[ 'accumulated_softmax']] = accumulated_softmax feed_dict[samples_placeholders[ 'accumulated_softmax_sq']] = accumulated_softmax_sq #start_time = time.time() pred_mean = 1.0 * accumulated_softmax / num_forward_passes pred_var = accumulated_softmax_sq -\ 2 * pred_mean * accumulated_softmax +\ num_forward_passes * pred_mean**2 pred_var = np.abs( pred_var ) # deal with negative values due to precision error. These values be small (ie 0) pred_var = np.sqrt((1.0 / (num_forward_passes - 1)) * pred_var) #print(' Time elapsed for computing mean and var: {}'.format(time.time() - start_time)) #print(pred_var) # Overwrite semantic_predictions with mean prediction print(' Computing pred_mean_argmax...') start_time = time.time() pred_mean_argmax = np.argmax(pred_mean, axis=-1) #semantic_predictions_orig = semantic_predictions semantic_predictions = pred_mean_argmax #print(np.where(semantic_predictions != semantic_predictions_orig)) #assert np.all(semantic_predictions == semantic_predictions_orig) print(' Time elapsed: {}'.format(time.time() - start_time)) print(' Computing pred_var corresponding to pred_mean_argmax...') start_time = time.time() prediction_variances = np.zeros_like(pred_mean_argmax, dtype=pred_var.dtype) for ii in range(pred_var.shape[0]): for jj in range(pred_var.shape[1]): for kk in range(pred_var.shape[2]): prediction_variances[ii, jj, kk] = pred_var[ii, jj, kk, pred_mean_argmax[ii, jj, kk]] print(' Time elapsed: {}'.format(time.time() - start_time)) assert prediction_variances.shape == semantic_predictions.shape #print(np.max(prediction_variance)) #print(np.min(prediction_variance)) else: if logits is not None: logits = logits_i else: pass ### BELOW IS UNCHANGED. ### num_image = semantic_predictions.shape[0] for i in range(num_image): original_image = np.squeeze(original_images[i]) #image_height = original_image.shape[0] #image_width = original_image.shape[1] image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] image_filename = os.path.basename( image_names[i]).split('.png')[0].split('.jpg')[0] if image_filename == '': # Save image. save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) else: # Save image. save_annotation.save_annotation(original_image, save_dir, image_filename, add_colormap=False) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, save_dir, image_filename + "_vis", add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: #image_filename = os.path.basename(image_names[i]) image_filename = os.path.basename( image_names[i]).split('.png')[0].split('.jpg')[0] if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False) if FLAGS.save_logits: assert logits is not None image_filename = os.path.basename( image_names[i]).split('.png')[0].split('.jpg')[0] #print(type(logits)) #print(logits.shape) #logits = np.array(logits) with tf.gfile.Open('%s/%s.npy' % (logit_save_dir, image_filename), mode='w') as f: np.save(f, logits) if FLAGS.compute_uncertainty: prediction_variances = prediction_variances.astype(np.float16) image_filename = os.path.basename( image_names[i]).split('.png')[0].split('.jpg')[0] prediction_variance = np.squeeze(prediction_variances[i]) crop_prediction_variance = prediction_variance[:image_height, : image_width] with tf.gfile.Open('%s/%s.npy' % (uncertainty_save_dir, image_filename), mode='w') as f: np.save(f, crop_prediction_variance)
def _process_batch(sess, original_images, semantic_predictions, gt_labels, image_names, image_heights, image_widths, image_id_offset, update_op, iou, save_dir, save_dir1, raw_save_dir, raw_save_dir_label, utf, mtf, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, labels, image_names, image_heights, image_widths, confusion_matrix) = sess.run([original_images, semantic_predictions, gt_labels, image_names, image_heights, image_widths, update_op]) mean_iou = sess.run(iou) # print("iou tf: ", m1) # print("confusion matrix tf: ", u1) # print("shape of labels: ", labels.shape) # import pdb; pdb.set_trace() num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) label = np.squeeze(labels[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] crop_gt_label = label[:image_height, :image_width] # Save image. save_annotation.save_annotation( original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) save_annotation.save_annotation( crop_semantic_prediction, save_dir1, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) # Save ground truth. save_annotation.save_annotation( crop_gt_label, save_dir, _GT_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) # label[label==255]=0 # save_annotation.save_annotation( # label, save_dir, # _GT_FORMAT % (image_id_offset + 100), add_colormap=True, # colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False, flag='Y', save_dir_label=raw_save_dir_label) # print("Mean IoU per class: ", mean_iou) miou_class1_back.append(mean_iou[0]) miou_class2_stem.append(mean_iou[1]) miou_class3_cal.append(mean_iou[2]) miou_class4_shoot.append(mean_iou[3]) miou_img = np.nanmean(mean_iou) mean_iou_eval.append(miou_img) print("Mean iou: ", miou_img) print("Confusion Matrix: ", confusion_matrix)
def _process_batch(sess, original_images, semantic_predictions, raw_predictions, logits, exp, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, logits, image_names, image_heights, image_widths) = sess.run([original_images, semantic_predictions, logits, image_names, image_heights, image_widths]) global to_output_logits_sihl global to_output_logits_stmoritz global to_output_logits_sils global to_output_logits_silvaplana num_image = semantic_predictions.shape[0] logits = logits[common.OUTPUT_TYPE] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] logits = np.squeeze(logits[i]) crop_logits = logits[:image_height, :image_width] #plt.imsave(save_dir+"/{}_prob.png".format(image_names[i]), _crop_logits, cmap="seismic") #logits_0 = crop_logits[:,:,0] #logits_1 = crop_logits[:,:,1] #logits_2 = crop_logits[:,:,2] #logits_0 = logits_0[(labels == 1) | (labels == 2)] #logits_1 = logits_1[(labels == 1) | (labels == 2)] #logits_2 = logits_2[(labels == 1) | (labels == 2)] #labels = labels[(labels == 1) | (labels == 2)] #n_logits_0, n_logits_1, n_logits_2 = softmax([logits_0, logits_1, logits_2]) #plt.imsave(save_dir+"/{}_prob0.png".format(image_names[i]),1-logits_0, cmap="seismic") #plt.imsave(save_dir+"/{}_prob1.png".format(image_names[i]),logits_1, cmap="seismic") #plt.imsave(save_dir+"/{}_prob2.png".format(image_names[i]),logits_2, cmap="seismic") if "sils" in image_names[i]: to_output_logits_sils.append([crop_logits, crop_semantic_prediction, image_names[i]]) elif "stmoritz" in image_names[i]: to_output_logits_stmoritz.append([crop_logits, crop_semantic_prediction, image_names[i]]) elif "silvaplana" in image_names[i]: to_output_logits_silvaplana.append([crop_logits, crop_semantic_prediction, image_names[i]]) elif "sihl" in image_names[i]: to_output_logits_sihl.append([crop_logits, crop_semantic_prediction, image_names[i]]) #np.save("deeplab/datasets/sar_ice/exp_{}/logits/{}".format(exp,image_names[i]), crop_logits) # np.save("deeplab/pr_curve/logits_sils", crop_logits) #if "stmoritz" in image_names[i]: # np.save("deeplab/pr_curve/logits_stmoritz", crop_logits) #if "silvaplana" in image_names[i]: # np.save("deeplab/pr_curve/logits_silvplana", crop_logits) # Save image. # Save image. save_annotation.save_annotation( original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, image_names[i], add_colormap=True, colormap_type=FLAGS.colormap_type) # _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, # colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, slide_mask, original_images, semantic_predictions, image_names, mask_size, downsample, image_heights, image_widths, image_id_offset, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. mask_size: [x,y] dimentions of the mask image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] image_filename = image_names[i].decode() # populate wsi mask Ystart = float(image_filename.split('-')[-2]) Ystart /= downsample Ystart = int(round(Ystart)) Xstart = float(image_filename.split('-')[-3]) Xstart /= downsample Xstart = int(round(Xstart)) Xstop = min(Xstart + image_width, mask_size[0]) Ystop = min(Ystart + image_height, mask_size[1]) slide_mask[Ystart:Ystop, Xstart:Xstop] = np.maximum( slide_mask[Ystart:Ystop, Xstart:Xstop], semantic_prediction[:Ystop - Ystart, :Xstop - Xstart]) if FLAGS.also_save_raw_predictions: # # Save image. # save_annotation.save_annotation( # original_image, raw_save_dir, _IMAGE_FORMAT % (image_id_offset + i), # add_colormap=False) # # # Save prediction. # save_annotation.save_annotation( # crop_semantic_prediction, raw_save_dir, # _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, # colormap_type=FLAGS.colormap_type) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False) return slide_mask
model_ts = int(sys.argv[1]) model_name = 'model-pc-%d' % model_ts root_dir = join('E:', 'lerner', 'deeplab', 'cache_data', model_name, 'vis') src_dir = join(root_dir, 'segmentation_results') dst_dir = join(root_dir, 'segmentation_results_masked') gt_mask_dir = join('D:', 'datasets', 'processed', 'pascalcontext', 'truth-', 'val') if not os.path.exists(dst_dir): os.mkdir(dst_dir) for f in os.listdir(src_dir): if 'image' in f: os.rename(join(src_dir, f), join(dst_dir, f)) continue idx = 1 + int(f[:f.index('_')]) pred = np.array(Image.open(join(src_dir, f)).convert('L')) with h5py.File(join(gt_mask_dir, 'val_%06d_pixeltruth.mat' % idx)) as mat: gt = mat['truth_img'][:].T pred[gt == 0] = 0 #im = Image.fromarray(pred).convert('RGB') #im.save(join(dst_dir, f)) save_annotation.save_annotation(pred, dst_dir, f)
def _process_batch(sess, original_images, semantic_predictions, instance_predictions, regression_predictions, panoptic_prediction, image_names, image_heights, image_widths, image_id_offset, save_dir, instance_save_dir, regression_save_dir, panoptic_save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. instance_predictions: One batch of instance predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. instance_save_dir : The directory where the instance predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, instance_predictions, regression_predictions, instance_segmentation, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, instance_predictions, regression_predictions, panoptic_prediction, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) instance_predictions = np.squeeze(instance_predictions[i]) regression_predictions = np.squeeze(regression_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] crop_instance_prediction = instance_predictions[:image_height, : image_width] crop_regression_prediction = regression_predictions[:image_height, : image_width, :] instance_segmentation = np.squeeze(instance_segmentation) unique_elements = np.unique(instance_segmentation) instance_segmentation_scaled = np.array(instance_segmentation) * ( 255 // len(unique_elements)) ########## VIS INSTANCE SEG OUTPUT ################## inst_color = cv2.applyColorMap( instance_segmentation_scaled.astype('uint8'), cv2.COLORMAP_JET) instance_segmentation_coloured = Image.blend( Image.fromarray(original_image), Image.fromarray(inst_color), 0.4) ###################################################### # For Creating boundries around instances # Add boundry to Image colormap_type = FLAGS.colormap_type instance_boundry = np.zeros_like(semantic_prediction) instances = np.delete(unique_elements, 0) for index, i in enumerate(instances): local_instance_mask = instance_segmentation == i kernel = np.ones((5, 5), np.uint8) dilation = cv2.dilate(local_instance_mask.astype('uint8'), kernel, iterations=1) erosion = cv2.erode(local_instance_mask.astype('uint8'), kernel, iterations=1) boundry = (dilation - erosion) * 255 instance_boundry += boundry colored_label = get_dataset_colormap.label_to_color_image( semantic_prediction.astype('uint8'), colormap_type) colored_label = colored_label + np.dstack( (instance_boundry, instance_boundry, instance_boundry)) colored_label = Image.fromarray(colored_label.astype(dtype=np.uint8)) panoptic_output = Image.blend(Image.fromarray(original_image), colored_label, 0.7) ###################################################################################### # Save image. save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save instance heatmap prediction. save_annotation.save_annotation(crop_instance_prediction, instance_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), scale_values=True, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save regression prediction. save_annotation.save_annotation_instance_regression( instance_segmentation_coloured, regression_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), normalize_values=True, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) # Save panoptic prediction. save_annotation.save_annotation_panoptic( panoptic_output, panoptic_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=False, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) tf.gfile.MakeDirs(FLAGS.inference_dir) elapsed_time = 0 g = load_graph() with g.as_default(), tf.device("/cpu:0"): if FLAGS.print_flops: opts = tf.profiler.ProfileOptionBuilder.float_operation() flops = tf.profiler.profile(g, options=opts) if flops is not None: print 'Total flops: ', flops.total_float_ops image_name = FLAGS.image_path.split('/')[-1] image_name, image_extension = image_name.split('.') supported_extensions = ['png', 'jpeg', 'jpg'] if not any(image_extension == extension for extension in supported_extensions): raise ValueError('Image extension "{}" not supported...'.format( image_extension)) image = cv2.imread(FLAGS.image_path) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) original_image_dimensions = image.shape[0:2] image = cv2.resize(image, tuple(reversed(FLAGS.inference_crop_size))) image = np.expand_dims(image, 0) input_operation = g.get_operation_by_name('import/' + _INPUT_OP) output_operation = g.get_operation_by_name('import/' + _OUTPUT_OP) with tf.Session(graph=g) as sess: semantic_predictions = None if FLAGS.avg_inf_time: for i in range(20): start_time = timeit.default_timer() semantic_predictions = sess.run( output_operation.outputs[0], feed_dict={input_operation.outputs[0]: image}) elapsed_time += timeit.default_timer() - start_time elapsed_time = np.round(elapsed_time / 20, 4) else: start_time = timeit.default_timer() semantic_predictions = sess.run( output_operation.outputs[0], feed_dict={input_operation.outputs[0]: image}) elapsed_time = timeit.default_timer() - start_time print 'Inference time : {} s'.format(elapsed_time) result = np.array(semantic_predictions, dtype=np.uint8) result = np.squeeze(result) result = cv2.resize(result, tuple(reversed(original_image_dimensions))) # save raw result... save_annotation.save_annotation(result, FLAGS.inference_dir, _RAW_FORMAT % image_name, add_colormap=False) # save result as color image... save_annotation.save_annotation(result, FLAGS.inference_dir, _PREDICTION_FORMAT % image_name, add_colormap=True, colormap_type=FLAGS.dataset) return elapsed_time
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ img_save_dir, color_save_dir, raw_save_dir = my_func() (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] image_filename = os.path.basename(image_names[i]).decode("utf-8") # Save image. save_annotation.save_annotation(original_image, img_save_dir, image_filename, add_colormap=False) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, color_save_dir, image_filename, add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, semantic_predictions, instance_predictions, regression_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, instance_save_dir, regression_save_dir, panoptic_save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. instance_predictions: One batch of instance predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. instance_save_dir : The directory where the instance predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ (original_images, semantic_predictions, instance_predictions, regression_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, instance_predictions, regression_predictions, image_names, image_heights, image_widths ]) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) instance_predictions = np.squeeze(instance_predictions[i]) regression_predictions = np.squeeze(regression_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] crop_instance_prediction = instance_predictions[:image_height, : image_width] crop_regression_prediction = regression_predictions[:image_height, : image_width, :] '''if len(crop_regression_prediction.shape) == 3 and crop_regression_prediction.shape[2] == 2: red, green = np.dsplit(crop_regression_prediction, 3) blue = np.zeros_like(green) crop_regression_prediction = np.concatenate((red, green, blue), axis=2) else: raise ValueError('Input label y offset shape must be [height, width, 2].') #crop_regression_prediction = regression_predictions[:image_height, :image_width]''' panoptic_prediction = process_panoptic_output( original_image, crop_semantic_prediction, crop_instance_prediction, crop_regression_prediction, colormap_type=FLAGS.colormap_type) # Save image. save_annotation.save_annotation(original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save instance heatmap prediction. save_annotation.save_annotation(crop_instance_prediction, instance_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), scale_values=True, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save regression prediction. save_annotation.save_annotation_instance_regression( crop_regression_prediction, regression_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), normalize_values=True, add_colormap=False, colormap_type=FLAGS.colormap_type) # Save prediction. save_annotation.save_annotation(crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) # Save panoptic prediction. save_annotation.save_annotation_panoptic( panoptic_prediction, panoptic_save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=False, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, semantic_predictions, image_names, image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None, text_file=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ # run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) # run_metadata = tf.RunMetadata() t = TicToc() t.tic() (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([ original_images, semantic_predictions, image_names, image_heights, image_widths ]) # , options=run_options, run_metadata=run_metadata) # tl = timeline.Timeline(run_metadata.step_stats) # ctf = tl.generate_chrome_trace_format() # with open('/home/zhaopeng/Muyan/custom/vis_dir/segmentation_resultsmobilenet_v2/timeline'+str(batch_num)+'.json','w') as f: # f.write(ctf) tElapse = t.tocvalue() text_file.write("Testing image %s\n" % image_names[0]) text_file.write(" %f\n" % tElapse) num_image = semantic_predictions.shape[0] for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) # original_image = np.squeeze(original_images[i]) semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, : image_width] image_filename = os.path.basename(image_names[i]) image_name = image_filename.decode("utf-8") # Save image. # save_annotation.save_annotation( # original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), # add_colormap=False) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, image_name[:len(image_name) - 4], # _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation(crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def _process_batch(sess, original_images, labels, mybatch_num, semantic_predictions, image_names, #pang-add image_heights, image_widths, image_id_offset, save_dir, raw_save_dir, train_id_to_eval_id=None): """Evaluates one single batch qualitatively. Args: sess: TensorFlow session. original_images: One batch of original images. semantic_predictions: One batch of semantic segmentation predictions. image_names: Image names. image_heights: Image heights. image_widths: Image widths. image_id_offset: Image id offset for indexing images. save_dir: The directory where the predictions will be saved. raw_save_dir: The directory where the raw predictions will be saved. train_id_to_eval_id: A list mapping from train id to eval id. """ ''' (original_images, semantic_predictions, image_names, image_heights, image_widths) = sess.run([original_images, semantic_predictions, image_names, image_heights, image_widths]) ''' (original_images, labels, #pang-add semantic_predictions, image_names, image_heights, image_widths) = sess.run([original_images, labels, semantic_predictions, image_names, image_heights, image_widths]) num_image = semantic_predictions.shape[0] #print(num_image) #pang-add #print('pangllalalallalallalalallalaql----------------------------------') for i in range(num_image): image_height = np.squeeze(image_heights[i]) image_width = np.squeeze(image_widths[i]) original_image = np.squeeze(original_images[i]) label = np.squeeze(labels[i]) #pang-add semantic_prediction = np.squeeze(semantic_predictions[i]) crop_semantic_prediction = semantic_prediction[:image_height, :image_width] #print(type(crop_semantic_prediction)) #pang-add #print(type(label)) pang_prediction = crop_semantic_prediction pang_label = label im_pang_prediction = Image.fromarray(pang_prediction.astype(dtype=np.uint8)) #print(type(im_pang_prediction)) my_str_path_label = '/home/pzn/dataset/result_pre_label_new/'+str(mybatch_num)+'_my_label.png' my_str_path_predict = '/home/pzn/dataset/result_pre_label_new/'+str(mybatch_num)+'_my_predict.png' #print(my_str_path_label) #print(my_str_path_predict) im_pang_prediction.save(my_str_path_label, 'PNG') im_pang_label = Image.fromarray(pang_label.astype(dtype=np.uint8)) #print(type(im_pang_label)) im_pang_label.save(my_str_path_predict, 'PNG') #print('------------lalalalallalal---------------------') #pang-add #print(type(original_image)) # Save image. save_annotation.save_annotation( original_image, save_dir, _IMAGE_FORMAT % (image_id_offset + i), add_colormap=False) # Save image_label. #pang-add save_annotation.save_annotation( label, save_dir, _IMAGE_FORMAT_LABEL % (image_id_offset + i), add_colormap=False) # Save prediction. save_annotation.save_annotation( crop_semantic_prediction, save_dir, _PREDICTION_FORMAT % (image_id_offset + i), add_colormap=True, colormap_type=FLAGS.colormap_type) if FLAGS.also_save_raw_predictions: image_filename = os.path.basename(image_names[i]) if train_id_to_eval_id is not None: crop_semantic_prediction = _convert_train_id_to_eval_id( crop_semantic_prediction, train_id_to_eval_id) save_annotation.save_annotation( crop_semantic_prediction, raw_save_dir, image_filename, add_colormap=False)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) tf.gfile.MakeDirs(FLAGS.inference_dir) g = tf.Graph() with g.as_default(): image_name = FLAGS.image_path.split('/')[-1] image_name, image_extension = image_name.split('.') supported_extensions = ['png', 'jpeg', 'jpg'] if not any(image_extension == extension for extension in supported_extensions): raise ValueError('Image extension "{}" not supported...'.format( image_extension)) reader = build_data.ImageReader(image_extension) image = reader.decode_image( tf.gfile.FastGFile(FLAGS.image_path, 'r').read()) image = tf.identity(image) original_image_dimensions = image.get_shape().as_list()[0:2] original_image_dimensions = reversed(original_image_dimensions) image = tf.image.resize_images(image, [480, 640], method=tf.image.ResizeMethod.BILINEAR, align_corners=True) image.set_shape([None, None, 3]) image = tf.expand_dims(image, 0) model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: FLAGS.num_classes}, crop_size=FLAGS.inference_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) predictions = model.predict_labels(image, model_options=model_options, image_pyramid=None) predictions = predictions[common.OUTPUT_TYPE] # predictions = tf.image.resize_images( # predictions, original_image_dimensions, # method=tf.image.ResizeMethod.BILINEAR, # align_corners=True) param_stats = tf.profiler.profile( tf.get_default_graph(), options=tf.profiler.ProfileOptionBuilder. trainable_variables_parameter()) print('Total parameters: ', param_stats.total_parameters) total_parameters = 0 for variable in tf.trainable_variables(): shape = variable.get_shape() variable_parameters = 1 for dim in shape: variable_parameters *= dim.value total_parameters += variable_parameters print('Total parameters: ', total_parameters) tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.inference_dir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) with sv.managed_session(start_standard_services=False) as sess: sv.start_queue_runners(sess) sv.saver.restore(sess, FLAGS.checkpoint_path) semantic_predictions = sess.run(predictions) result = np.array(semantic_predictions, dtype=np.uint8) result = np.squeeze(result) result = cv2.resize(result, tuple(original_image_dimensions)) # save raw result... save_annotation.save_annotation(result, FLAGS.inference_dir, _RAW_FORMAT % image_name, add_colormap=False) # save result as color image... save_annotation.save_annotation(result, FLAGS.inference_dir, _PREDICTION_FORMAT % image_name, add_colormap=True, colormap_type=FLAGS.dataset)