def test_option_save_best_reconstructor(self): dataset = get_standard_dataset('ellipses', impl='skimage') test_data = dataset.get_data_pairs('validation', 1) tt = TaskTable() fbp_reconstructor = FBPReconstructor(dataset.ray_trafo) hyper_param_choices = {'filter_type': ['Ram-Lak', 'Hann'], 'frequency_scaling': [0.1, 0.5, 1.0]} known_best_choice = {'filter_type': 'Hann', 'frequency_scaling': 0.5} path = 'dummypath' options = {'save_best_reconstructor': {'path': path, 'measure': PSNR}} tt.append(fbp_reconstructor, test_data, measures=[PSNR], hyper_param_choices=hyper_param_choices, options=options) class ExtStringIO(StringIO): def __init__(self, ext, f, *args, **kwargs): self.ext = ext self.f = f super().__init__(*args, **kwargs) self.ext[self.f] = self.getvalue() def close(self): self.ext[self.f] = self.getvalue() super().close() ext = {} with patch('dival.reconstructors.reconstructor.open', lambda f, *a, **kw: ExtStringIO(ext, f)): tt.run() self.assertIn(path + '_hyper_params.json', ext) self.assertDictEqual(json.loads(ext[path + '_hyper_params.json']), known_best_choice)
def test_option_save_best_reconstructor_reuse_iterates(self): # test 'save_best_reconstructor' option together with 'iterations' in # hyper_param_choices, because `run` has performance optimization for # it (with the default argument ``reuse_iterates=True``) domain = odl.uniform_discr([0, 0], [1, 1], (2, 2)) ground_truth = domain.element([[1, 0], [0, 1]]) observation = domain.element([[0, 0], [0, 0]]) # Reconstruct [[1, 0], [0, 1]], iterates are # [[0, 0], [0, 0]], [[.1, .1], [.1, .1]], [[.2, .2], [.2, .2]], ... # Best will be [[.5, .5], [.5, .5]]. class DummyReconstructor(StandardIterativeReconstructor): def _setup(self, observation): self.setup_var = 'dummy_val' def _compute_iterate(self, observation, reco_previous, out): out[:] = reco_previous + 0.1 test_data = DataPairs([observation], [ground_truth]) tt = TaskTable() r = DummyReconstructor(reco_space=domain) hyper_param_choices = {'iterations': list(range(10))} known_best_choice = {'iterations': 5} path = 'dummypath' options = {'save_best_reconstructor': {'path': path, 'measure': PSNR}} tt.append(r, test_data, measures=[PSNR], hyper_param_choices=hyper_param_choices, options=options) class ExtStringIO(StringIO): def __init__(self, ext, f, *args, **kwargs): self.ext = ext self.f = f super().__init__(*args, **kwargs) self.ext[self.f] = self.getvalue() def close(self): self.ext[self.f] = self.getvalue() super().close() ext = {} with patch('dival.reconstructors.reconstructor.open', lambda f, *a, **kw: ExtStringIO(ext, f)): tt.run() self.assertIn(path + '_hyper_params.json', ext) self.assertDictEqual(json.loads(ext[path + '_hyper_params.json']), known_best_choice)
def test_iterations_hyper_param_choices(self): # test 'iterations' in hyper_param_choices, because `run` has # performance optimization for it domain = odl.uniform_discr([0, 0], [1, 1], (1, 1)) ground_truth = domain.one() observation = domain.one() # reconstruct 1., iterates 0., 0.5, 0.75, 0.875, ... class DummyReconstructor(StandardIterativeReconstructor): def _setup(self, observation): self.setup_var = 'dummy_val' def _compute_iterate(self, observation, reco_previous, out): out[:] = 0.5 * (observation + reco_previous) test_data = DataPairs([observation], [ground_truth]) tt = TaskTable() r = DummyReconstructor(reco_space=domain) hyper_param_choices = {'iterations': [2, 3, 10]} tt.append(r, test_data, hyper_param_choices=hyper_param_choices) iters = [] r.callback = CallbackStore(iters) results = tt.run(reuse_iterates=True) self.assertAlmostEqual(1., results.results['reconstructions'][0, 1][0][0, 0], delta=0.2) self.assertNotAlmostEqual(1., results.results['reconstructions'][0, 0][0][0, 0], delta=0.2) self.assertEqual(len(iters), max(hyper_param_choices['iterations'])) print(results.results['misc']) iters2 = [] r.callback = CallbackStore(iters2) results2 = tt.run(reuse_iterates=False) self.assertAlmostEqual(1., results2.results['reconstructions'][0, 1][0][0, 0], delta=0.2) self.assertNotAlmostEqual(1., results2.results['reconstructions'][0, 0][0][0, 0], delta=0.2) self.assertEqual(len(iters2), sum(hyper_param_choices['iterations']))
def test_option_save_iterates(self): domain = odl.uniform_discr([0, 0], [1, 1], (1, 1)) ground_truth = domain.one() observation = domain.one() # reconstruct 1., iterates 0., 0.5, 0.75, 0.875, ... class DummyReconstructor(StandardIterativeReconstructor): def _setup(self, observation): self.setup_var = 'dummy_val' def _compute_iterate(self, observation, reco_previous, out): out[:] = 0.5 * (observation + reco_previous) test_data = DataPairs([observation], [ground_truth]) tt = TaskTable() r = DummyReconstructor(reco_space=domain) hyper_param_choices = {'iterations': [10]} options = {'save_iterates': True} tt.append(r, test_data, hyper_param_choices=hyper_param_choices, options=options) results = tt.run() self.assertAlmostEqual( 1., results.results['misc'][0, 0]['iterates'][0][2][0, 0], delta=0.2) self.assertNotAlmostEqual( 1., results.results['misc'][0, 0]['iterates'][0][1][0, 0], delta=0.2)
def test(self): reco_space = odl.uniform_discr( min_pt=[-64, -64], max_pt=[64, 64], shape=[128, 128]) phantom = odl.phantom.shepp_logan(reco_space, modified=True) geometry = odl.tomo.parallel_beam_geometry(reco_space, 30) ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='skimage') proj_data = ray_trafo(phantom) observation = np.asarray( proj_data + np.random.normal(loc=0., scale=2., size=proj_data.shape)) test_data = DataPairs(observation, phantom) tt = TaskTable() fbp_reconstructor = FBPReconstructor(ray_trafo, hyper_params={ 'filter_type': 'Hann', 'frequency_scaling': 0.8}) tt.append(fbp_reconstructor, test_data, measures=[PSNR, SSIM]) tt.run() self.assertGreater( tt.results.results['measure_values'][0, 0]['psnr'][0], 15.)
hyper_params={ 'filter_type': 'Hann', 'frequency_scaling': 0.8 }) cg_reconstructor = CGReconstructor(ray_trafo, reco_space.zero(), 4) gn_reconstructor = GaussNewtonReconstructor(ray_trafo, reco_space.zero(), 2) lw_reconstructor = LandweberReconstructor(ray_trafo, reco_space.zero(), 8) mlem_reconstructor = MLEMReconstructor(ray_trafo, 0.5 * reco_space.one(), 1) reconstructors = [ fbp_reconstructor, cg_reconstructor, gn_reconstructor, lw_reconstructor, mlem_reconstructor ] options = {'save_iterates': True} eval_tt.append_all_combinations(reconstructors=reconstructors, test_data=[test_data], options=options) # %% run task table results = eval_tt.run() results.apply_measures([PSNR, SSIM]) print(results) # %% plot reconstructions fig = results.plot_all_reconstructions(fig_size=(9, 4), vrange='individual') # %% plot convergence results.plot_convergence(1, fig_size=(9, 6), gridspec_kw={'hspace': 0.5}) results.plot_performance(PSNR)