def __init__(self, model, data):
self.data = data
if isinstance(model, list):
model = Model(model)
elif not isinstance(model, Model):
model = Model([model])
self.model = model
def rejection_sample_posterior(event_samples: Dict[str, List],
hyper_param: dict,
n_draws=2000) -> pd.DataFrame:
# event_samples['cos_tilt_1'] = event_samples['cos_theta_1']
model = Model(model_functions=[agn_spin])
model.parameters.update(hyper_param)
weights = np.array(model.prob(event_samples) / PRIOR_VOLUME)
weights = weights / np.linalg.norm(weights)
event_samples['weights'] = weights
event_samples = pd.DataFrame(event_samples)
event_samples = event_samples.sample(n_draws, weights=weights)
event_samples = event_samples.to_dict('list')
return event_samples
def __init__(self, model, data):
self.vts = data.pop("vt")
self.data = data
if isinstance(model, list):
model = Model(model)
elif not isinstance(model, Model):
model = Model([model])
self.model = model
self.values = {key: xp.unique(self.data[key]) for key in self.data}
shape = np.array(list(self.data.values())[0].shape)
lens = {key: len(self.values[key]) for key in self.data}
self.axes = {
int(np.where(shape == lens[key])[0]): key
for key in self.data
}
self.ndim = len(self.axes)
def __init__(self,
posteriors,
hyper_prior,
sampling_prior=None,
ln_evidences=None,
max_samples=1e100,
selection_function=lambda args: 1,
conversion_function=lambda args: (args, None),
cupy=True):
"""
Parameters
----------
posteriors: list
An list of pandas data frames of samples sets of samples.
Each set may have a different size.
These can contain a `prior` column containing the original prior
values.
hyper_prior: `bilby.hyper.model.Model`
The population model, this can alternatively be a function.
sampling_prior: `bilby.hyper.model.Model` *DEPRECATED*
The sampling prior, this can alternatively be a function.
ln_evidences: list, optional
Log evidences for single runs to ensure proper normalisation
of the hyperparameter likelihood. If not provided, the original
evidences will be set to 0. This produces a Bayes factor between
the sampling power_prior and the hyperparameterised model.
selection_function: func
Function which evaluates your population selection function.
conversion_function: func
Function which converts a dictionary of sampled parameter to a
dictionary of parameters of the population model.
max_samples: int, optional
Maximum number of samples to use from each set.
cupy: bool
If True and a compatible CUDA environment is available,
cupy will be used for performance.
Note: this requires setting up your hyper_prior properly.
"""
if cupy and not CUPY_LOADED:
logger.warning('Cannot import cupy, falling back to numpy.')
self.samples_per_posterior = max_samples
self.data = self.resample_posteriors(posteriors,
max_samples=max_samples)
if not isinstance(hyper_prior, Model):
hyper_prior = Model([hyper_prior])
self.hyper_prior = hyper_prior
Likelihood.__init__(self, hyper_prior.parameters)
if sampling_prior is not None:
logger.warning('Passing a sampling_prior is deprecated. This '
'should be passed as a column in the posteriors.')
if not isinstance(sampling_prior, Model):
sampling_prior = Model([sampling_prior])
self.sampling_prior = sampling_prior.prob(self.data)
elif 'prior' in self.data:
self.sampling_prior = self.data.pop('prior')
else:
logger.info('No prior values provided, defaulting to 1.')
self.sampling_prior = 1
if ln_evidences is not None:
self.total_noise_evidence = np.sum(ln_evidences)
else:
self.total_noise_evidence = np.nan
self.conversion_function = conversion_function
self.selection_function = selection_function
self.n_posteriors = len(posteriors)
self.samples_factor =\
- self.n_posteriors * np.log(self.samples_per_posterior)
def __init__(
self,
posteriors,
hyper_prior,
sampling_prior=None,
ln_evidences=None,
max_samples=1e100,
selection_function=lambda args: 1,
conversion_function=lambda args: (args, None),
cupy=True,
):
"""
Parameters
----------
posteriors: list
An list of pandas data frames of samples sets of samples.
Each set may have a different size.
These can contain a `prior` column containing the original prior
values.
hyper_prior: `bilby.hyper.model.Model`
The population model, this can alternatively be a function.
sampling_prior: array-like *DEPRECATED*
The sampling prior, this can alternatively be a function.
THIS WILL BE REMOVED IN THE NEXT RELEASE.
ln_evidences: list, optional
Log evidences for single runs to ensure proper normalisation
of the hyperparameter likelihood. If not provided, the original
evidences will be set to 0. This produces a Bayes factor between
the sampling power_prior and the hyperparameterised model.
selection_function: func
Function which evaluates your population selection function.
conversion_function: func
Function which converts a dictionary of sampled parameter to a
dictionary of parameters of the population model.
max_samples: int, optional
Maximum number of samples to use from each set.
cupy: bool
If True and a compatible CUDA environment is available,
cupy will be used for performance.
Note: this requires setting up your hyper_prior properly.
"""
if cupy and not CUPY_LOADED:
logger.warning("Cannot import cupy, falling back to numpy.")
self.samples_per_posterior = max_samples
self.data = self.resample_posteriors(posteriors,
max_samples=max_samples)
if isinstance(hyper_prior, types.FunctionType):
hyper_prior = Model([hyper_prior])
elif not (hasattr(hyper_prior, 'parameters')
and callable(getattr(hyper_prior, 'prob'))):
raise AttributeError(
"hyper_prior must either be a function, "
"or a class with attribute 'parameters' and method 'prob'")
self.hyper_prior = hyper_prior
Likelihood.__init__(self, hyper_prior.parameters)
if sampling_prior is not None:
raise ValueError(
"Passing a sampling_prior is deprecated and will be removed "
"in the next release. This should be passed as a 'prior' "
"column in the posteriors.")
elif "prior" in self.data:
self.sampling_prior = self.data.pop("prior")
else:
logger.info("No prior values provided, defaulting to 1.")
self.sampling_prior = 1
if ln_evidences is not None:
self.total_noise_evidence = np.sum(ln_evidences)
else:
self.total_noise_evidence = np.nan
self.conversion_function = conversion_function
self.selection_function = selection_function
self.n_posteriors = len(posteriors)
def test_base_cannot_be_called(self):
model = Model([dummy_function, dummy_function])
evaluator = vt._BaseVT(model=model, data=dict())
with self.assertRaises(NotImplementedError):
evaluator()
def test_initialize_with_bilby_model(self):
model = Model([dummy_function, dummy_function])
evaluator = vt._BaseVT(model=model, data=dict())
self.assertTrue(
evaluator.model.models == [dummy_function, dummy_function])