def jet_loglikelihood(self, pars_list, neg=False):
# Iterate over individual lobe region log-likelihoods and sum
jet_res = 0 #
for i, item in enumerate(self.jet_data):
rmf = self.jet_data[i].get_rmf()
erange = np.array(
rmf.e_min
) # need to convert to numpy array to use a double mask
bounds = (erange > self.e_min) & (erange < self.e_max)
model = self.jet_models[i]
data = self.jet_data[i]
pars = pars_list[i, :]
model._set_thawed_pars(pars)
mean_model = data.eval_model(model)
#stupid hack to make it not go -infinity
mean_model += np.exp(-20.)
res = np.nansum(-mean_model[bounds] +
data.counts[bounds] * np.log(mean_model[bounds]) -
scipy_gammaln(data.counts[bounds] + 1.))
if not np.isfinite(res):
res = -logmin
jet_res += res
if neg:
return -jet_res
else:
return jet_res
def test_negative_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = -np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def test_negative_loglikelihood(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
loglike = -np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
loglike_test = lpost.loglikelihood(t0, neg=True)
assert np.isclose(loglike, loglike_test)
def testGammalnExecution(self):
raw = np.random.rand(10, 8, 6)
a = tensor(raw, chunk_size=3)
r = gammaln(a)
result = self.executor.execute_tensor(r, concat=True)[0]
expected = scipy_gammaln(raw)
np.testing.assert_array_equal(result, expected)
# test sparse
raw = sps.csr_matrix(np.array([0, 1.0, 1.01, np.nan]))
a = tensor(raw, chunk_size=3)
r = gammaln(a)
result = self.executor.execute_tensor(r, concat=True)[0]
data = scipy_gammaln(raw.data)
expected = sps.csr_matrix((data, raw.indices, raw.indptr), raw.shape)
np.testing.assert_array_equal(result.toarray(), expected.toarray())
def test_negative_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=True)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
logprior = np.log(scipy.stats.norm(self.countrate, self.countrate).pdf(t0))
post = -loglike - logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_negative_posterior(self):
t0 = [10.0]
self.model.amplitude = t0[0]
mean_model = self.model(self.x)
lpost = PoissonPosterior(self.x, self.y, self.model)
lpost.logprior = set_logprior(lpost, self.priors)
post_test = lpost(t0, neg=True)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) - scipy_gammaln(self.y+1))
logprior = np.log(scipy.stats.norm(self.countrate, self.countrate).pdf(t0))
post = -loglike - logprior
assert np.isclose(post_test, post, atol=1.e-10)
def test_gammaln():
raw = np.random.rand(10, 8, 5)
t = tensor(raw, chunk_size=3)
r = gammaln(t)
expect = scipy_gammaln(raw)
assert r.shape == raw.shape
assert r.dtype == expect.dtype
t, r = tile(t, r)
assert r.nsplits == t.nsplits
for c in r.chunks:
assert isinstance(c.op, TensorGammaln)
assert c.index == c.inputs[0].index
assert c.shape == c.inputs[0].shape
def testGammaln(self):
raw = np.random.rand(10, 8, 5)
t = tensor(raw, chunk_size=3)
r = gammaln(t)
expect = scipy_gammaln(raw)
self.assertEqual(r.shape, raw.shape)
self.assertEqual(r.dtype, expect.dtype)
r.tiles()
self.assertEqual(r.nsplits, t.nsplits)
for c in r.chunks:
self.assertIsInstance(c.op, TensorGammaln)
self.assertEqual(c.index, c.inputs[0].index)
self.assertEqual(c.shape, c.inputs[0].shape)
def evaluate(self, pars, neg=False):
"""
Evaluate the log-likelihood for a given set of parameters.
Parameters
----------
pars : numpy.ndarray
An array of parameters at which to evaluate the model
and subsequently the log-likelihood. Note that the
length of this array must match the free parameters in
``model``, i.e. ``npar``
neg : bool, optional, default ``False``
If ``True``, return the *negative* log-likelihood, i.e.
``-loglike``, rather than ``loglike``. This is useful e.g.
for optimization routines, which generally minimize
functions.
Returns
-------
loglike : float
The log(likelihood) value for the data and model.
"""
if np.size(pars) != self.npar:
raise IncorrectParameterError("Input parameters must" +
" match model parameters!")
_fitter_to_model_params(self.model, pars)
mean_model = self.model(self.x)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) \
- scipy_gammaln(self.y + 1.))
if not np.isfinite(loglike):
loglike = logmin
if neg:
return -loglike
else:
return loglike
def evaluate(self, pars, neg=False):
"""
Evaluate the log-likelihood for a given set of parameters.
Parameters
----------
pars : numpy.ndarray
An array of parameters at which to evaluate the model
and subsequently the log-likelihood. Note that the
length of this array must match the free parameters in
``model``, i.e. ``npar``
neg : bool, optional, default ``False``
If ``True``, return the *negative* log-likelihood, i.e.
``-loglike``, rather than ``loglike``. This is useful e.g.
for optimization routines, which generally minimize
functions.
Returns
-------
loglike : float
The log(likelihood) value for the data and model.
"""
if np.size(pars) != self.npar:
raise IncorrectParameterError("Input parameters must" +
" match model parameters!")
_fitter_to_model_params(self.model, pars)
mean_model = self.model(self.x)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) \
- scipy_gammaln(self.y + 1.))
if not np.isfinite(loglike):
loglike = logmin
if neg:
return -loglike
else:
return loglike
def evaluate(self, pars, neg=False):
if np.size(pars) != self.npar:
raise IncorrectParameterError("Input parameters must" +
" match model parameters!")
_fitter_to_model_params(self.model, pars)
mean_model = self.model(self.x)
loglike = np.sum(-mean_model + self.y*np.log(mean_model) \
- scipy_gammaln(self.y + 1.))
if not np.isfinite(loglike):
loglike = logmin
if neg:
return -loglike
else:
return loglike
