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
