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)
