def DEBUG_core(sess): logging.info('#-----------------------------------------------#') logging.info('# Start Debugging #') logging.info('#-----------------------------------------------#') args.test_dir = filesys.find_or_create_test_dir(args.test_dir, args.train_dir, opts=opts_test) batch_img, batch_label, batch_weights = data_layers.data_HDF5( opts_train.dataset, opts_train.shape_img, opts_train.shape_label, opts_train.shape_weights, shuffle=False, batch_size=opts.batch_size, prefetch_threads=12, prefetch_n=40, resample_n=40, augment=True) resize = opts_train.resize if opts_train.resize is not None: if opts_train.resize_method == "scale": batch_img = tf.image.resize_images(batch_img, resize) batch_label = tf.image.resize_images(batch_label, resize) batch_label = tf.cast(batch_label, tf.uint8) # is changed by resize batch_weights = tf.image.resize_images(batch_weights, resize) elif opts_train.resize_method == "center_crop": batch_img = tf.map_fn(lambda img: tf.image.central_crop(img, 0.5), batch_img, parallel_iterations=8, name="center_crop") batch_label = tf.map_fn( lambda img: tf.image.central_crop(img, 0.5), batch_label, parallel_iterations=8, name="center_crop") batch_weights = tf.map_fn( lambda img: tf.image.central_crop(img, 0.5), batch_weights, parallel_iterations=8, name="center_crop") else: random_seed = 42 # tf.random_uniform(1, minval=0, maxval=65536, dtype=tf.int16) batch_img = tf.random_crop(batch_img, [ batch_img.get_shape().as_list()[0], resize[0], resize[1], batch_img.get_shape().as_list()[3] ], seed=random_seed) batch_label = tf.random_crop(batch_label, [ batch_label.get_shape().as_list()[0], resize[0], resize[1], batch_label.get_shape().as_list()[3] ], seed=random_seed) batch_weights = tf.random_crop(batch_weights, [ batch_weights.get_shape().as_list()[0], resize[0], resize[1], batch_weights.get_shape().as_list()[3] ], seed=random_seed) for bb in range(opts_test.n_samples): r_batch_img = [] for b in range(8): start = timer() e_batch_img, e_batch_label, e_batch_weights = sess.run( [batch_img, batch_label, batch_weights]) end = timer() print("got batch in %.4f s : img %s %s" % ( (end - start), str(e_batch_img.shape), str(e_batch_img.dtype))) r_batch_img.append( np.reshape(e_batch_img, [-1, e_batch_img.shape[2], e_batch_img.shape[3]])) print("stitching and creating file") out_img = np.concatenate( [img_util.to_rgb(batch) for batch in r_batch_img], axis=1) img_util.save_image(out_img, "%s/img_aug_%s.jpg" % (args.test_dir, str(bb)))
def test_debug_sampling(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing with sampling #') logging.info('#-----------------------------------------------#') # load model for testing (if None provided, searches in train_dir, if not found doesn't load) trainer = SimpleTrainer(session=sess, train_dir=args.train_dir) chkpt_loaded = trainer.load_checkpoint(args.checkpoint) args.test_dir = filesys.find_or_create_test_dir(args.test_dir, args.train_dir) # add uncertainty op if supported (network trained with aleatoric loss) if opts_test.aleatoric_sample_n is not None and opts_test.aleatoric_sample_n > 0: # get uncertainty (entropy) and sampled, softmaxed output mask net_batch_uncertainty, net_batch_softmax = uncertainty.aleatoric_entropy( net_test.output_mask, net_test.sigma_activations, opts_test.aleatoric_sample_n) # create prediction from sampled, softmaxed output mask net_batch_prediction = tf.argmax(tf.nn.softmax(net_batch_softmax), axis=-1, output_type=tf.int32) else: # add softmax op, default net prediction and dummy uncertainty net_batch_softmax = tf.nn.softmax(net_test.output_mask) net_batch_prediction = net_test.prediction # for default net w/o aleatoric loss no uncertainty is defined. Can be generated with dropout (resample_n) net_batch_uncertainty = tf.constant(0, shape=list( net_batch_softmax.shape)[0:3]) # ########################################################################### # RUN UNET # ########################################################################### logging.debug("predicting: n_samples %s, resample_n %s, batch_size %s" % (str(opts_test.n_samples), str( opts_test.resample_n), str(opts_test.batch_size))) # create folder to store samples in if opts_test.resample_n is not None: sample_dir = args.test_dir + os.sep + 'samples' os.mkdir(sample_dir) for b in range(opts_test.n_samples): # GENERATE RESULTS # ---------------- try: # standard run (or first run if resampling, to get batch_img and batch_label once) logging.debug("run ...") batch_img, batch_label, batch_softmax, batch_prediction, batch_uncertainty \ = sess.run([net_test.batch_img, net_test.batch_label, net_batch_softmax, net_batch_prediction, net_batch_uncertainty]) # if resampling, create store to sample into if opts_test.resample_n is not None: r_batch_pred = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) # init prediction_sample store prediction_samples = np.zeros([opts_test.resample_n] + list(r_batch_pred.shape), dtype=np.uint8) # store prediction for averaging prediction_samples[0, ...] = r_batch_pred if opts_test.aleatoric_sample_n is not None: r_batch_uncertainty = np.reshape( batch_uncertainty, [-1, batch_uncertainty.shape[2]]) # init prediction_sample store uncertainty_samples = np.zeros( [opts_test.aleatoric_sample_n] + list(r_batch_uncertainty.shape), dtype=np.float32) # store uncertainty for averaging (comes as [batch_size x y]) uncertainty_samples[0, ...] = r_batch_uncertainty # start sampling (-1 because one run was already done) for s in range(1, opts_test.resample_n): batch_softmax, batch_prediction, batch_uncertainty \ = sess.run([net_batch_softmax, net_test.prediction, net_batch_uncertainty]) # store prediction r_batch_pred = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) prediction_samples[s, ...] = r_batch_pred # save sample images to sample folder out_sample = img_util.to_rgb(prediction_samples[s, ...]) img_util.save_image( out_sample, "%s/sample_%s_%s_pred.png" % (sample_dir, b, s)) if opts_test.aleatoric_sample_n is not None: # store uncertainty r_batch_uncertainty = np.reshape( batch_uncertainty, [-1, batch_uncertainty.shape[2]]) uncertainty_samples[s, ...] = r_batch_uncertainty # save sample images to sample folder out_sample = img_util.to_rgb(uncertainty_samples[s, ...]) img_util.save_image( out_sample, "%s/sample_%s_%s_unc.png" % (sample_dir, b, s)) except tf.errors.OutOfRangeError: break # PROCESS RESULTS # --------------- # reshape so that batch_size is merged into x dimension (images are concatenated along x dim) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_softmax = np.reshape( batch_softmax, [-1, batch_softmax.shape[2], batch_softmax.shape[3]]) # if resampling, create pred and uncertainty from samples if opts_test.resample_n is not None: # create mean of samples and save as r_batch_prediction logging.info('resampled pred (%s), averaging for pred' % (str(opts_test.resample_n))) r_batch_prediction = np.mean(prediction_samples, axis=0) #std_deviation = np.std(prediction_samples, axis=0) if opts_test.aleatoric_sample_n is not None: #uncertainty_samples = uncertainty_samples[..., np.newaxis] # create mean of samples and save as r_batch_uncertainty logging.info( 'calculating combined entropy from %s aleatoric samples' % (str(opts_test.aleatoric_sample_n))) # create r_batch_uncertainty = -np.sum( uncertainty_samples * np.nan_to_num(np.log(uncertainty_samples)), axis=0) #r_batch_uncertainty = r_batch_uncertainty r_batch_uncertainty /= np.max(r_batch_uncertainty) else: logging.info( 'calculating epistemic entropy from %s pred samples' % (str(opts_test.resample_n))) # compute epistemic uncertainty and overwrite (empty) network output uncertainty #TODO entropy with softmax? but which class? r_batch_uncertainty = calc.entropy_bin_array( prediction_samples) else: r_batch_prediction = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) # append axis for easier processing in MATLAB (same rank as softmax) batch_uncertainty = batch_uncertainty[..., np.newaxis] r_batch_uncertainty = np.reshape( batch_uncertainty, [-1, batch_uncertainty.shape[2], batch_uncertainty.shape[3]]) # WRITE RESULTS # ------------- logging.debug('writing tile-file: %s/tile_%s.mat' % (args.test_dir, b)) logging.debug(' softmax_activations: %s %s' % (str(r_batch_softmax.shape), str(r_batch_softmax.dtype))) logging.debug( ' prediction: %s %s' % (str(r_batch_prediction.shape), str(r_batch_prediction.dtype))) logging.debug(' img: %s %s' % (str(r_batch_img.shape), str(r_batch_img.dtype))) logging.debug(' label: %s %s' % (str(r_batch_label.shape), str(r_batch_label.dtype))) logging.debug( ' uncertainty: %s %s' % (str(r_batch_uncertainty.shape), str(r_batch_uncertainty.dtype))) # write matlab arrays scipy.io.savemat("%s/tile_%02d.mat" % (args.test_dir, b), mdict={ 'tile': r_batch_img, 'label': r_batch_label, 'pred': r_batch_prediction, 'softmax': r_batch_softmax, 'uncertainty': r_batch_uncertainty }) # summary out_img = np.concatenate( ( np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), #np.squeeze(img_util.to_rgb(r_batch_softmax[..., 0, np.newaxis], normalize=True)), np.squeeze( img_util.to_rgb(r_batch_softmax[..., 1, np.newaxis], normalize=True)), np.squeeze(img_util.to_rgb(r_batch_prediction[..., np.newaxis])), np.squeeze( img_util.to_rgb(r_batch_uncertainty[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/tile_%02d_summary.png" % (args.test_dir, b))
def test_metrics(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing (metrics) #') logging.info('#-----------------------------------------------#') # load model for testing (if None provided, searches in train_dir, if not found doesn't load) logging.info("Attempt restore with SimpleTrainer load from: %s" % args.checkpoint) # load model for continued training (if None provided, searches in train_dir, if not found doesn't load) trainer = SimpleTrainer(session=sess, train_dir=args.train_dir) chkpt_loaded = trainer.load_checkpoint(args.checkpoint) # init variables if no checkpoint was loaded if not chkpt_loaded: sess.run(tf.group(tf.global_variables_initializer())) logging.info("Loaded variables from checkpoint" if chkpt_loaded else "Randomly initialized (!) variables") # create test op and initialize associated variables test_op = net_test.test_op() tf_helpers.initialize_uninitialized(sess, vars=tf.global_variables()) tf_helpers.initialize_uninitialized(sess, vars=tf.local_variables()) # ########################################################################### # RUN UNET # ########################################################################### logging.debug("predicting, sampling %s times, batch_size %s" % (opts_test.n_samples, opts_test.batch_size)) [c_accuracy, c_precision, c_recall, c_accuracy_per_class, c_mean_iou] = [(0, 0), (0, 0), (0, 0), 0, 0] [global_step] = sess.run([net_test.global_step]) args.test_dir = filesys.find_or_create_test_dir(args.test_dir, args.train_dir, global_step=global_step) for b in range(opts_test.n_samples): try: test_op_results = sess.run(test_op) except tf.errors.OutOfRangeError: break [ batch_img, batch_label, batch_weights, batch_activations, batch_softmax, batch_prediction, accuracy, precision, recall, accuracy_per_class, mean_iou ] = test_op_results [c_accuracy, c_precision, c_recall, c_accuracy_per_class, c_mean_iou] = \ [[sum(x) for x in zip(accuracy,c_accuracy)], [sum(x) for x in zip(precision, c_precision)], [sum(x) for x in zip(recall, c_recall)], c_accuracy_per_class + accuracy_per_class[0], c_mean_iou + mean_iou[0]] # out_img = np.squeeze(img_util.to_rgb(batch_activations)) # img_util.save_image(out_img, "%s/img_%s_pred.png" % (args.test_dir, b)) # logging.debug('\naccuracy: %s, prec: %s, rec: %s \naccuracy_per_class %s, \nmean_iou %s' % # (str(accuracy), str(precision), str(recall), # str(accuracy_per_class), str(mean_iou))) #logging.debug('batch_activations: %s %s' % (str(batch_activations.shape), str(batch_activations.dtype))) #logging.debug('batch_prediction: %s %s' % (str(batch_prediction.shape), str(batch_prediction.dtype))) #logging.debug('batch_img: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) #logging.debug('batch_label: %s %s' % (str(batch_label.shape), str(batch_label.dtype))) # logging.debug('describe prediction_samples: ' + str(stats.describe(batch_activations))) # logging.debug('describe prediction_samples[0]: ' + str(stats.describe(prediction_samples[0]))) # out_img = img_util.combine_img_prediction(batch_img, batch_label, batch_activations) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_activations = np.reshape( batch_activations, [-1, batch_activations.shape[2], batch_activations.shape[3]]) r_batch_prediction = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) # r_batch_softmax = calc.softmax(r_batch_activations, axis=-1) # slow argmax = np.argmax(r_batch_activations, axis=-1) # just take direct max out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 0, np.newaxis], normalize=False)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 1, np.newaxis], normalize=False)), np.squeeze(img_util.to_rgb(argmax[..., np.newaxis])), np.squeeze(img_util.to_rgb(r_batch_prediction[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.test_dir, b)) # ########################################################################### # CLOSE NET # ########################################################################### c_accuracy = tuple(x / opts_test.n_samples for x in c_accuracy) c_precision = tuple(x / opts_test.n_samples for x in c_precision) c_recall = tuple(x / opts_test.n_samples for x in c_recall) c_accuracy_per_class = c_accuracy_per_class / opts_test.n_samples c_mean_iou = c_mean_iou / opts_test.n_samples logging.debug( '\naccuracy: %s, prec: %s, rec: %s \naccuracy_per_class %s, \nmean_iou %s' % (str(c_accuracy), str(c_precision), str(c_recall), str(c_accuracy_per_class), str(c_mean_iou)))
def val_sample_fn(self): """ does opts_val.n_samples forward passes and writes images """ opts_val = self.opts_val val_dir = self.val_dir sess = self.sess if opts_val is not None and opts_val.val_sample_intervall is not None: logging.info('#----------------------------#') logging.info('# Sampling over Valset #') logging.info("# %s samples, to %s" % (opts_val.n_samples, val_dir)) global_step_value = self.sess.run(self.global_step) # not needed: # self.val_summary_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step=global_step_value) for b in range(opts_val.n_samples): try: # run session with feed_dict to switch datalayer batch_img, batch_label, batch_activations, batch_prediction, \ val_summary = \ sess.run( [self.batch_img, self.batch_label, self.output_mask, self.prediction, self.merged_summary], feed_dict = {self.use_train_data : False} ) except tf.errors.OutOfRangeError: break # add summaries self.val_summary_writer.add_summary(val_summary, global_step_value) self.val_summary_writer.flush() if val_dir is not None: r_batch_img = np.reshape( batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_activations = np.reshape(batch_activations, [ -1, batch_activations.shape[2], batch_activations.shape[3] ]) r_batch_prediction = np.reshape( batch_prediction, [-1, batch_prediction.shape[2]]) out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 0, np.newaxis], normalize=True)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 1, np.newaxis], normalize=True)), np.squeeze( img_util.to_rgb(r_batch_prediction[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (val_dir, b)) logging.info('# #') logging.info('#-X--------------------------#') pass
def test_debug(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing (debug) #') logging.info('#-----------------------------------------------#') # load model for testing (if None provided, searches in train_dir, if not found doesn't load) trainer = SimpleTrainer(session=sess, train_dir=args.train_dir) chkpt_loaded = trainer.load_checkpoint(args.checkpoint) # init variables if no checkpoint was loaded if not chkpt_loaded: sess.run(tf.group(tf.global_variables_initializer())) logging.info("Loaded variables from checkpoint" if chkpt_loaded else "Randomly initialized (!) variables") # add softmax op net_batch_softmax = tf.nn.softmax(net_test.output_mask) # add uncertainty op if supported (network trained with aleatoric loss) if opts_test.aleatoric_sample_n is not None and opts_test.aleatoric_sample_n > 0: net_batch_uncertainty = uncertainty.aleatoric_entropy( net_test.output_mask, net_test.sigma_activations, opts_test.aleatoric_sample_n) else: net_batch_uncertainty = \ tf.constant(0, shape = [opts_test.batch_size, opts_test.shape_label[0], opts_test.shape_label[1]]) # ########################################################################### # RUN UNET # ########################################################################### logging.debug("predicting, sampling %s times, batch_size %s" % (opts_test.n_samples, opts_test.batch_size)) for b in range(opts_test.n_samples): try: logging.debug("run ...") batch_img, batch_label, batch_softmax, batch_prediction, batch_uncertainty \ = sess.run( [net_test.batch_img, net_test.batch_label, net_batch_softmax, net_test.prediction, net_batch_uncertainty ]) except tf.errors.OutOfRangeError: break logging.debug("... success") # reshape so that batch_size is merged into x dimension (images are concatenated along x dim) #logging.debug(' uncertainty: %s %s' % (str(batch_uncertainty.shape), str(batch_uncertainty.dtype))) batch_uncertainty = batch_uncertainty[..., np.newaxis] r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_softmax = np.reshape( batch_softmax, [-1, batch_softmax.shape[2], batch_softmax.shape[3]]) r_batch_prediction = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) r_batch_uncertainty = np.reshape( batch_uncertainty, [-1, batch_uncertainty.shape[2], batch_uncertainty.shape[3]]) import scipy.io # matlab arrays scipy.io.savemat("%s/tile_%02d.mat" % (args.test_dir, b), mdict={ 'tile': r_batch_img, 'label': r_batch_label, 'pred': r_batch_prediction, 'softmax': r_batch_softmax, 'uncertainty': r_batch_uncertainty }) logging.debug('writing tile-file: %s/tile_%s.mat' % (args.test_dir, b)) logging.debug(' softmax_activations: %s %s' % (str(r_batch_softmax.shape), str(r_batch_softmax.dtype))) logging.debug( ' prediction: %s %s' % (str(r_batch_prediction.shape), str(r_batch_prediction.dtype))) logging.debug(' img: %s %s' % (str(r_batch_img.shape), str(r_batch_img.dtype))) logging.debug(' label: %s %s' % (str(r_batch_label.shape), str(r_batch_label.dtype))) logging.debug( ' uncertainty: %s %s' % (str(r_batch_uncertainty.shape), str(r_batch_uncertainty.dtype))) # summary out_img = np.concatenate( ( np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), #np.squeeze(img_util.to_rgb(r_batch_softmax[..., 0, np.newaxis], normalize=True)), np.squeeze( img_util.to_rgb(r_batch_softmax[..., 1, np.newaxis], normalize=True)), np.squeeze(img_util.to_rgb(r_batch_prediction[..., np.newaxis])), np.squeeze( img_util.to_rgb(r_batch_uncertainty[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/tile_%02d_summary.png" % (args.test_dir, b))
def DEBUG_core(sess): logging.info('#-----------------------------------------------#') logging.info('# Start Debugging #') logging.info('#-----------------------------------------------#') batch_img, batch_label, batch_weights = data_layers.data_HDF5( args.dataset, opts.shape_img, opts.shape_label, opts.shape_weights, shuffle=False, batch_size=opts.batch_size, prefetch_threads=12, prefetch_n=40, resample_n=40, augment=True) for bb in range(opts.n_samples): r_batch_img = [] for b in range(8): start = timer() e_batch_img, e_batch_label, e_batch_weights = sess.run( [batch_img, batch_label, batch_weights]) end = timer() print("got batch in %.4f s : img %s %s" % ( (end - start), str(e_batch_img.shape), str(e_batch_img.dtype))) r_batch_img.append( np.reshape(e_batch_img, [-1, e_batch_img.shape[2], e_batch_img.shape[3]])) print("stitching and creating file") out_img = np.concatenate( [img_util.to_rgb(batch) for batch in r_batch_img], axis=1) img_util.save_image(out_img, "%s/img_aug_%s.jpg" % (args.predict_dir, str(bb))) batch_img, batch_label, batch_weights = data_layers.data_HDF5( args.dataset, opts.shape_img, opts.shape_label, opts.shape_weights, shuffle=True, batch_size=opts.batch_size, prefetch_threads=12, prefetch_n=10, resample_n=None, augment=True) for b in range(50): start = timer() e_batch_img, e_batch_label, e_batch_weights = sess.run( [batch_img, batch_label, batch_weights]) end = timer() print("got batch in %.4f s : img %s %s, label %s %s, weights %s %s" % ((end - start), str(e_batch_img.shape), str(e_batch_img.dtype), str(e_batch_label.shape), str(e_batch_label.dtype), str(e_batch_weights.shape), str(e_batch_weights.dtype))) r_batch_img = np.reshape( e_batch_img, [-1, e_batch_img.shape[2], e_batch_img.shape[3]]) r_batch_label = np.reshape( e_batch_label, [-1, e_batch_label.shape[2], e_batch_label.shape[3]]) r_batch_weights = np.reshape( e_batch_weights, [-1, e_batch_weights.shape[2], e_batch_weights.shape[3]]) out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze(img_util.to_rgb(r_batch_weights, normalize=True))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.predict_dir, str(b)))
def test_sampling(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing with sampling #') logging.info('#-----------------------------------------------#') # # init variables # sess.run(tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) trainer = SimpleTrainer(session=sess, train_dir=train_dir) # load model (if None provided, gets latest from train_dir/checkpoints, if none found doesn't load) trainer.load_checkpoint(args.checkpoint) # ########################################################################### # RUN UNET # ########################################################################### logging.debug( "predicting, sampling %s x %s times, batch_size %s" % (str(opts.n_samples), str(opts.resample_n), str(opts.batch_size))) sample_dir = args.predict_dir + os.sep + 'samples' os.mkdir(sample_dir) for b in range(opts.n_samples): for s in range(opts.resample_n): if s == 0: batch_img, batch_label, batch_pred = sess.run([ net_test.batch_img, net_test.batch_label, net_test.prediction ]) logging.debug('batch_img: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) logging.debug('batch_label: %s %s' % (str(batch_label.shape), str(batch_label.dtype))) logging.debug('prediction: %s %s' % (str(batch_pred.shape), str(batch_pred.dtype))) else: _, _, batch_pred = sess.run([ net_test.batch_img, net_test.batch_label, net_test.prediction ]) logging.debug('prediction: %s %s' % (str(prediction_samples[s, ...].shape), str(prediction_samples[s, ...].dtype))) r_batch_pred = np.reshape(batch_pred, [-1, batch_pred.shape[2]]) if s == 0: prediction_samples = np.zeros([opts.resample_n] + list(r_batch_pred.shape), dtype=np.uint8) prediction_samples[s, ...] = r_batch_pred out_sample = img_util.to_rgb(prediction_samples[s, ...]) img_util.save_image(out_sample, "%s/sample_%s_%s.png" % (sample_dir, b, s)) logging.info('finished resampling (%s), calculating entropy' % (str(opts.resample_n))) entropy = calc.entropy_bin_array(prediction_samples) mean = np.mean(prediction_samples, axis=0) std = np.std(prediction_samples, axis=0) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze(img_util.to_rgb(mean)), np.squeeze(img_util.to_rgb_heatmap(entropy, rgb_256=True)), np.squeeze(img_util.to_rgb_heatmap(std, rgb_256=True))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.predict_dir, b))
def test_debug(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing (debug) #') logging.info('#-----------------------------------------------#') # load model for testing (if None provided, searches in train_dir, if not found doesn't load) logging.info("Attempt restore with SimpleTrainer load from: %s" % args.checkpoint) # load model for continued training (if None provided, searches in train_dir, if not found doesn't load) trainer = SimpleTrainer(session=sess, train_dir=train_dir) chkpt_loaded = trainer.load_checkpoint(args.checkpoint) # init variables if no checkpoint was loaded if not chkpt_loaded: sess.run(tf.group(tf.global_variables_initializer())) logging.info("Loaded variables from checkpoint" if chkpt_loaded else "Randomly initialized (!) variables") # in case any variables are not yet initialized #initialize_uninitialized(sess) # ########################################################################### # RUN UNET # ########################################################################### logging.debug("predicting, sampling %s times, batch_size %s" % (opts.n_samples, opts.batch_size)) for b in range(opts.n_samples): batch_img, batch_label, batch_activations, batch_prediction = sess.run( [ net_test.batch_img, net_test.batch_label, net_test.output_mask, net_test.prediction ]) # out_img = np.squeeze(img_util.to_rgb(batch_activations)) # img_util.save_image(out_img, "%s/img_%s_pred.png" % (args.test_dir, b)) logging.debug( 'batch_activations: %s %s' % (str(batch_activations.shape), str(batch_activations.dtype))) logging.debug( 'batch_prediction: %s %s' % (str(batch_prediction.shape), str(batch_prediction.dtype))) logging.debug('batch_img: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) logging.debug('batch_label: %s %s' % (str(batch_label.shape), str(batch_label.dtype))) # logging.debug('describe prediction_samples: ' + str(stats.describe(batch_activations))) # logging.debug('describe prediction_samples[0]: ' + str(stats.describe(prediction_samples[0]))) # out_img = img_util.combine_img_prediction(batch_img, batch_label, batch_activations) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_activations = np.reshape( batch_activations, [-1, batch_activations.shape[2], batch_activations.shape[3]]) r_batch_prediction = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) #r_batch_softmax = calc.softmax(r_batch_activations, axis=-1) # slow argmax = np.argmax(r_batch_activations, axis=-1) # just take direct max out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 0, np.newaxis], normalize=False)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 1, np.newaxis], normalize=False)), np.squeeze(img_util.to_rgb(argmax[..., np.newaxis])), np.squeeze(img_util.to_rgb(r_batch_prediction[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.predict_dir, b))
def test_core(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing #') logging.info('#-----------------------------------------------#') # load model for testing (if None provided, searches in train_dir, if not found doesn't load) trainer = SimpleTrainer(session=sess, train_dir=train_dir) chkpt_loaded = trainer.load_checkpoint(args.checkpoint) # init variables if no checkpoint was loaded if not chkpt_loaded: sess.run(tf.group(tf.global_variables_initializer())) logging.info("Loaded variables from checkpoint" if chkpt_loaded else "Randomly initialized (!) variables") # ########################################################################### # RUN UNET # ########################################################################### logging.debug("predicting, sampling %s times, batch_size %s" % (opts.n_samples, opts.batch_size)) for b in range(opts.n_samples): batch_img, batch_label, batch_activations, batch_prediction = sess.run( [ net_test.batch_img, net_test.batch_label, net_test.output_mask, net_test.prediction ]) # out_img = np.squeeze(img_util.to_rgb(batch_activations)) # img_util.save_image(out_img, "%s/img_%s_pred.png" % (args.test_dir, b)) logging.debug( 'batch_activations: %s %s' % (str(batch_activations.shape), str(batch_activations.dtype))) logging.debug( 'batch_prediction: %s %s' % (str(batch_prediction.shape), str(batch_prediction.dtype))) logging.debug('batch_img: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) logging.debug('batch_label: %s %s' % (str(batch_label.shape), str(batch_label.dtype))) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) r_batch_label = np.reshape( batch_label, [-1, batch_label.shape[2], batch_label.shape[3]]) r_batch_activations = np.reshape( batch_activations, [-1, batch_activations.shape[2], batch_activations.shape[3]]) r_batch_prediction = np.reshape(batch_prediction, [-1, batch_prediction.shape[2]]) out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img)), np.squeeze(img_util.to_rgb(r_batch_label)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 0, np.newaxis], normalize=True)), np.squeeze( img_util.to_rgb(r_batch_activations[..., 1, np.newaxis], normalize=True)), np.squeeze(img_util.to_rgb(r_batch_prediction[..., np.newaxis]))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.predict_dir, b))
def test_feed_sampling(sess, net_test): logging.info('#-----------------------------------------------#') logging.info('# Starting Testing with sampling #') logging.info('#-----------------------------------------------#') # # init variables # sess.run(tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) trainer = SimpleTrainer(session=sess, train_dir=train_dir) # load model (if None provided, gets latest from train_dir/checkpoints, if none found doesn't load) trainer.load_checkpoint(args.checkpoint) # ########################################################################### # RUN UNET # ########################################################################### logging.debug( "predicting, sampling %s x %s times, batch_size %s" % (str(opts.n_samples), str(opts.resample_n), str(opts.batch_size))) sample_dir = args.predict_dir + os.sep + 'samples' os.mkdir(sample_dir) for b in range(opts.n_samples): data_provider = data_import.create_img_batch_provider( data_dir, opts.batch_size, shuffle_data=True) batch_img = next(data_provider) logging.debug('batch_img: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) if opts.resize_method == "center_crop": batch_img = img_util.crop_to_shape(batch_img, [ batch_img.shape[0], opts.resize[0], opts.resize[1], batch_img.shape[3] ]) logging.debug(' resized to: %s %s' % (str(batch_img.shape), str(batch_img.dtype))) for s in range(opts.resample_n): batch_activations, batch_pred = sess.run( [net_test.output_mask, net_test.prediction], feed_dict={net_test.batch_img: batch_img}) logging.debug('prediction: %s %s' % (str(batch_pred.shape), str(batch_pred.dtype))) r_batch_pred = np.reshape(batch_pred, [-1, batch_pred.shape[2]]) if s == 0: prediction_samples = np.zeros([opts.resample_n] + list(r_batch_pred.shape), dtype=np.uint8) prediction_samples[s, ...] = r_batch_pred out_sample = img_util.to_rgb(prediction_samples[s, ...]) img_util.save_image(out_sample, "%s/sample_%s_%s.png" % (sample_dir, b, s)) logging.info('finished resampling (%s), calculating entropy' % (str(opts.resample_n))) entropy = calc.entropy_bin_array(prediction_samples) mean = np.mean(prediction_samples, axis=0) std = np.std(prediction_samples, axis=0) r_batch_img = np.reshape(batch_img, [-1, batch_img.shape[2], batch_img.shape[3]]) #r_batch_img_rgb = r_batch_img[..., 0:3] # ignore fourth channel # r_batch_img_new[..., 0] = r_batch_img[..., 1] # r_batch_img_new[..., 1] = r_batch_img[..., 0] # r_batch_img_new[..., 2] = r_batch_img[..., 2] out_img = np.concatenate( (np.squeeze(img_util.to_rgb(r_batch_img_rgb)), np.squeeze(img_util.to_rgb(mean)), np.squeeze(img_util.to_rgb_heatmap(entropy, rgb_256=True)), np.squeeze(img_util.to_rgb_heatmap(std, rgb_256=True))), axis=1) img_util.save_image(out_img, "%s/img_%s.png" % (args.predict_dir, b))