def setUp(self):
self.x = np.array([1, 2, 3])
self.y = np.array([1, 2, 3])
self.first_likelihood = GaussianLikelihood(
x=self.x,
y=self.y,
func=lambda x, param1, param2: (param1 + param2) * x,
sigma=1,
)
self.second_likelihood = PoissonLikelihood(
x=self.x, y=self.y, func=lambda x, param2, param3: (param2 + param3) * x
)
self.third_likelihood = ExponentialLikelihood(
x=self.x, y=self.y, func=lambda x, param4, param5: (param4 + param5) * x
)
self.joint_likelihood = JointLikelihood(
self.first_likelihood, self.second_likelihood, self.third_likelihood
)
self.first_likelihood.parameters["param1"] = 1
self.first_likelihood.parameters["param2"] = 2
self.second_likelihood.parameters["param2"] = 2
self.second_likelihood.parameters["param3"] = 3
self.third_likelihood.parameters["param4"] = 4
self.third_likelihood.parameters["param5"] = 5
self.joint_likelihood.parameters["param1"] = 1
self.joint_likelihood.parameters["param2"] = 2
self.joint_likelihood.parameters["param3"] = 3
self.joint_likelihood.parameters["param4"] = 4
self.joint_likelihood.parameters["param5"] = 5
def test_sigma_other(self):
likelihood = GaussianLikelihood(self.x,
self.y,
self.function,
sigma=None)
with self.assertRaises(ValueError):
likelihood.sigma = 'test'
def setUp(self):
self.likelihood = GaussianLikelihood(
x=np.linspace(0, 1, 2),
y=np.linspace(0, 1, 2),
func=lambda x, **kwargs: x,
sigma=1,
)
self.priors = PriorDict(dict(a=Uniform(0, 1), b=Uniform(0, 1)))
self._args = (self.likelihood, self.priors)
self._kwargs = dict(
outdir="outdir",
label="label",
use_ratio=False,
plot=False,
skip_import_verification=True,
)
self.sampler = Ptemcee(*self._args, **self._kwargs)
self.expected = dict(
ntemps=10,
nwalkers=100,
Tmax=None,
betas=None,
a=2.0,
adaptation_lag=10000,
adaptation_time=100,
random=None,
adapt=False,
swap_ratios=False,
)
def test_repr(self):
likelihood = GaussianLikelihood(self.x,
self.y,
self.function,
sigma=self.sigma)
expected = 'GaussianLikelihood(x={}, y={}, func={}, sigma={})' \
.format(self.x, self.y, self.function.__name__, self.sigma)
self.assertEqual(expected, repr(likelihood))
def test_sigma_float(self):
likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=None)
likelihood.parameters["m"] = 2
likelihood.parameters["c"] = 0
likelihood.parameters["sigma"] = 1
likelihood.log_likelihood()
self.assertTrue(likelihood.sigma == 1)
def test_set_sigma_None(self):
likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma=None)
likelihood.parameters["m"] = 2
likelihood.parameters["c"] = 0
self.assertTrue(likelihood.sigma is None)
with self.assertRaises(TypeError):
likelihood.log_likelihood()
def test_known_sigma(self):
likelihood = GaussianLikelihood(self.x, self.y, self.function,
self.sigma)
likelihood.parameters['m'] = 2
likelihood.parameters['c'] = 0
likelihood.log_likelihood()
self.assertEqual(likelihood.sigma, self.sigma)
def test_known_array_sigma(self):
sigma_array = np.ones(self.N) * self.sigma
likelihood = GaussianLikelihood(self.x, self.y, self.function, sigma_array)
likelihood.parameters["m"] = 2
likelihood.parameters["c"] = 0
likelihood.log_likelihood()
self.assertTrue(type(likelihood.sigma) == type(sigma_array))
self.assertTrue(all(likelihood.sigma == sigma_array))
time = np.arange(0, time_duration, 1 / sampling_frequency)
N = len(time)
data = model(time, **injection_parameters) + np.random.normal(0, sigma, N)
# We quickly plot the data to check it looks sensible
fig, ax = plt.subplots()
ax.plot(time, data, 'o', label='data')
ax.plot(time, model(time, **injection_parameters), '--r', label='signal')
ax.set_xlabel('time')
ax.set_ylabel('y')
ax.legend()
fig.savefig('{}/{}_data.png'.format(outdir, label))
# Now lets instantiate a version of our GaussianLikelihood, giving it
# the time, data and signal model
likelihood = GaussianLikelihood(time, data, model, sigma=sigma)
# From hereon, the syntax is exactly equivalent to other bilby examples
# We make a prior
priors = dict()
priors['m'] = bilby.core.prior.Uniform(0, 5, 'm')
priors['c'] = bilby.core.prior.Uniform(-2, 2, 'c')
# And run sampler
result = bilby.run_sampler(likelihood=likelihood,
priors=priors,
sampler='pymc3',
injection_parameters=injection_parameters,
outdir=outdir,
draws=2000,
label=label)
class TestJointLikelihood(unittest.TestCase):
def setUp(self):
self.x = np.array([1, 2, 3])
self.y = np.array([1, 2, 3])
self.first_likelihood = GaussianLikelihood(
x=self.x,
y=self.y,
func=lambda x, param1, param2: (param1 + param2) * x,
sigma=1,
)
self.second_likelihood = PoissonLikelihood(
x=self.x, y=self.y, func=lambda x, param2, param3: (param2 + param3) * x
)
self.third_likelihood = ExponentialLikelihood(
x=self.x, y=self.y, func=lambda x, param4, param5: (param4 + param5) * x
)
self.joint_likelihood = JointLikelihood(
self.first_likelihood, self.second_likelihood, self.third_likelihood
)
self.first_likelihood.parameters["param1"] = 1
self.first_likelihood.parameters["param2"] = 2
self.second_likelihood.parameters["param2"] = 2
self.second_likelihood.parameters["param3"] = 3
self.third_likelihood.parameters["param4"] = 4
self.third_likelihood.parameters["param5"] = 5
self.joint_likelihood.parameters["param1"] = 1
self.joint_likelihood.parameters["param2"] = 2
self.joint_likelihood.parameters["param3"] = 3
self.joint_likelihood.parameters["param4"] = 4
self.joint_likelihood.parameters["param5"] = 5
def tearDown(self):
del self.x
del self.y
del self.first_likelihood
del self.second_likelihood
del self.third_likelihood
del self.joint_likelihood
def test_parameters_consistent_from_init(self):
expected = dict(param1=1, param2=2, param3=3, param4=4, param5=5,)
self.assertDictEqual(expected, self.joint_likelihood.parameters)
def test_log_likelihood_correctly_sums(self):
expected = (
self.first_likelihood.log_likelihood()
+ self.second_likelihood.log_likelihood()
+ self.third_likelihood.log_likelihood()
)
self.assertEqual(expected, self.joint_likelihood.log_likelihood())
def test_log_likelihood_checks_parameter_updates(self):
self.first_likelihood.parameters["param2"] = 7
self.second_likelihood.parameters["param2"] = 7
self.joint_likelihood.parameters["param2"] = 7
expected = (
self.first_likelihood.log_likelihood()
+ self.second_likelihood.log_likelihood()
+ self.third_likelihood.log_likelihood()
)
self.assertEqual(expected, self.joint_likelihood.log_likelihood())
def test_list_element_parameters_are_updated(self):
self.joint_likelihood.parameters["param2"] = 7
self.assertEqual(
self.joint_likelihood.parameters["param2"],
self.joint_likelihood.likelihoods[0].parameters["param2"],
)
self.assertEqual(
self.joint_likelihood.parameters["param2"],
self.joint_likelihood.likelihoods[1].parameters["param2"],
)
def test_log_noise_likelihood(self):
self.first_likelihood.noise_log_likelihood = MagicMock(return_value=1)
self.second_likelihood.noise_log_likelihood = MagicMock(return_value=2)
self.third_likelihood.noise_log_likelihood = MagicMock(return_value=3)
self.joint_likelihood = JointLikelihood(
self.first_likelihood, self.second_likelihood, self.third_likelihood
)
expected = (
self.first_likelihood.noise_log_likelihood()
+ self.second_likelihood.noise_log_likelihood()
+ self.third_likelihood.noise_log_likelihood()
)
self.assertEqual(expected, self.joint_likelihood.noise_log_likelihood())
def test_init_with_list_of_likelihoods(self):
with self.assertRaises(ValueError):
JointLikelihood(
[self.first_likelihood, self.second_likelihood, self.third_likelihood]
)
def test_setting_single_likelihood(self):
self.joint_likelihood.likelihoods = self.first_likelihood
self.assertEqual(
self.first_likelihood.log_likelihood(),
self.joint_likelihood.log_likelihood(),
)
def test_setting_likelihood_other(self):
with self.assertRaises(ValueError):
self.joint_likelihood.likelihoods = "test"
true_sigma_c0 = 1
fig1, ax1 = plt.subplots()
fig2, ax2 = plt.subplots()
# Make the sample sets
results = list()
for i in range(Nevents):
c0 = np.random.normal(true_mu_c0, true_sigma_c0)
c1 = np.random.uniform(-1, 1)
injection_parameters = dict(c0=c0, c1=c1)
data = model(x, **injection_parameters) + np.random.normal(0, sigma, N)
line = ax1.plot(x, data, "-x", label=labels[i])
likelihood = GaussianLikelihood(x, data, model, sigma)
priors = dict(c0=Uniform(-10, 10, "c0"), c1=Uniform(-10, 10, "c1"))
result = run_sampler(
likelihood=likelihood,
priors=priors,
sampler="nestle",
nlive=1000,
outdir=outdir,
verbose=False,
label="individual_{}".format(i),
save=False,
injection_parameters=injection_parameters,
)
ax2.hist(
result.posterior.c0,
