def _get_model_with_requirements_and_eval(theo, reqs, packages_path, skip_not_installed): planck_base_model_prime = deepcopy(planck_base_model) planck_base_model_prime["hubble"] = "H" # intercompatibility CAMB/CLASS info_theory = {theo: {"extra_args": base_precision[theo]}} info = create_input(planck_names=True, theory=theo, **planck_base_model_prime) info = recursive_update(info, { "theory": info_theory, "likelihood": { "one": None } }) info["packages_path"] = process_packages_path(packages_path) info["debug"] = True model = install_test_wrapper(skip_not_installed, get_model, info) eval_parameters = { p: v for p, v in fiducial_parameters.items() if p in model.parameterization.sampled_params() } model.add_requirements(reqs) model.logposterior(eval_parameters) return model
def test_cosmo_docs_basic(): flag = True for theo in ["camb", "classy"]: info_new = create_input(preset=preset_pre + theo) info_yaml_new = yaml_dump(info_new) file_path = os.path.join(path, file_pre + theo + ".yaml") with open(file_path) as docs_file: info_yaml_docs = "".join(docs_file.readlines()) info_docs = yaml_load(info_yaml_docs) if not is_equal_info( info_new, info_docs, strict=True, print_not_log=True): with open(file_path, "w") as docs_file: docs_file.write(info_yaml_new) flag = False print("OLD:\n%s" % info_yaml_docs) print("----------------------------------------") print("NEW:\n%s" % info_yaml_new) assert flag, ("Differences in example input file. " "Files have been re-generated; check out your git diff.")
def makeGrid(batchPath, settingName=None, settings=None, read_only=False, interactive=False, install_reqs_at=None, install_reqs_force=None): print("Generating grid...") batchPath = os.path.abspath(batchPath) + os.sep if not settings: if not settingName: raise NotImplementedError( "Re-using previous batch is work in progress...") # if not pathIsGrid(batchPath): # raise Exception('Need to give name of setting file if batchPath/config ' # 'does not exist') # read_only = True # sys.path.insert(0, batchPath + 'config') # settings = __import__(IniFile(batchPath + 'config/config.ini').params['setting_file'].replace('.py', '')) elif os.path.splitext(settingName)[-1].lower() in _yaml_extensions: settings = yaml_load_file(settingName) else: raise NotImplementedError( "Using a python script is work in progress...") # In this case, info-as-dict would be passed # settings = __import__(settingName, fromlist=['dummy']) batch = batchjob.BatchJob(batchPath) # batch.skip = settings.get("skip", False) batch.makeItems(settings, messages=not read_only) if read_only: for jobItem in [b for b in batch.jobItems]: if not jobItem.chainExists(): batch.jobItems.remove(jobItem) batch.save() print('OK, configured grid with %u existing chains' % (len(batch.jobItems))) return batch else: batch.makeDirectories(setting_file=None) batch.save() infos = {} components_used = {} # Default info defaults = copy.deepcopy(settings) grid_definition = defaults.pop("grid") models_definitions = grid_definition["models"] datasets_definitions = grid_definition["datasets"] for jobItem in batch.items(wantSubItems=False): # Model info jobItem.makeChainPath() try: model_info = copy.deepcopy(models_definitions[jobItem.param_set] or {}) except KeyError: raise ValueError("Model '%s' must be defined." % jobItem.param_set) model_info = merge_info(defaults, model_info) # Dataset info try: dataset_info = copy.deepcopy( datasets_definitions[jobItem.data_set.tag]) except KeyError: raise ValueError("Data set '%s' must be defined." % jobItem.data_set.tag) # Combined info combined_info = merge_info(defaults, model_info, dataset_info) if "preset" in combined_info: preset = combined_info.pop("preset") combined_info = merge_info(create_input(**preset), combined_info) combined_info[_output_prefix] = jobItem.chainRoot # Requisites components_used = get_used_components(components_used, combined_info) if install_reqs_at: combined_info[_packages_path] = os.path.abspath(install_reqs_at) # Save the info (we will write it after installation: # we need to install to add auto covmats if jobItem.param_set not in infos: infos[jobItem.param_set] = {} infos[jobItem.param_set][jobItem.data_set.tag] = combined_info # Installing requisites if install_reqs_at: print("Installing required code and data for the grid.") from cobaya.log import logger_setup logger_setup() install_reqs(components_used, path=install_reqs_at, force=install_reqs_force) print("Adding covmats (if necessary) and writing input files") for jobItem in batch.items(wantSubItems=False): info = infos[jobItem.param_set][jobItem.data_set.tag] # Covariance matrices # We try to find them now, instead of at run time, to check if correctly selected try: sampler = list(info[kinds.sampler])[0] except KeyError: raise ValueError("No sampler has been chosen") if sampler == "mcmc" and info[kinds.sampler][sampler].get( "covmat", "auto"): packages_path = install_reqs_at or info.get(_packages_path, None) if not packages_path: raise ValueError( "Cannot assign automatic covariance matrices because no " "external packages path has been defined.") # Need updated info for covmats: includes renames updated_info = update_info(info) # Ideally, we use slow+sampled parameters to look for the covariance matrix # but since for that we'd need to initialise a model, we approximate that set # as theory+sampled from itertools import chain like_params = set( chain(*[ list(like[_params]) for like in updated_info[kinds.likelihood].values() ])) params_info = { p: v for p, v in updated_info[_params].items() if is_sampled_param(v) and p not in like_params } best_covmat = _get_best_covmat(os.path.abspath(packages_path), params_info, updated_info[kinds.likelihood]) info[kinds.sampler][sampler]["covmat"] = os.path.join( best_covmat["folder"], best_covmat["name"]) # Write the info for this job # Allow overwrite since often will want to regenerate grid with tweaks yaml_dump_file(jobItem.iniFile(), sort_cosmetic(info), error_if_exists=False) # Non-translated old code # if not start_at_bestfit: # setMinimize(jobItem, ini) # variant = '_minimize' # ini.saveFile(jobItem.iniFile(variant)) ## NOT IMPLEMENTED: start at best fit ## ini.params['start_at_bestfit'] = start_at_bestfit # --- # for deffile in settings.defaults: # ini.defaults.append(batch.commonPath + deffile) # if hasattr(settings, 'override_defaults'): # ini.defaults = [batch.commonPath + deffile for deffile in settings.override_defaults] + ini.defaults # --- # # add ini files for importance sampling runs # for imp in jobItem.importanceJobs(): # if getattr(imp, 'importanceFilter', None): continue # if batch.hasName(imp.name.replace('_post', '')): # raise Exception('importance sampling something you already have?') # for minimize in (False, True): # if minimize and not getattr(imp, 'want_minimize', True): continue # ini = IniFile() # updateIniParams(ini, imp.importanceSettings, batch.commonPath) # if cosmomcAction == 0 and not minimize: # for deffile in settings.importanceDefaults: # ini.defaults.append(batch.commonPath + deffile) # ini.params['redo_outroot'] = imp.chainRoot # ini.params['action'] = 1 # else: # ini.params['file_root'] = imp.chainRoot # if minimize: # setMinimize(jobItem, ini) # variant = '_minimize' # else: # variant = '' # ini.defaults.append(jobItem.iniFile()) # ini.saveFile(imp.iniFile(variant)) # if cosmomcAction != 0: break if not interactive: return batch print('Done... to run do: cobaya-grid-run %s' % batchPath)
def body_of_test(modules, best_fit, info_likelihood, info_theory, ref_chi2, best_fit_derived=None, extra_model={}): # Create base info theo = list(info_theory)[0] # In Class, theta_s is exact, but different from the approximate one cosmomc_theta # used by Planck, so we take H0 instead planck_base_model_prime = deepcopy(planck_base_model) planck_base_model_prime.update(extra_model or {}) if "H0" in best_fit: planck_base_model_prime["hubble"] = "H" best_fit_derived = deepcopy(best_fit_derived) or {} best_fit_derived.pop("H0", None) info = create_input(planck_names=True, theory=theo, **planck_base_model_prime) # Add specifics for the test: theory, likelihoods and derived parameters info = recursive_update(info, {_theory: info_theory}) info[_theory][theo]["use_planck_names"] = True info = recursive_update(info, {_likelihood: info_likelihood}) info[_params].update({p: None for p in best_fit_derived or {}}) # We need UPDATED info, to get the likelihoods nuisance parameters info = update_info(info) # Notice that update_info adds an aux internal-only _params property to the likes for lik in info[_likelihood]: info[_likelihood][lik].pop(_params, None) info[_path_install] = process_modules_path(modules) info[_debug] = True # Create the model and compute likelihood and derived parameters at best fit model = get_model(info) best_fit_values = { p: best_fit[p] for p in model.parameterization.sampled_params() } likes, derived = model.loglikes(best_fit_values) likes = dict(zip(list(model.likelihood), likes)) derived = dict(zip(list(model.parameterization.derived_params()), derived)) # Check value of likelihoods for like in info[_likelihood]: chi2 = -2 * likes[like] msg = ( "Testing likelihood '%s': | %.2f (now) - %.2f (ref) | = %.2f >= %.2f" % (like, chi2, ref_chi2[like], abs(chi2 - ref_chi2[like]), ref_chi2["tolerance"])) assert abs(chi2 - ref_chi2[like]) < ref_chi2["tolerance"], msg print(msg) # Check value of derived parameters not_tested = [] not_passed = [] for p in best_fit_derived or {}: if best_fit_derived[p][0] is None or p not in best_fit_derived: not_tested += [p] continue rel = (abs(derived[p] - best_fit_derived[p][0]) / best_fit_derived[p][1]) if rel > tolerance_derived * (2 if p in ("YHe", "Y_p", "DH", "sigma8", "s8omegamp5", "thetastar") else 1): not_passed += [(p, rel)] print("Derived parameters not tested because not implemented: %r" % not_tested) assert not not_passed, "Some derived parameters were off. Fractions of test tolerance: %r" % not_passed