def test_ensure_parameters_are_listlike(self): sphere = Sphere(r=prior.Uniform(0, 1), n=prior.Uniform(1, 2)) model = AlphaModel(sphere, alpha=prior.Uniform(0.5, 1)) as_dict = {'alpha': 0.8, 'r': 1.2, 'n': 1.5} as_list = [1.5, 1.2, 0.8] self.assertEqual(model.ensure_parameters_are_listlike(as_dict), as_list) self.assertEqual(model.ensure_parameters_are_listlike(as_list), as_list)
def test_serialization(): par_s = Sphere(center=(Uniform(0, 1e-5, guess=.567e-5), Uniform(0, 1e-5, .567e-5), Uniform(1e-5, 2e-5)), r=Uniform(1e-8, 1e-5, 8.5e-7), n=Uniform(1, 2, 1.59)) alpha = Uniform(.1, 1, .6, 'alpha') schema = update_metadata(detector_grid(shape=100, spacing=.1151e-6), illum_wavelen=.66e-6, medium_index=1.33, illum_polarization=(1, 0)) model = AlphaModel(par_s, medium_index=schema.medium_index, illum_wavelen=schema.illum_wavelen, alpha=alpha) initial_guess = model.scatterer_from_parameters(model.initial_guess) holo = calc_holo(schema, initial_guess, scaling=model.alpha.guess) result = NmpfitStrategy().fit(model, holo) temp = tempfile.NamedTemporaryFile(suffix='.h5', delete=False) with warnings.catch_warnings(): warnings.simplefilter('ignore') save(temp.name, result) loaded = load(temp.name) assert_obj_close(result, loaded, context='serialized_result')
def test_scatterer_from_parameters_dict(self): sphere = Sphere(n=prior.Uniform(1, 2), r=prior.Uniform(0, 1)) model = AlphaModel(sphere) pars = {'r': 0.8, 'n': 1.6} expected = Sphere(n=1.6, r=0.8) out_scatterer = model.scatterer_from_parameters(pars) self.assertEqual(out_scatterer, expected)
def test_yaml_preserves_parameter_names(self): sphere = Sphere(r=prior.Uniform(0, 1), n=prior.Uniform(1, 2, name='a')) model = AlphaModel(sphere) model._parameter_names = ['b', 'c'] post_model = take_yaml_round_trip(model) self.assertEqual(post_model._parameter_names, ['b', 'c']) self.assertEqual(post_model._parameters[0].name, 'a')
def test_add_tie_specify_name(self): tied = prior.Uniform(-5, 5) sphere = Sphere(n=prior.Uniform(1, 2), r=prior.Uniform(1, 2), center=[tied, tied, 10]) model = AlphaModel(sphere) model.add_tie(['r', 'n'], new_name='dummy') expected = ['dummy', 'center.0'] self.assertEqual(model._parameter_names, expected)
def test_add_tie_updates_parameter_names(self): tied = prior.Uniform(-5, 5) sphere = Sphere(n=prior.Uniform(1, 2), r=prior.Uniform(1, 2), center=[tied, tied, 10]) model = AlphaModel(sphere) model.add_tie(['r', 'n']) expected = ['n', 'center.0'] self.assertEqual(model._parameter_names, expected)
def test_optics_from_schema(self): model = AlphaModel(Sphere(), medium_index=prior.Uniform(1, 2)) schema = detector_grid(2, 2) schema.attrs['illum_wavelen'] = 0.6 schema.attrs['illum_polarization'] = [1, 0] found_optics = model._find_optics([1.5], schema) expected = {'medium_index': 1.5, 'illum_wavelen': 0.6, 'illum_polarization': [1, 0]} self.assertEqual(found_optics, expected)
def test_yaml_preserves_parameter_ties(self): tied = prior.Uniform(0, 1) sphere = Sphere(n=tied, r=prior.Uniform(0.6, 1, name='radius'), center=[prior.Uniform(0.6, 1), tied, 10]) alpha = {'r': 0.6, 'g': prior.Uniform(0.8, 0.9)} model = AlphaModel(sphere, alpha=alpha) model.add_tie(['radius', 'center.0']) post_model = take_yaml_round_trip(model) self.assertEqual(model.parameters, post_model.parameters)
def test_model_optics_take_precedence(self): model = AlphaModel(Sphere(), medium_index=1.5, illum_wavelen=0.8) schema = detector_grid(2, 2) schema.attrs['illum_wavelen'] = 0.6 schema.attrs['illum_polarization'] = [1, 0] found_optics = model._find_optics([], schema) expected = {'medium_index': 1.5, 'illum_wavelen': 0.8, 'illum_polarization': [1, 0]} self.assertEqual(found_optics, expected)
def test_add_tie_updates_map(self): tied = prior.Uniform(-5, 5) sphere = Sphere(n=prior.Uniform(1, 2), r=prior.Uniform(1, 2), center=[tied, tied, 10]) model = AlphaModel(sphere) model.add_tie(['r', 'n']) expected = [dict, [[['n', '_parameter_0'], ['r', '_parameter_0'], ['center', ['_parameter_1', '_parameter_1', 10]]]]] self.assertEqual(model._maps['scatterer'], expected)
def test_reads_optics_from_map(self): med_n = prior.ComplexPrior(1.5, prior.Uniform(0, 0.1)) wl = {'red': 0.5, 'green': prior.Uniform(0, 1)} pol = [1, prior.Uniform(0.5, 1.5)] model = AlphaModel(Sphere(), medium_index=med_n, illum_wavelen=wl, illum_polarization=pol) pars = [0.01, 0.6, 1] found_optics = model._find_optics(pars, None) expected = {'medium_index': complex(1.5, 0.01), 'illum_wavelen': {'red': 0.5, 'green': 0.6}, 'illum_polarization': [1, 1]} self.assertEqual(found_optics, expected)
def test_calc_holo_with_twocolor_priors(self): detector = detector_grid( 5, 1, extra_dims={'illumination': ['red', 'green']}) index = { 'red': prior.Uniform(1.5, 1.6), 'green': prior.Uniform(1.5, 1.6)} scatterer = Sphere(r=0.5, n=index, center=(2,2,2)) alpha = {'red': prior.Uniform(0.6, 1), 'green': prior.Uniform(0.6, 1)} model = AlphaModel(scatterer, alpha, illum_polarization=(0, 1), illum_wavelen={'red': 0.66, 'green': 0.52}, medium_index=1.33) result = model.forward(model.initial_guess, detector) assert result is not None
def test_prior_name(self): tied = prior.Uniform(-5, 5, name='xy') sphere = Sphere(n=prior.Uniform(1, 2, name='index'), r=0.5, center=[tied, tied, prior.Uniform(0, 10, name='z')]) model = AlphaModel(sphere) expected_names = ['index', tied.name, 'z'] self.assertEqual(model._parameter_names, expected_names)
def test_tied_name(self): tied = prior.Uniform(0, 1) sphere1 = Sphere(n=prior.Uniform(1, 2), r=tied, center=[1, 1, 1]) sphere2 = Sphere(n=prior.Uniform(1, 2), r=tied, center=[1, 1, 1]) model = AlphaModel(Spheres([sphere1, sphere2])) expected_names = ['0:n', 'r', '1:n'] self.assertEqual(model._parameter_names, expected_names)
def test_ComplexPrior(): parm = Sphere( n=prior.ComplexPrior(real=prior.Uniform(1.58, 1.59), imag=.001)) model = AlphaModel(parm, alpha=prior.Uniform(.6, 1, .7)) assert_equal(model.parameters['n.real'].name, 'n.real') interpreted_pars = {'alpha': .7, 'n': {'real': 1.585}} assert_equal(_interpret_parameters(model.parameters), interpreted_pars)
def test_parameters_names(self): tied = prior.Uniform(0, 1) scatterer = Sphere(n=tied, r=prior.Uniform(0.5, 1.5), center=[tied, 10, prior.Uniform(0, 10)]) model = AlphaModel(scatterer) expected = ['n', 'r', 'center.2'] self.assertEqual(model._parameter_names, expected)
def test_yaml_round_trip_with_dict(self): alpha_dict = {'red': 1, 'green': 0.5} sphere = make_sphere() model = AlphaModel(sphere, alpha=alpha_dict) reloaded = take_yaml_round_trip(model) self.assertEqual(reloaded, model)
def test_duplicate_name(self): tied = prior.Uniform(-5, 5, name='dummy') sphere = Sphere(n=prior.Uniform(1, 2, name='dummy'), r=0.5, center=[tied, tied, prior.Uniform(0, 10, name='z')]) model = AlphaModel(sphere) expected = ['dummy', 'dummy_0', 'z'] self.assertEqual(model._parameter_names, expected)
def test_parameters_map(self): tied = prior.Uniform(0, 1) scatterer = Sphere(n=tied, r=prior.Uniform(0.5, 1.5), center=[tied, 10, prior.Uniform(0, 10)]) model = AlphaModel(scatterer) expected = [dict, [[['n', '_parameter_0'], ['r', '_parameter_1'], ['center', ['_parameter_0', 10, '_parameter_2']]]]] self.assertEqual(model._maps['scatterer'], expected)
def test_yaml_preserves_parameter_names(self): n = prior.ComplexPrior(prior.Uniform(1, 2), prior.Uniform(0, 0.1)) sphere = Sphere(n=n, r=prior.Uniform(0, 1.5, name='radius'), center=[1, 1, prior.Uniform(10, 20)]) alpha = {'r': 0.6, 'g': prior.Uniform(0.6, 1.0)} model = AlphaModel(sphere, alpha=alpha) pre_names = model._parameter_names post_names = take_yaml_round_trip(model)._parameter_names self.assertEqual(pre_names, post_names)
def test_parameters_list(self): tied = prior.Uniform(0, 1) scatterer = Sphere(n=tied, r=prior.Uniform(0.5, 1.5), center=[tied, 10, prior.Uniform(0, 10)]) model = AlphaModel(scatterer) expected = [prior.Uniform(0, 1), prior.Uniform(0.5, 1.5), prior.Uniform(0, 10)] self.assertEqual(model._parameters, expected)
def test_yaml_round_trip_with_xarray(self): alpha_xarray = xr.DataArray([1, 0.5], dims=['illumination'], coords={'illumination': ['red', 'green']}) sphere = make_sphere() model = AlphaModel(sphere, alpha=alpha_xarray) reloaded = take_yaml_round_trip(model) self.assertEqual(reloaded, model)
def test_transformed_priors_are_tied(self): base_prior = prior.Uniform(0, 2, name='x') transformed = prior.TransformedPrior(np.sqrt, base_prior, name='y') scatterer = Sphere(n=1.5, r=0.5, center=[base_prior, transformed, prior.Uniform(5, 10)]) model = AlphaModel(scatterer) expected_priors = [base_prior, prior.Uniform(5, 10)] expected_names = ['x', 'center.2'] self.assertEqual(model._parameters, expected_priors) self.assertEqual(model._parameter_names, expected_names)
def test_equal_not_identical_do_not_tie(self): scatterer = Sphere(n=prior.Uniform(1, 2), r=prior.Uniform(1, 2), center=[10, 10, prior.Uniform(1, 2)]) model = AlphaModel(scatterer) expected_priors = [prior.Uniform(1, 2), prior.Uniform(1, 2), prior.Uniform(1, 2)] expected_names = ['n', 'r', 'center.2'] self.assertEqual(model._parameters, expected_priors) self.assertEqual(model._parameter_names, expected_names)
def _make_model(self): sphere = Sphere(center=(Uniform(0, 1e-5, guess=.567e-5), Uniform(0, 1e-5, .567e-5), Uniform(1e-5, 2e-5)), r=Uniform(1e-8, 1e-5, 8.5e-7), n=Uniform(1, 2, 1.59)) model = AlphaModel(sphere, theory=Mie(False), alpha=Uniform(0.1, 1, 0.6)) return model
def test_add_3_way_tie(self): tied = prior.Uniform(-5, 5) n = prior.ComplexPrior(prior.Uniform(1, 2), prior.Uniform(0, 1)) sphere = Sphere(n=n, r=prior.Uniform(0.5, 1), center=[prior.Uniform(0, 1), prior.Uniform(0, 1), prior.Uniform(0, 10)]) model = AlphaModel(sphere) model.add_tie(['center.0', 'n.imag', 'center.1']) expected_map = [ dict, [[['n', [transformed_prior, [complex, ['_parameter_0', '_parameter_1']]]], ['r', '_parameter_2'], ['center', ['_parameter_1', '_parameter_1', '_parameter_3']]]]] expected_parameters = [prior.Uniform(1, 2), prior.Uniform(0, 1), prior.Uniform(0.5, 1), prior.Uniform(0, 10)] expected_names = ['n.real', 'n.imag', 'r', 'center.2'] self.assertEqual(model._maps['scatterer'], expected_map) self.assertEqual(model._parameters, expected_parameters) self.assertEqual(model._parameter_names, expected_names)
def test_find_noise(): noise = 0.5 s = Sphere(n=prior.Uniform(1.5, 1.7), r=2, center=[1, 2, 3]) data_base = detector_grid(10, spacing=0.5) data_noise = update_metadata(data_base, noise_sd=noise) model_u = AlphaModel(s, alpha=prior.Uniform(0.7, 0.9)) model_g = AlphaModel(s, alpha=prior.Gaussian(0.8, 0.1)) pars = {'n': 1.6, 'alpha': 0.8} assert_equal(model_u._find_noise(pars, data_noise), noise) assert_equal(model_g._find_noise(pars, data_noise), noise) assert_equal(model_u._find_noise(pars, data_base), 1) assert_raises(MissingParameter, model_g._find_noise, pars, data_base) pars.update({'noise_sd': noise}) assert_equal(model_g._find_noise(pars, data_base), noise)
def test_integer_correctness(): # we keep having bugs where the fitter doesn't schema = detector_grid(shape=10, spacing=1) s = Sphere(center=(10.2, 9.8, 10.3), r=.5, n=1.58) holo = calc_holo(schema, s, illum_wavelen=.660, medium_index=1.33, illum_polarization=(1, 0)) par_s = Sphere(r=.5, n=1.58, center=(Uniform(5, 15), Uniform(5, 15), Uniform(5, 15))) model = AlphaModel(par_s, alpha=Uniform(.1, 1, .6)) result = NmpfitStrategy().fit(model, holo) assert_allclose(result.scatterer.center, [10.2, 9.8, 10.3])
def make_model(): # Makes a model with all the paramters used in make_fake_data(), # but with the guesses slightly off from the true values center_guess = [ Uniform(0, 1e-5, name='x', guess=5.6e-6), Uniform(0, 1e-5, name='y', guess=5.8e-6), Uniform(1e-5, 2e-5, name='z', guess=14e-6), ] scatterer = Sphere(n=Uniform(1, 2, name='n', guess=1.55), r=Uniform(1e-8, 1e-5, name='r', guess=8.5e-7), center=center_guess) alpha = Uniform(0.1, 1, name='alpha', guess=0.6) theory = Mie(compute_escat_radial=False) model = AlphaModel(scatterer, theory=theory, alpha=alpha) return model
def fit(self): sphere_priors = self.make_guessed_scatterer() if self.theory == 'mielens': lens_prior = self.guess_lens_angle() model = PerfectLensModel( sphere_priors, noise_sd=self.data.noise_sd, lens_angle=lens_prior) elif self.theory == 'mieonly': alpha_prior = self.guess_alpha() model = AlphaModel( sphere_priors, noise_sd=self.data.noise_sd, alpha=alpha_prior) optimizer = NmpfitStrategy() result = optimizer.optimize(model, self.data) # FIXME this result sometimes leaves the allowed ranges. To get # result = hp.fitting.fit(model, self.data, minimizer=optimizer) return result