def __init__(self, conf): self.model = None self.conf = conf self.loader = None if hasattr(self.conf, 'dataset_name') and len(self.conf.dataset_name) > 0: self.loader = loader_factory.init_loader(self.conf.dataset_name)
def __init__(self, conf, model): self.conf = conf self.model = model self.loader = loader_factory.init_loader(self.conf.dataset_name) self.epoch = 0 self.models_folder = self.conf.folder + '/models' self.train_data = None self.valid_data = None self.train_folder = None
def test(self): """ Evaluate a model on the test data. """ log.info('Evaluating model on test data') folder = os.path.join(self.conf.folder, 'test_results_%s' % self.conf.dataset_name) if not os.path.exists(folder): os.makedirs(folder) test_loader = loader_factory.init_loader(self.conf.dataset_name) test_data = test_loader.load_labelled_data(self.conf.split, 'test') synth = [] im_dice = {} samples = os.path.join(folder, 'samples') if not os.path.exists(samples): os.makedirs(samples) f = open(os.path.join(folder, 'results.csv'), 'w') f.writelines('Vol, Dice\n') for vol_i in test_data.volumes(): vol_folder = os.path.join(samples, 'vol_%s' % str(vol_i)) if not os.path.exists(vol_folder): os.makedirs(vol_folder) vol_image = test_data.get_volume_image(vol_i) vol_mask = test_data.get_volume_mask(vol_i) assert vol_image.shape[0] > 0 and vol_image.shape == vol_mask.shape pred, _ = self.sdnet.Decomposer.predict(vol_image) synth.append(pred) im_dice[vol_i] = costs.dice(vol_mask, pred) f.writelines('%s, %.3f\n' % (str(vol_i), im_dice[vol_i])) for i in range(vol_image.shape[0]): im = np.concatenate([ vol_image[i, :, :, 0], pred[i, :, :, 0], vol_mask[i, :, :, 0] ], axis=1) scipy.misc.imsave( os.path.join(vol_folder, 'test_vol%d_sl%d.png' % (vol_i, i)), im) print('Dice score: %.3f' % np.mean(list(im_dice.values()))) f.close()
def __init__(self, sdnet, conf): self.sdnet = sdnet self.conf = conf self.loader = loader_factory.init_loader(self.conf.dataset_name) # Data iterators self.gen_X_L = None # labelled data: (image, mask) pairs self.gen_X_U = None # unlabelled data self.other_masks = None # real masks to use for discriminator training self.fake_image_pool = [] self.fake_mask_pool = [] self.batch = 0 self.epoch = 0 if not os.path.exists(self.conf.folder): os.makedirs(self.conf.folder)
def __init__(self, conf): """ SDNet constructor :param conf: configuration object """ super(SDNet, self).__init__() self.other_masks = None self.conf = conf self.loader = loader_factory.init_loader(self.conf.dataset_name) self.D_model = None # Discriminator trainer self.G_model = None # Unsupervised generator trainer self.G_supervised_model = None # Supervised generator trainer self.Decomposer = None # Decomposer self.Reconstructor = None # Reconstructor self.ImageDiscriminator = None # Image discriminator self.MaskDiscriminator = None # Mask discriminator
def test_modality(self, modality, modality_index): """ Evaluate model on a given modality :param modality: the modality to load """ test_loader = loader_factory.init_loader(self.conf.test_dataset) test_loader.modalities = self.conf.modality test_data = test_loader.load_all_modalities_concatenated(self.conf.split, 'test', self.conf.image_downsample) test_data.crop(self.conf.input_shape[:2]) # crop data to input shape for type in ['simple', 'def', 'max']: folder = self.make_test_folder(modality, suffix=type) self.test_modality_type(folder, modality_index, type, test_loader, test_data) test_data.randomise_pairs(length=2, seed=self.conf.seed) for type in ['simple', 'def', 'max']: folder = self.make_test_folder(modality, suffix=type + '_rand') self.test_modality_type(folder, modality_index, type, test_loader, test_data)
log.info('---- Setting up experiment at ' + config.folder + '----') if __name__ == '__main__': parser = argparse.ArgumentParser(description='Run SDNet') parser.add_argument('--epochs', help='Number of epochs to train', type=int) parser.add_argument('--dataset', help='Dataset to use', choices=['acdc'], required=True) parser.add_argument('--description', help='Experiment description') parser.add_argument('--split', help='Split for Cross Validation', type=int, required=True) parser.add_argument('--test', help='Test', type=bool) parser.add_argument('--ul_mix', help='Percentage of unlabelled data to mix', type=float, required=True) parser.add_argument('--l_mix', help='Percentage of labelled data to mix', type=float, required=True) args = parser.parse_args() # Create configuration object from parameters loader = loader_factory.init_loader(args.dataset) data = loader.load_labelled_data(args.split, 'training') folder = 'sdnet_%s_ul_%.3f_l_%.3f_split%d' % (args.dataset, args.ul_mix, args.l_mix, args.split) conf = Configuration(folder, data.size(), data.shape()[1:]) del data conf.description = args.description if args.description else '' if args.epochs: conf.epochs = args.epochs conf.dataset_name = args.dataset conf.ul_mix = args.ul_mix conf.l_mix = args.l_mix conf.split = args.split conf.save()
def test_modality(self, folder, modality, group, save_figs=True): test_loader = loader_factory.init_loader(self.conf.test_dataset) test_data = test_loader.load_labelled_data( self.conf.split, group, modality=modality, downsample=self.conf.image_downsample) anatomy_segmentor = self.model.get_anatomy_segmentor() pathology_segmentator = self.model.get_pathology_encoder() synth = [] im_dice_anato, im_false_negative_anato = {}, {} im_dice_patho, im_false_negative_patho = {}, {} sep_dice_list_anato, sep_false_negative_list_anato = [], [] sep_dice_list_patho, sep_false_negative_list_patho = [], [] anato_mask_num = len(test_data.anato_mask_names) patho_mask_num = len(test_data.patho_mask_names) for ii in range(anato_mask_num): sep_dice_list_anato.append([]) sep_false_negative_list_anato.append([]) for ii in range(patho_mask_num): sep_dice_list_patho.append([]) sep_false_negative_list_patho.append([]) f = open(os.path.join(folder, 'results.csv'), 'w') for vol_i in test_data.volumes(): vol_image = test_data.get_images(vol_i) vol_anato_mask = test_data.get_anato_masks(vol_i) vol_patho_mask = test_data.get_patho_masks(vol_i) vol_slice = test_data.get_slice(vol_i) assert vol_image.shape[ 0] > 0 and vol_image.shape[: -1] == vol_anato_mask.shape[: -1] and vol_image.shape[: -1] == vol_patho_mask.shape[: -1] anato_pred = anatomy_segmentor.predict(vol_image) patho_pred = pathology_segmentator.predict(vol_image) pred = [anato_pred, patho_pred] synth.append(pred) model_type = 'sdnet' im_dice_anato[vol_i], sep_dice_anato \ = dice(vol_anato_mask, pred[0]) im_false_negative_anato[vol_i], sep_false_negative_anato \ = calculate_false_negative(vol_anato_mask, pred[0]) im_dice_patho[vol_i], sep_dice_patho \ = dice(vol_patho_mask, pred[1]) im_false_negative_patho[vol_i], sep_false_negative_patho \ = calculate_false_negative(vol_patho_mask, pred[1]) # harric added to specify dice scores across different masks assert anato_mask_num == len( sep_dice_anato), 'Incorrect mask num !' assert patho_mask_num == len( sep_dice_patho), 'Incorrect mask num !' for ii in range(anato_mask_num): sep_dice_list_anato[ii].append(sep_dice_anato[ii]) sep_false_negative_list_anato[ii].append( sep_false_negative_anato[ii]) for ii in range(patho_mask_num): sep_dice_list_patho[ii].append(sep_dice_patho[ii]) sep_false_negative_list_patho[ii].append( sep_false_negative_patho[ii]) # harric added to specify dice scores across different masks s = 'Volume:%s, AnatomyDice:%.3f, AnatomyFN:%.3f, ' \ + 'PathologyDice:%.3f, PathologyFN:%.3f, ' \ + ', '.join(['%s, %.3f, %.3f, '] * len(test_data.anato_mask_names)) \ + ', '.join(['%s, %.3f, %.3f, '] * len(test_data.patho_mask_names)) \ + '\n' d = (str(vol_i), im_dice_anato[vol_i], im_false_negative_anato[vol_i]) d += (im_dice_patho[vol_i], im_false_negative_patho[vol_i]) for info_travesal in range(anato_mask_num): d += (test_data.anato_mask_names[info_travesal], sep_dice_anato[info_travesal], sep_false_negative_anato[info_travesal]) for info_travesal in range(patho_mask_num): d += (test_data.patho_mask_names[info_travesal], sep_dice_patho[info_travesal], sep_false_negative_patho[info_travesal]) f.writelines(s % d) if save_figs: for i in range(vol_image.shape[0]): d, m, mm = vol_image[i], vol_anato_mask[i], vol_patho_mask[ i] # d, m, mm = vol_image[10], vol_anato_mask[10], vol_patho_mask[10] s = vol_slice[i] im1 = save_segmentation(pred[0][i, :, :, :], d, m) im2 = save_segmentation(pred[1][i, :, :, :], d, mm) if im1.shape[1] > im2.shape[1]: im2 = np.concatenate([ im2, np.zeros(shape=(im2.shape[0], im1.shape[1] - im2.shape[1]), dtype=im2.dtype) ], axis=1) elif im1.shape[1] < im2.shape[1]: im1 = np.concatenate([ im1, np.zeros(shape=(im1.shape[0], im2.shape[1] - im1.shape[1]), dtype=im1.dtype) ], axis=1) im = np.concatenate([im1, im2], axis=0) imsave( os.path.join( folder, "vol%s_slice%s" % (str(vol_i), s) + '.png'), im) # harric added to specify dice scores across different masks print_info = group + ', AnatomyDice:%.3f, AnatoFN:%.3f, PathoDice:%.3f, PathoFN:%.3f,' % \ (np.mean(list(im_dice_anato.values())), np.mean(list(im_false_negative_anato.values())), np.mean(list(im_dice_patho.values())), np.mean(list(im_false_negative_patho.values()))) for ii in range(anato_mask_num): print_info += '%s, %.3f, %.3f,' % \ (test_data.anato_mask_names[ii], np.mean(sep_dice_list_anato[ii]), np.mean(sep_false_negative_list_anato[ii])) for ii in range(patho_mask_num): print_info += '%s, %.3f, %.3f' % \ (test_data.patho_mask_names[ii], np.mean(sep_dice_list_patho[ii]), np.mean(sep_false_negative_list_patho[ii])) print(print_info) f.write(print_info) f.close() return np.mean(list(im_dice_patho.values()))