def from_results_internal( cls, results_internal: np.ndarray, log_posterior_list: np.ndarray, model: AbstractPriorModel, total_iterations: int, time: Optional[float] = None, ): """ The `Samples` classes in **PyAutoFit** provide an interface between the results of a `NonLinearSearch` (e.g. as files on your hard-disk) and Python. To create a `Samples` object after an `pyswarms` model-fit the results must be converted from the native format used by `pyswarms` (which are numpy ndarrays) to lists of values, the format used by the **PyAutoFit** `Samples` objects. This classmethod performs this conversion before creating a `PySwarmsSamples` object. Parameters ---------- results_internal The Pyswarms results in their native internal format from which the samples are computed. log_posterior_list The log posterior of the PySwarms accepted samples. model Maps input vectors of unit parameter values to physical values and model instances via priors. total_iterations The total number of PySwarms iterations, which cannot be estimated from the sample list (which contains only accepted samples). time The time taken to perform the model-fit, which is passed around `Samples` objects for outputting information on the overall fit. """ parameter_lists = [ param.tolist() for parameters in results_internal for param in parameters ] log_prior_list = model.log_prior_list_from( parameter_lists=parameter_lists) log_likelihood_list = [ lp - prior for lp, prior in zip(log_posterior_list, log_prior_list) ] weight_list = len(log_likelihood_list) * [1.0] sample_list = Sample.from_lists( model=model, parameter_lists=[ parameters.tolist()[0] for parameters in results_internal ], log_likelihood_list=log_likelihood_list, log_prior_list=log_prior_list, weight_list=weight_list) return PySwarmsSamples( model=model, sample_list=sample_list, total_iterations=total_iterations, time=time, results_internal=results_internal, )
def from_results_internal( cls, results_internal: Results, model: AbstractPriorModel, number_live_points: int, unconverged_sample_size: int = 100, time: Optional[float] = None, ): """ The `Samples` classes in **PyAutoFit** provide an interface between the results of a `NonLinearSearch` (e.g. as files on your hard-disk) and Python. To create a `Samples` object after a `dynesty` model-fit the results must be converted from the native format used by `dynesty` to lists of values, the format used by the **PyAutoFit** `Samples` objects. This classmethod performs this conversion before creating a `DynestySamples` object. Parameters ---------- results_internal The `dynesty` results in their native internal format from which the samples are computed. model Maps input vectors of unit parameter values to physical values and model instances via priors. number_live_points The number of live points used by the `dynesty` search. unconverged_sample_size If the samples are for a search that is yet to convergence, a reduced set of samples are used to provide a rough estimate of the parameters. The number of samples is set by this parameter. time The time taken to perform the model-fit, which is passed around `Samples` objects for outputting information on the overall fit. """ parameter_lists = results_internal.samples.tolist() log_prior_list = model.log_prior_list_from(parameter_lists=parameter_lists) log_likelihood_list = list(results_internal.logl) try: weight_list = list( np.exp(np.asarray(results_internal.logwt) - results_internal.logz[-1]) ) except: weight_list = results_internal["weights"] sample_list = Sample.from_lists( model=model, parameter_lists=parameter_lists, log_likelihood_list=log_likelihood_list, log_prior_list=log_prior_list, weight_list=weight_list, ) return DynestySamples( model=model, sample_list=sample_list, number_live_points=number_live_points, unconverged_sample_size=unconverged_sample_size, time=time, results_internal=results_internal, )
def from_results_internal( cls, results_internal, model: AbstractPriorModel, auto_correlation_settings: AutoCorrelationsSettings, unconverged_sample_size: int = 100, time: Optional[float] = None, ): """ The `Samples` classes in **PyAutoFit** provide an interface between the results of a `NonLinearSearch` (e.g. as files on your hard-disk) and Python. To create a `Samples` object after an `Zeus` model-fit the results must be converted from the native format used by `Zeus` (which is a HDFBackend) to lists of values, the format used by the **PyAutoFit** `Samples` objects. This classmethod performs this conversion before creating a `ZeusSamples` object. Parameters ---------- results_internal The MCMC results in their native internal format from which the samples are computed. model Maps input vectors of unit parameter values to physical values and model instances via priors. auto_correlations_settings Customizes and performs auto correlation calculations performed during and after the search. unconverged_sample_size If the samples are for a search that is yet to convergence, a reduced set of samples are used to provide a rough estimate of the parameters. The number of samples is set by this parameter. time The time taken to perform the model-fit, which is passed around `Samples` objects for outputting information on the overall fit. """ parameter_lists = results_internal.get_chain(flat=True).tolist() log_posterior_list = results_internal.get_log_prob(flat=True).tolist() log_prior_list = model.log_prior_list_from( parameter_lists=parameter_lists) log_likelihood_list = [ log_posterior - log_prior for log_posterior, log_prior in zip( log_posterior_list, log_prior_list) ] weight_list = len(log_likelihood_list) * [1.0] sample_list = Sample.from_lists( model=model, parameter_lists=parameter_lists, log_likelihood_list=log_likelihood_list, log_prior_list=log_prior_list, weight_list=weight_list) return ZeusSamples( model=model, sample_list=sample_list, auto_correlation_settings=auto_correlation_settings, unconverged_sample_size=unconverged_sample_size, time=time, results_internal=results_internal, )