def test_complex_compound_name(self): model = SimpleModel() parameter = prior.ComplexPrior(prior.Uniform(0, 1), prior.Uniform(2, 3)) model._convert_to_map(parameter, 'prefix') self.assertEqual(model._parameter_names[-2], 'prefix.real') self.assertEqual(model._parameter_names[-1], 'prefix.imag')
def test_run_cma(): popsize = 10 pars = [prior.Uniform(0, 1), prior.Uniform(0, 1)] ndim = len(pars) p0 = np.linspace(0, 1, popsize * ndim).reshape((popsize, ndim)) r = run_cma(simplefunc, pars, p0, weightfunc, tols, seed=1) assert_allclose(r.logger.xrecent.mean(), 3, rtol=.01)
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_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 _make_center_priors(self, params): image_x_values = self.data.x.values image_min_x = image_x_values.min() image_max_x = image_x_values.max() image_y_values = self.data.y.values image_min_y = image_y_values.min() image_max_y = image_y_values.max() if ('x' not in params) or ('y' not in params): pixel_spacing = get_spacing(self.data) image_lower_left = np.array([image_min_x, image_min_y]) center = center_find(self.data) * pixel_spacing + image_lower_left else: center = [params['x'], params['y']] xpar = prior.Uniform(image_min_x, image_max_x, guess=center[0]) ypar = prior.Uniform(image_min_y, image_max_y, guess=center[1]) extents = get_extents(self.data) extent = max(extents['x'], extents['y']) zextent = 5 zpar = prior.Uniform( -extent * zextent, extent * zextent, guess=params['z']) return xpar, ypar, zpar
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_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_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_minimizer(): x = np.arange(-10, 10, .1) a = 5.3 b = -1.8 c = 3.4 gold_list = [a, b, c] y = a * x**2 + b * x + c # This test does NOT handle scaling correctly -- we would need a Model # which knows the parameters to properly handle the scaling/unscaling def cost_func(pars): a, b, c = pars return a * x**2 + b * x + c - y # test basic usage parameters = [ prior.Uniform(-np.inf, np.inf, name='a', guess=5), prior.Uniform(-np.inf, np.inf, name='b', guess=-2), prior.Uniform(-np.inf, np.inf, name='c', guess=3) ] minimizer = Nmpfit() result, minimization_details = minimizer.minimize(parameters, cost_func) assert_obj_close(result, gold_list, context='basic_minimized_parameters') # now test limiting minimizer iterations minimizer = Nmpfit(maxiter=1) try: result, minimization_details = minimizer.minimize( parameters, cost_func) except MinimizerConvergenceFailed as cf: # the fit shouldn't converge result, minimization_details = cf.result, cf.details assert_equal(minimization_details.niter, 2) # there's always an offset of 1
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_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 __init__(self, npars=2): self._parameters = [ prior.Uniform(0, 1, name='x'), prior.Uniform(0, 1, name='y') ][:npars] self.constraints = [] self.noise_sd = 1
def make_scatterer(self, params): center = self._make_center_priors(params) index = prior.Uniform( self._min_index, self._max_index, guess=params['n']) radius = prior.Uniform( self._min_radius, self._max_radius, guess=params['r']) scatterer = Sphere(n=index, r=radius, center=center) return scatterer
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_map_list(self): model = SimpleModel() parameter = [0, prior.Uniform(0, 1), prior.Uniform(2, 3)] position = len(model._parameters) parameter_map = model._convert_to_map(parameter) expected = [0, "_parameter_{}".format(position), "_parameter_{}".format(position + 1)] self.assertEqual(parameter_map, 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_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_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_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_map_hierarchical_transformed_prior(self): model = SimpleModel() inner = prior.TransformedPrior(np.sqrt, prior.Uniform(0, 2)) full = prior.TransformedPrior(np.maximum, [inner, prior.Uniform(0, 1)]) position = len(model._parameters) parameter_map = model._convert_to_map(full) placeholder = ['_parameter_{}'.format(position + i) for i in range(2)] submap = [transformed_prior, [np.sqrt, [placeholder[0]]]] expected = [transformed_prior, [np.maximum, [submap, placeholder[1]]]]
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_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_pullingoutguess(): g = Sphere(center=(prior.Uniform(0, 1e-5, guess=.567e-5), prior.Uniform(0, 1e-5, .567e-5), prior.Uniform(1e-5, 2e-5, 15e-6)), r=prior.Uniform(1e-8, 1e-5, 8.5e-7), n=prior.ComplexPrior(prior.Uniform(1, 2, 1.59), 1e-4)) model = ExactModel(g, calc_holo) s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7) assert_equal(s.n, model.scatterer.guess.n) assert_equal(s.r, model.scatterer.guess.r) assert_equal(s.center, model.scatterer.guess.center) g = Sphere(center=(prior.Uniform(0, 1e-5, guess=.567e-5), prior.Uniform(0, 1e-5, .567e-5), prior.Uniform(1e-5, 2e-5, 15e-6)), r=prior.Uniform(1e-8, 1e-5, 8.5e-7), n=1.59 + 1e-4j) model = ExactModel(g, calc_holo) s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7) assert_equal(s.n, model.scatterer.guess.n) assert_equal(s.r, model.scatterer.guess.r) assert_equal(s.center, model.scatterer.guess.center)
def test_parameterize_scatterer_spheres_by_given(self): s1 = Sphere(r=0.5, n=1, center=[0, 0, 0]) s2 = Sphere(r=0.5, n=1, center=[1, 1, 1]) model = make_default_model(Spheres([s1, s2]), ['0:r', '1:x']) e1 = Sphere(r=prior.Uniform(0, np.inf, 0.5, '0:r'), n=1, center=[0, 0, 0]) e2 = Sphere(r=0.5, n=1, center=[prior.Uniform(-np.inf, np.inf, 1, '1:x'), 1, 1]) self.assertEqual(model.scatterer, Spheres([e1, e2]))
def test_run_cma_returns_reproducible_answer(): # If this test fails, it could be either a change in holopy code # or a change in the cma package code. popsize = 10 pars = [prior.Uniform(0, 1), prior.Uniform(0, 1)] ndim = len(pars) p0 = np.linspace(0, 1, popsize * ndim).reshape((popsize, ndim)) r = run_cma(simplefunc, pars, p0, weightfunc, tols, seed=1) found = r.logger.xrecent.mean() correct = 2.876866703907526 assert_allclose(found, correct, rtol=1e-3)
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_read_hierarchical_transformed(self): inner_map = [transformed_prior, [np.sqrt, ['_parameter_0']]] parameter_map = [transformed_prior, [np.maximum, ['_parameter_1', inner_map]]] priors = [prior.Uniform(0, 1), prior.Uniform(1, 2)] expected_base = [prior.Uniform(1, 2), prior.TransformedPrior(np.sqrt, prior.Uniform(0, 1))] expected_full = prior.TransformedPrior(np.maximum, expected_base) self.assertEqual(read_map(parameter_map, priors), expected_full) values = [25, 7] self.assertEqual(read_map(inner_map, values), 5) self.assertEqual(read_map(parameter_map, values), 7)
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_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)