def prior_from_config(cp, prior_section='prior'): """Loads a prior distribution from the given config file. Parameters ---------- cp : pycbc.workflow.WorkflowConfigParser The config file to read. sections : list of str, optional The sections to retrieve the prior from. If ``None`` (the default), will look in sections starting with 'prior'. Returns ------- distributions.JointDistribution The prior distribution. """ # Read variable and static parameters from the config file variable_params, _ = distributions.read_params_from_config( cp, prior_section=prior_section, vargs_section='variable_params', sargs_section='static_params') # Read constraints to apply to priors from the config file constraints = distributions.read_constraints_from_config(cp) # Get PyCBC distribution instances for each variable parameter in the # config file dists = distributions.read_distributions_from_config(cp, prior_section) # construct class that will return draws from the prior return distributions.JointDistribution(variable_params, *dists, **{"constraints": constraints})
def prior_from_config(cp, variable_params, prior_section, constraint_section): """Gets arguments and keyword arguments from a config file. Parameters ---------- cp : WorkflowConfigParser Config file parser to read. variable_params : list List of of model parameter names. prior_section : str Section to read prior(s) from. constraint_section : str Section to read constraint(s) from. Returns ------- pycbc.distributions.JointDistribution The prior. """ # get prior distribution for each variable parameter logging.info("Setting up priors for each parameter") dists = distributions.read_distributions_from_config(cp, prior_section) constraints = distributions.read_constraints_from_config( cp, constraint_section) return distributions.JointDistribution(variable_params, *dists, constraints=constraints)
def __init__(self, config_file, random_seed): # Fix the seed for the random number generator np.random.seed(random_seed) # Read in the configuration file using a WorkflowConfigParser. # Note that the argument `configFiles` has to be a list here, # so we need to wrap the `config_file` argument accordingly... config_file = WorkflowConfigParser(configFiles=[config_file]) # Extract variable arguments and constraints # We don't need the static_args here, hence they do not get amended. self.var_args, _ = read_params_from_config(config_file) self.constraints = read_constraints_from_config(config_file) # Extract distributions dist = read_distributions_from_config(config_file) # Extract transformations self.trans = read_transforms_from_config(config_file) # Set up a joint distribution to sample from self.pval = JointDistribution(self.var_args, *dist, **{'constraints': self.constraints})
def setUp(self): # set random seed numpy.random.seed(1024) # path to example configuration file for testing config_path = "/".join([os.path.dirname(os.path.realpath(__file__)), "../examples/distributions/example.ini"]) # get a set of simulated command line options for # configuration file reading class Arguments(object): config_overrides = [] config_delete = [] config_files = [config_path] self.opts = Arguments() # read configuration files self.cp = WorkflowConfigParser.from_cli(self.opts) self.variable_args, self.static_args = \ distributions.read_params_from_config(self.cp) self.constraints = distributions.read_constraints_from_config(self.cp) # read distributions self.dists = distributions.read_distributions_from_config(self.cp) # check that all distriubtions will be tested for dname in distributions.distribs: dclass = distributions.distribs[dname] if (not numpy.any([isinstance(dist, dclass) for dist in self.dists]) and dname not in EXCLUDE_DIST_NAMES): raise ValueError("There is no test for {}".format(dname))
def initial_dist_from_config(cp, variable_params): r"""Loads a distribution for the sampler start from the given config file. A distribution will only be loaded if the config file has a [initial-\*] section(s). Parameters ---------- cp : Config parser The config parser to try to load from. variable_params : list of str The variable parameters for the distribution. Returns ------- JointDistribution or None : The initial distribution. If no [initial-\*] section found in the config file, will just return None. """ if len(cp.get_subsections("initial")): logging.info("Using a different distribution for the starting points " "than the prior.") initial_dists = distributions.read_distributions_from_config( cp, section="initial") constraints = distributions.read_constraints_from_config( cp, constraint_section="initial_constraint") init_dist = distributions.JointDistribution( variable_params, *initial_dists, **{"constraints": constraints}) else: init_dist = None return init_dist
def __init__( self, config_files: Union[List[Union[str, os.PathLike]], Union[str, os.PathLike]], seed: Optional[int] = None, ): """Class to generate gravitational waveform parameters using PyCBC workflow and distribution packages. """ if seed is not None: raise NotImplementedError( "Reproducible random seed not yet implemented.") self.config_files = config_files if isinstance( config_files, list) else [config_files] self.config_parser = WorkflowConfigParser( configFiles=self.config_files) self.parameters, self.static_args = read_params_from_config( self.config_parser) self.constraints = read_constraints_from_config(self.config_parser) self.transforms = read_transforms_from_config(self.config_parser) self.distribution = JointDistribution( self.parameters, *read_distributions_from_config(self.config_parser), **{'constraints': self.constraints}) # ensure statistics match output of self.parameters self.statistics = compute_parameter_statistics({ parameter: self.distribution.bounds[parameter] for parameter in self.parameters })
def from_config(cls, cp, model, nprocesses=1, use_mpi=False): """Loads the sampler from the given config file.""" section = "sampler" # check name assert cp.get(section, "name") == cls.name, ( "name in section [sampler] must match mine") # get the number of live points to use nlivepoints = int(cp.get(section, "nlivepoints")) # get the checkpoint interval, if it's specified checkpoint = get_optional_arg_from_config( cp, section, 'checkpoint-interval', dtype=int) # get the evidence tolerance, if specified ztol = get_optional_arg_from_config(cp, section, 'evidence-tolerance', dtype=float) # get the sampling efficiency, if specified eff = get_optional_arg_from_config(cp, section, 'sampling-efficiency', dtype=float) # get importance nested sampling setting, if specified ins = get_optional_arg_from_config(cp, section, 'importance-nested-sampling', dtype=bool) # get constraints since we can't use the joint prior distribution constraints = read_constraints_from_config(cp) # build optional kwarg dict kwarg_names = ['evidence_tolerance', 'sampling_efficiency', 'importance_nested_sampling', 'checkpoint_interval'] optional_kwargs = {k: v for k, v in zip(kwarg_names, [ztol, eff, ins, checkpoint]) if v is not None} obj = cls(model, nlivepoints, constraints=constraints, **optional_kwargs) return obj
def draw_samples_from_config(path, num=1, seed=150914): r""" Generate sampling points from a standalone .ini file. Parameters ---------- path : str The path to the .ini file. num : int The number of samples. seed: int The random seed for sampling. Returns -------- samples : pycbc.io.record.FieldArray The parameter values and names of sample(s). Examples -------- Draw a sample from the distribution defined in the .ini file: >>> import numpy as np >>> from pycbc.distributions.utils import draw_samples_from_config >>> # A path to the .ini file. >>> CONFIG_PATH = "./pycbc_bbh_prior.ini" >>> random_seed = np.random.randint(low=0, high=2**32-1) >>> sample = draw_samples_from_config( >>> path=CONFIG_PATH, num=1, seed=random_seed) >>> # Print all parameters. >>> print(sample.fieldnames) >>> print(sample) >>> # Print a certain parameter, for example 'mass1'. >>> print(sample[0]['mass1']) """ np.random.seed(seed) # Initialise InterpolatingConfigParser class. config_parser = InterpolatingConfigParser() # Read the file file = open(path, 'r') config_parser.read_file(file) file.close() # Get the vairable arguments from the .ini file. variable_args, _ = distributions.read_params_from_config( config_parser, prior_section='prior', vargs_section='variable_params') constraints = distributions.read_constraints_from_config(config_parser) if any(config_parser.get_subsections('waveform_transforms')): waveform_transforms = transforms.read_transforms_from_config( config_parser, 'waveform_transforms') else: waveform_transforms = None # Get prior distribution for each variable parameter. dists = distributions.read_distributions_from_config(config_parser) # Construct class that will draw the samples. randomsampler = distributions.JointDistribution( variable_args, *dists, **{"constraints": constraints}) # Draw samples from prior distribution. samples = randomsampler.rvs(size=int(num)) # Apply parameter transformation. if waveform_transforms is not None: samples = transforms.apply_transforms(samples, waveform_transforms) else: pass return samples