def main(): # load data options = get_parser().parse_args() dataset = load_standard_dataset(options.dataset, ordered=True) ray_trafo = dataset.ray_trafo X = ray_trafo.range lodopab_cache_file_names = { 'train': [None, None], 'validation': [None, None] } if options.method == 'fbpunet': X = ray_trafo.domain train_path = 'cache_train_{}_fbp.npy'.format(options.dataset) validation_path = 'cache_validation_{}_fbp.npy'.format(options.dataset) lodopab_cache_file_names = { 'train': [train_path, None], 'validation': [validation_path, None] } cached_dataset = CachedDataset(dataset, space=(X, ray_trafo.domain), cache_files=lodopab_cache_file_names, size_part=options.size_part) test_data = dataset.get_data_pairs('validation', cached_dataset.validation_len) print('validation size: %d' % len(test_data)) reconstructor = get_reconstructor(options.method, dataset=options.dataset, size_part=options.size_part, pretrained=False) print(reconstructor.hyper_params) full_name = '{}_{}_{}'.format( options.dataset, options.method, options.size_part) print(full_name) reconstructor.save_best_learned_params_path = get_weights_path(full_name) reconstructor.log_dir = options.log_dir reconstructor.num_data_loader_workers = 16 # create a Dival task table and run it task_table = TaskTable() task_table.append( reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, dataset=cached_dataset, hyper_param_choices=[reconstructor.hyper_params] ) results = task_table.run() # save report save_results_table(results, full_name)
def generate_cache(dataset_name, file_names, frequency_scaling=1.0, only_fbp=False): dataset = load_standard_dataset(dataset_name, ordered=False) ray_trafo = dataset.ray_trafo for part in ['train', 'validation']: generate_dataset_cache( dataset=dataset, part=part, ray_trafo=ray_trafo, file_names=file_names[part], frequency_scaling=frequency_scaling, filter_type='Hann', only_fbp=only_fbp )
def tvadam_reconstructor(dataset='ellipses', name=None): """ :param dataset: Can be 'ellipses' or 'lodopab' :return: TV reconstructor for the specified dataset """ try: params = Params.load('{}_tvadam'.format(dataset)) standard_dataset = load_standard_dataset(dataset) if name is None: name = 'TV-Adam' reconstructor = TVAdamReconstructor(standard_dataset.ray_trafo, hyper_params=params.dict, name=name) return reconstructor except Exception as e: raise Exception('The reconstructor doesn\'t exist')
def fbp_reconstructor(dataset='ellipses', name=None): """ :param dataset: Can be 'ellipses' or 'lodopab' :return: Filtered back projection reconstructor for the specified dataset """ try: params = Params.load('{}_fbp'.format(dataset)) standard_dataset = load_standard_dataset(dataset) if name is None: name = 'FBP' reconstructor = FBPReconstructor(standard_dataset.ray_trafo, hyper_params=params.dict, name=name) return reconstructor except Exception as e: raise Exception('The reconstructor doesn\'t exist')
def dip_reconstructor(dataset='ellipses', name=None): """ :param dataset: Can be 'ellipses' or 'lodopab' :return: The Deep Image Prior (DIP) method for the specified dataset """ try: standard_dataset = load_standard_dataset(dataset) params = Params.load('{}_dip'.format(dataset)) if name is None: name = 'DIP' reconstructor = DeepImagePriorReconstructor(standard_dataset.ray_trafo, hyper_params=params.dict, name=name) return reconstructor except Exception as e: raise Exception('The reconstructor doesn\'t exist')
def main(): """Main function""" options = get_parser().parse_args() # options.dataset = 'lodopab' | 'ellipses' | 'lodopab-sparse' dataset = load_standard_dataset(options.dataset) test_data = dataset.get_data_pairs('test', 100) obs = list(y for y, x in test_data) gt = list(x for y, x in test_data) start = options.start count = options.count if count is None: count = len(test_data) test_data = DataPairs(obs[start:start + count], gt[start:start + count], name='test') # load reconstructor reconstructor = get_reconstructor(options.method, options.dataset, options.size_part) # eval on the test-set print('Reconstructor: %s' % options.method) print('Dataset: %s' % options.dataset) print('Offset: %d' % start) print('Count: %d' % count) task_table = TaskTable() task_table.append(reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, options={'skip_training': True}) task_table.run() print(task_table.results.to_string(show_columns=['misc'])) if options.size_part is not None: save_path = '{}_{}_{}_eval'.format(options.dataset, options.method, options.size_part) else: save_path = '{}_{}_eval'.format(options.dataset, options.method) save_path += '_offset_%d' % start save_results_table(task_table.results, save_path)
import time from dliplib.reconstructors import learnedpd_dip_reconstructor, diptv_reconstructor from dliplib.utils.helper import load_standard_dataset, set_use_latex set_use_latex() # load data dataset = load_standard_dataset('ellipses') test_data = dataset.get_data_pairs('test', 100) obs, gt = test_data[0] data_size = 0.001 print('Eval: Learned PD ({}%) + DIP'.format(data_size * 100)) reconstructor = learnedpd_dip_reconstructor('ellipses', data_size) t_start = time.time() reco1 = reconstructor.reconstruct(obs) t_end = time.time() print('Elapsed time: %d s' % (t_end - t_start)) print('Eval: DIP+TV') # load hyper-parameters and create reconstructor reconstructor = diptv_reconstructor('ellipses') t_start = time.time() reco2 = reconstructor.reconstruct(obs) t_end = time.time()
def main(): # load data options = get_parser().parse_args() dataset = load_standard_dataset('lodopab', ordered=True) ray_trafo = dataset.ray_trafo global_results = [] sizes = [0.001, 0.01, 0.1, 1.00] #sizes = [0.0001] #sizes = [0.001] #sizes = [0.01] #sizes = [0.1] for size_part in sizes: cached_dataset = CachedDataset(dataset, space=(ray_trafo.range, ray_trafo.domain), cache_files={ 'train': [None, None], 'validation': [None, None] }, size_part=size_part) test_data = dataset.get_data_pairs('validation', cached_dataset.validation_len) print('validation size: %d' % len(test_data)) full_size_epochs = 10 if size_part >= 0.10 else 5 lr = 0.0001 if size_part >= 0.10 else 0.001 # scale number of epochs by 1/size_part, but maximum 1000 times as many # epochs as for full size dataset epochs = min(1000 * full_size_epochs, int(1. / size_part * full_size_epochs)) reconstructor = LearnedPDReconstructor( ray_trafo, log_dir='lodopab_learnedpd_{}'.format(size_part), save_best_learned_params_path=get_weights_path( 'lodopab_learnedpd_{}'.format(size_part))) # create a Dival task table and run it task_table = TaskTable() task_table.append(reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, dataset=cached_dataset, hyper_param_choices={ 'batch_size': [1], 'epochs': [epochs], 'niter': [10], 'internal_ch': [64 if size_part >= 0.10 else 32], 'lr': [lr], 'lr_min': [lr], 'init_fbp': [True], 'init_frequency_scaling': [0.7] }) results = task_table.run() # save report save_results_table(results, 'lodopab_learnedpd_{}'.format(size_part)) # select best parameters and save them best_choice, best_error = select_hyper_best_parameters(results) params = Params(best_choice) params.save('lodopab_learnedpd_{}'.format(size_part))
import numpy as np from dival import TaskTable from dival.measure import PSNR, SSIM from dliplib.utils import Params from dliplib.utils.helper import select_hyper_best_parameters from dliplib.utils.helper import load_standard_dataset from dliplib.reconstructors.dip import DeepImagePriorReconstructor from dliplib.utils.reports import save_results_table # load data dataset = load_standard_dataset('lodopab_200') test_data = dataset.get_data_pairs('validation', 4) task_table = TaskTable() # create the reconstructor reconstructor = DeepImagePriorReconstructor(dataset.ray_trafo) # create a Dival task table and run it task_table.append(reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, hyper_param_choices={ 'lr': [0.0007], 'scales': [6], 'gamma': np.linspace(2, 7, 10), 'channels': [(128, ) * 6], 'skip_channels': [(0, 0, 0, 0, 4, 4)], 'iterations':
import numpy as np from dival import TaskTable from dival.measure import PSNR, SSIM from dliplib.utils import Params from dliplib.utils.helper import select_hyper_best_parameters, load_standard_dataset from dliplib.reconstructors.dip import DeepImagePriorReconstructor from dliplib.utils.reports import save_results_table # load data dataset = load_standard_dataset('lodopab') test_data = dataset.get_data_pairs('validation', 2) task_table = TaskTable() # create the reconstructor reconstructor = DeepImagePriorReconstructor(dataset.ray_trafo) # create a Dival task table and run it task_table.append(reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, hyper_param_choices={ 'lr': [0.001, 0.0005, 0.0001], 'scales': [5], 'gamma': [0.0], 'channels': [(64, ) * 5, (128, ) * 5], 'skip_channels': [(0, 0, 0, 0, 0), (0, 0, 0, 0, 4), (0, 0, 0, 4, 4)], 'iterations': [3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000],
import numpy as np from dival import TaskTable from dival.measure import PSNR, SSIM from dliplib.reconstructors import learnedpd_dip_reconstructor from dliplib.utils import Params from dliplib.utils.data.datasets import CachedDataset from dliplib.utils.helper import select_hyper_best_parameters, load_standard_dataset from dliplib.utils.reports import save_results_table dataset = load_standard_dataset('lodopab_200', ordered=True) test_data = dataset.get_data_pairs('train', 5) task_table = TaskTable() size_part = 0.0001 # load reconstructor reconstructor = learnedpd_dip_reconstructor('lodopab_200', size_part) # create a Dival task table and run it task_table.append(reconstructor=reconstructor, measures=[PSNR, SSIM], test_data=test_data, hyper_param_choices={ 'lr1': [0.0005], 'lr2': [1e-6], 'scales': [6], 'gamma': [2.5, 3.0, 4.0], 'channels': [(128, ) * 6], 'skip_channels': [(0, 0, 0, 0, 4, 4)], 'initial_iterations': [5000, 9750],