def test_unequal_ties(self):
spheres = [
Sphere(n=Uniform(0, i + 1), r=Uniform(0, 1)) for i in range(3)
]
ties = {'r': ['0:r', '1:r', '2:r'], 'n': ['0:n', '1:n', '2:n']}
msg = 'Tied parameters 1:n and 0:n are not equal but have values'
self.assertRaisesRegex(ValueError, msg, Spheres, spheres, ties=ties)
def test_lnprob_fixed_real(self):
real = np.random.rand()
imag = Uniform(*(np.random.rand(2) + np.array([0, 1])))
cp = ComplexPrior(real, imag)
self.assertEqual(cp.lnprob(1), -np.inf)
self.assertEqual(cp.lnprob(1.0j), imag.lnprob(1))
self.assertEqual(cp.lnprob(1 + 1.0j), imag.lnprob(1))
def test_all_ties(self):
n = Uniform(0, 1)
r = Uniform(0, 1)
spheres = [Sphere(n=n, r=r, center=[i, i, i]) for i in range(3)]
spheres = Spheres(spheres)
expected_ties = ['0:n', '1:n', '2:n', '0:r', '1:r', '2:r']
self.assertEqual(spheres._all_ties, expected_ties)
def test_from_parameters(self):
n = Uniform(0, 1)
r = Uniform(0, np.pi / 2)
spheres = [Sphere(n=n, r=r, center=[i, i, i]) for i in range(3)]
spheres = Spheres(spheres)
parameters = spheres.parameters
self.assertEqual(spheres.guess, spheres.from_parameters(parameters))
def test_sample_multiple_priors_with_size(self):
base_prior = [Uniform(0, 1), Uniform(2, 3)]
transformed = TransformedPrior(np.maximum, base_prior)
sample = transformed.sample(100)
self.assertEqual(len(sample), 100)
self.assertTrue(isinstance(sample, np.ndarray))
self.assertTrue((2 < sample).all() and (sample < 3).all())
self.assertNotEqual(sample[0], sample[1])
def test_sample_shape(self):
n_samples = 7
bounds = np.random.rand(2) + np.array([0, 1])
u = Uniform(*bounds)
samples = u.sample(n_samples)
self.assertEqual(samples.shape, np.array(n_samples))
self.assertTrue(np.all(samples > bounds[0]))
self.assertTrue(np.all(samples < bounds[1]))
def test_sample_distribution(self):
n_samples = 1000
np.random.seed(805)
bounds = np.random.rand(2) + np.array([0, 1])
u = Uniform(*bounds)
samples = u.sample(n_samples)
p_val = kstest(samples, 'uniform', (bounds[0], np.diff(bounds)))[1]
self.assertTrue(p_val > 0.05)
def test_parameters_checks_ties(self):
spheres = [Sphere(n=Uniform(0, 1), r=Uniform(0, 1)) for i in range(3)]
ties = {'r': ['0:r', '1:r', '2:r'], 'n': ['0:n', '1:n', '2:n']}
spheres = Spheres(spheres, ties=ties)
spheres.ties['n'].append('dummy_name')
msg = 'Tied parameter dummy_name not present in raw parameters'
with self.assertRaisesRegex(ValueError, msg):
spheres.parameters
def test_add_tie(self):
spheres = [Sphere(n=Uniform(0, 1), r=Uniform(0, 1)) for i in range(3)]
spheres = Spheres(spheres)
spheres.add_tie('0:r', '1:r')
spheres.add_tie('r', '2:r')
spheres.add_tie('0:n', '1:n')
spheres.add_tie('0:n', '2:n')
expected_keys = {'n', 'r'}
self.assertEqual(set(spheres.parameters.keys()), expected_keys)
def test_save_and_open(self):
n = Uniform(0, 1)
r = Uniform(0, np.pi / 2)
spheres = [Sphere(n=n, r=r, center=[i, i, i]) for i in range(3)]
spheres = Spheres(spheres)
expected_keys = spheres.parameters.keys()
with tempfile.TemporaryDirectory() as tempdir:
hp.save(tempdir + '/test.out', spheres)
spheres = hp.load(tempdir + '/test.out')
self.assertEqual(spheres.parameters.keys(), expected_keys)
def test_sample_2_priors(self):
n_samples = 10
real = Uniform(*(np.random.rand(2) + np.array([0, 1])))
imag = Uniform(*(np.random.rand(2) + np.array([0, 1])))
cp = ComplexPrior(real, imag)
samples = cp.sample(n_samples)
self.assertTrue(np.all(samples.real < real.upper_bound))
self.assertTrue(np.all(samples.real > real.lower_bound))
self.assertTrue(np.all(samples.imag < imag.upper_bound))
self.assertTrue(np.all(samples.imag > imag.lower_bound))
def test_Composite_tying():
# tied parameters
n1 = Uniform(1.59, 1.6, guess=1.59)
sc = Spheres([
Sphere(n=n1, r=Uniform(0.5, 0.7), center=np.array([10., 10., 20.])),
Sphere(n=n1, r=Uniform(0.5, 0.7), center=np.array([9., 11., 21.]))
])
assert_equal(len(sc.parameters), 9)
assert_equal(sc.parameters['n'].guess, 1.59)
assert_equal(sc.parameters['0:r'], sc.parameters['1:r'])
def test_auto_guess_improper(self):
bound = np.random.rand()
u = Uniform(bound, np.inf)
self.assertEqual(u.guess, bound)
u = Uniform(-np.inf, bound)
self.assertEqual(u.guess, bound)
u = Uniform(-np.inf, np.inf)
self.assertEqual(u.guess, 0)
u = Uniform(-np.inf, np.inf, bound)
self.assertEqual(u.guess, bound)
def test_layered():
s = Sphere(n=(1, 2), r=(1, 2), center=(2, 2, 2))
sch = detector_grid((10, 10), .2)
hs = calc_holo(sch, s, 1, .66, (1, 0))
guess = LayeredSphere((1, 2), (Uniform(1, 1.01), Uniform(.99, 1)),
(2, 2, 2))
model = ExactModel(guess, calc_holo)
res = NmpfitStrategy().fit(model, hs)
assert_allclose(res.scatterer.t, (1, 1), rtol=1e-12)
def test_adding_newly_tied_scatterer(self):
n = Uniform(0, 1)
r = Uniform(0, 1)
spheres = [Sphere(n=n, r=r, center=[1, 1, 1])]
spheres = Spheres(spheres)
spheres.add(Sphere(n=n, r=r, center=[2, 2, 2]))
expected_keys = {
'n', 'r', '0:center.0', '0:center.1', '0:center.2', '1:center.0',
'1:center.1', '1:center.2'
}
self.assertEqual(set(spheres.parameters.keys()), expected_keys)
def test_tied_if_same_object(self):
n = Uniform(0, 1)
r = Uniform(0, 1)
spheres = [Sphere(n=n, r=r, center=[i, i, i]) for i in range(3)]
spheres = Spheres(spheres)
expected_keys = {
'n', 'r', '0:center.0', '0:center.1', '0:center.2', '1:center.0',
'1:center.1', '1:center.2', '2:center.0', '2:center.1',
'2:center.2'
}
self.assertEqual(set(spheres.parameters.keys()), expected_keys)
def test_tied_parameter_naming(self):
n = Uniform(0, 1)
r = [Uniform(0, 1), Uniform(0, 1)]
spheres = [Sphere(n=n, r=r[i % 2]) for i in range(4)]
spheres = Spheres(spheres)
expected_ties = {
'n': ['0:n', '1:n', '2:n', '3:n'],
'r': ['0:r', '2:r'],
'1:r': ['1:r', '3:r']
}
self.assertEqual(spheres.ties, expected_ties)
def test_adding_untied_scatterer(self):
n = Uniform(0, 1)
r = Uniform(0, 1)
spheres = [Sphere(n=n, r=r, center=[i, i, i]) for i in range(2)]
spheres = Spheres(spheres)
spheres.add(Sphere(n=1, r=1, center=[2, 2, 2]))
expected_keys = {
'n', 'r', '0:center.0', '0:center.1', '0:center.2', '1:center.0',
'1:center.1', '1:center.2', '2:n', '2:r', '2:center.0',
'2:center.1', '2:center.2'
}
self.assertEqual(set(spheres.parameters.keys()), expected_keys)
def test_scale_factor():
p1 = Gaussian(3, 1)
assert_equal(p1.scale_factor, 3)
p2 = Gaussian(0, 2)
assert_equal(p2.scale_factor, 2)
p4 = Uniform(-1, 1, 0)
assert_equal(p4.scale_factor, 0.2)
p5 = Uniform(1, 4)
assert_equal(p5.scale_factor, 2.5)
p6 = Uniform(0, np.inf)
assert_equal(p6.scale_factor, 1)
assert_equal(p2.scale(10), 5)
assert_equal(p2.unscale(5), 10)
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 test_sample_single_prior_with_size(self):
transformed = TransformedPrior(np.sqrt, Uniform(81, 100))
sample = transformed.sample(100)
self.assertEqual(len(sample), 100)
self.assertTrue(isinstance(sample, np.ndarray))
self.assertTrue((9 < sample).all() and (sample < 10).all())
self.assertNotEqual(sample[0], sample[1])
def test_construction_when_relying_argument_order(self):
parameters = OrderedDict([('lower_bound', 1), ('upper_bound', 3),
('guess', 2), ('name', 'a')])
u = Uniform(*parameters.values())
self.assertTrue(isinstance(u, Prior))
for key, val in parameters.items():
self.assertEqual(getattr(u, key), val)
def test_rdiv(self):
uniform = Uniform(1, 4, guess=3)
reciprocal = 1 / uniform
samples = reciprocal.sample(100)
self.assertEqual(reciprocal.guess, 1 / uniform.guess)
self.assertEqual(2 * reciprocal, 2 / uniform)
self.assertTrue(all(samples < 1) and all(samples > 1 / 4))
def test_transformation_by_constant(self):
base_prior = [Uniform(0, 5, guess=3), 2]
transform = TransformedPrior(np.maximum, base_prior)
samples = transform.sample(100)
self.assertEqual(transform.guess, 3)
self.assertTrue(all(samples < 5))
self.assertTrue(all(samples >= 2))
def make_uniform(guesses, key):
try:
guess_value = guesses[key]
except KeyError:
msg = 'Parameter {} not found in scatterer parameters.'.format(key)
raise ValueError(msg)
minval = 0 if key in ['n', 'r'] else -np.inf
return Uniform(minval, np.inf, guess_value, key)
def test_from_parameters():
s_prior = Sphere(n=1.6, r=Uniform(0.5, 0.7), center=[10, 10, 10])
s_guess = Sphere(n=1.6, r=0.6, center=[10, 10, 10])
s_new_r = Sphere(n=1.6, r=0.7, center=[10, 10, 10])
s_new_nr = Sphere(n=1.7, r=0.7, center=[10, 10, 10])
pars = {'n': 1.7, 'r': 0.7}
assert_equal(s_prior.from_parameters({}), s_guess)
assert_equal(s_prior.from_parameters(pars, overwrite=False), s_new_r)
assert_equal(s_prior.from_parameters(pars, overwrite=True), s_new_nr)
def test_hierarchical_transformed_prior(self):
base_prior = Uniform(10, 20, guess=16)
transform = TransformedPrior(np.sqrt, base_prior)
double = TransformedPrior(np.sqrt, transform)
samples = double.sample(100)
self.assertEqual(double.guess, 2)
self.assertTrue(
all(samples < np.sqrt(np.sqrt(20)))
and all(samples > np.sqrt(np.sqrt(10))))
def __new__(self, guess=None, limit=None, name=None, **kwargs):
fit_warning('hp.inference.prior', 'Parameter')
if len(ensure_listlike(limit)) == 2:
if limit[0] == limit[1]:
return Parameter(guess, limit[0])
out = Uniform(limit[0], limit[1], guess, name)
elif guess is None and limit is not None:
return limit
elif guess == limit and limit is not None:
return guess
elif limit is None and guess is not None:
out = Uniform(-np.inf, np.inf, guess, name)
else:
raise ParameterSpecificationError(
"Can't interpret Parameter with limit {} and guess {}".format(
limit, guess))
setattr(out, 'limit', limit)
setattr(out, 'kwargs', kwargs)
return out
def test_generate_guess():
gold1 = np.array([[-0.091949, 0.270532], [-1.463350, 0.691041],
[1.081791, 0.220404], [-0.239325, 0.811950],
[-0.491129, 0.010526]])
gold2 = np.array([[-0.045974, 0.535266], [-0.731675, 0.745520],
[0.540895, 0.510202], [-0.119662, 0.805975],
[-0.245564, 0.405263]])
pars = [Gaussian(0, 1), Uniform(0, 1, 0.8)]
guess1 = generate_guess(pars, 5, seed=22)
guess2 = generate_guess(pars, 5, scaling=0.5, seed=22)
assert_allclose(guess1, gold1, atol=1e-5)
assert_allclose(guess2, gold2, atol=1e-5)
def test_prob_2_priors(self):
real = Uniform(*(np.random.rand(2) + np.array([0, 1])))
imag = Uniform(*(np.random.rand(2) + np.array([0, 1])))
cp = ComplexPrior(real, imag)
self.assertEqual(cp.prob(1), 0)
self.assertEqual(cp.prob(1.0j), 0)
self.assertAlmostEqual(cp.prob(1 + 1.0j), real.prob(1) * imag.prob(1))
def test_uniform():
u = Uniform(0, 1)
assert_equal(u.lnprob(.4), 0)
assert_equal(u.lnprob(-.1), -np.inf)
assert_equal(u.lnprob(4), -np.inf)
assert_equal(u.guess, .5)
