def load_scan(self, run_tag=None): """ Load the details of a scan, if not already loaded This sets up the output of the scan in a format useful for Analysis """ if self.already_loaded: pass else: self.run_tag = run_tag self.make_dirs_for_run(run_tag) # Load the statistics and samples self.a = \ pymultinest.Analyzer(n_params=self.n_params, outputfiles_basename=self.chains_dir_for_run) self.s = self.a.get_stats() self.chain_file = self.chains_dir_for_run + '/post_equal_weights.dat' self.samples = np.array(np.loadtxt(self.chain_file)[:, :-1]) # Determine the median value of each parameter self.medians = [ self.s['marginals'][i]['median'] for i in range(self.n_params) ] # Determine the template normalisations self.calculate_norms() # Account for fixed parameters if necessary if len(self.fixed_params_list) > 0: self.fix_samples() self.fix_medians() self.n_params += len(self.fixed_params_list) self.fix_model_decompression() self.already_loaded = True
def mnest_analyzer(self): """ PyMultiNest Analyzer object associated with fit. See PyMultiNest documentation for more. """ return pymultinest.Analyzer(self.n_params, self.mnest_basename)
def plotMarginal(): import numpy as np import pymultinest from matplotlib import pyplot as plt outputFiles_rawbase = raw_input('Type path to chains folder: ') prefix = '%s/chains/1-'%outputFiles_rawbase open_params = open('%s/chains/.tmp_myCode/parameters.txt'%outputFiles_rawbase) paramNames = open_params.read().split() open_params.close() n_params = len(paramNames) a = pymultinest.Analyzer(n_params = n_params, outputfiles_basename = prefix) s = a.get_stats() p = pymultinest.PlotMarginalModes(a) for i in range(1,n_params): # plt.subplot(n_params, n_params, n_params * i + i + 1) #p.plot_marginal(i, ls='-', color='blue', linewidth=3) #p.plot_marginal(i, with_ellipses = True, dim2 = True, with_points = False, grid_points=50) for j in range(i): plt.subplot(n_params-1, n_params-1, (n_params-1) * j + i) p.plot_conditional(i, j, with_ellipses = False, with_points = False, grid_points=30) plt.subplot(n_params-1,n_params-1,(n_params-1)*(i-1) + i) plt.xlabel(paramNames[i]) plt.ylabel(paramNames[i-1]) plt.show()
def lfit(xx, yy, error, bounds=[-10., 10., -10., 10.]): # linear fit with nested sampling # prevents seg fault in MultiNest error[error == 0] = np.mean(error[error != 0]) def model_lin(params): return params[0] + xx * params[1] def myprior_lin(cube, ndim, n_params): '''This transforms a unit cube into the dimensions of your prior space.''' cube[0] = (bounds[1] - bounds[0]) * cube[0] + bounds[0] cube[1] = (bounds[3] - bounds[2]) * cube[1] + bounds[2] def myloglike_lin(cube, ndim, n_params): loglike = -np.sum(((yy - model_lin(cube)) / error)**2) return loglike / 2. pymultinest.run( myloglike_lin, myprior_lin, 2, resume=False, sampling_efficiency=0.5, evidence_tolerance=0.1, ) # retrieves the data that has been written to hard drive a = pymultinest.Analyzer(n_params=2) posteriors = a.get_data() stats = a.get_stats() stats['marginals'] = get_stats(posteriors) return stats, posteriors
def check_finesse(folder, recover=False): data = h5_2_dict(join(folder, 'input_finesse.h5')) ix = data['fit_ix'] Lpost, dpost = read_Ld_results(data['Ld_folder']) i = np.random.choice(len(Lpost)) L = Lpost[i] d = dpost[i] r = data['r'] sig = data['sig'] analyzer = pymultinest.Analyzer(5, outputfiles_basename=join( folder, "finesse_")) modes = analyzer.get_mode_stats() #F, A, Arel, Ti, offset = modes['modes'][0]['mean'] F, A, Arel, Ti = modes['modes'][0]['mean'] post = analyzer.get_equal_weighted_posterior() w0 = [487.873302, 487.98634] mu = [232.03806, 39.948] Lpost = Lpost[::30] dpost = dpost[::30] Fpost = post[::30, 0] Apost = post[::30, 1] Arelpost = post[::30, 2] Tipost = post[::30, 3] #offsetpost = post[::30, 4] #offset_mean = np.mean(post[:, 4]) #offset_sd = np.std(post[:, 4]) print('F: {0:f} +/- {1:f}'.format(np.mean(post[:, 0]), np.std(post[:, 0]))) print('A: {0:e} +/- {1:e}'.format(np.mean(post[:, 1]), np.std(post[:, 1]))) print('Arel: {0:f} +/- {1:f}'.format(np.mean(post[:, 2]), np.std(post[:, 2]))) print('Ti Ar: {0:f} +/- {1:f}'.format(np.mean(post[:, 3]), np.std(post[:, 3]))) #print('offset: {0:e} +/- {1:e}'.format(offset_mean, offset_sd)) if recover: try: post_dict = h5_2_dict(join(folder, "finesse_solver_model_post.h5")) sig_post = post_dict["signal post"] new_r = post_dict['new_r'] except IOError, e: print( "Can't recover finesse solver q posterior. Calculating from scratch." ) #sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, offsetpost, w0, mu) new_r = np.linspace(0, 900, 1000) # sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, w0, mu) sig_post = calculate_signal_post(new_r, Lpost, dpost, Fpost, Apost, Arelpost, Tipost, w0, mu) dict_2_h5(join(folder, "finesse_solver_model_post.h5"), { 'signal post': sig_post, 'new_r': new_r })
def get_1sigma(outputpath, param, shortlong): """ star : name of star (str) param : name of parameter (str) shortlong : 'short' or 'long' Retrieve median and 3 sigma errors of parameter of choice for a given star returns [median, low 1sigma, high 1sigma] """ if shortlong == 'short': if 'long' in outputpath: outputpath = outputpath.replace("/long/", "/short/") print(outputpath) # a = Analyzer(23, outputfiles_basename = outputpath + "/test-") a = pymultinest.Analyzer(23, outputfiles_basename=outputpath + "/test-") params = [ 'C1', 'Trim_min', 'qrim', 'C2', 'Tmid_min', 'Tmid_max', 'qmid', 'Tatm_min', 'Tatm_max', 'qatm', 'Ol. 0.1', 'Ol. 2.0', 'Ol. 5.0', 'Py. 0.1', 'Py. 2.0', 'Py. 5.0', 'Fo. 0.1', 'Fo. 2.0', 'En. 0.1', 'En. 2.0', 'Si. 0.1', 'Si. 2.0', 'Si. 5.0' ] elif shortlong == 'long': # a = Analyzer(20, outputfiles_basename = outputpath + "/test-") a = pymultinest.Analyzer(20, outputfiles_basename=outputpath + "/test-") params = [ 'C2', 'Tmid_min', 'Tmid_max', 'qmid', 'Tatm_min', 'Tatm_max', 'qatm', 'Ol. 0.1', 'Ol. 2.0', 'Ol. 5.0', 'Py. 0.1', 'Py. 2.0', 'Py. 5.0', 'Fo. 0.1', 'Fo. 2.0', 'En. 0.1', 'En. 2.0', 'Si. 0.1', 'Si. 2.0', 'Si. 5.0' ] i = params.index(param) stats = a.get_stats() # print(stats['modes'][0]['maximum a posterior'][i]) p = stats['modes'][0]['mean'][i] pl, ph = stats['marginals'][i]['1sigma'] return p, p - pl, ph - p
def my_curvfit(function, prior, parameters, x, y, yerr1, yerr2=None, savedir=None, done=True): n_params = len(parameters) if yerr2 is not None: yerr2 = np.abs(yerr2) x = np.array(x) y = np.array(y) yerr1 = np.abs(yerr1) if savedir is None: savedir = '/home/laojin/software/my_python/curvfit/' if os.path.exists(savedir) == False: os.makedirs(savedir) else: if os.path.exists(savedir) == False: os.makedirs(savedir) def loglike(cube, ndim, nparams): ymodel = function(x, cube) if yerr2 is not None: err = [] for index, value in enumerate(ymodel - y): if value > 0: err.append(yerr2[index]) else: err.append(yerr1[index]) err = np.array(err) else: err = yerr1 loglikelihood = (-0.5 * ((ymodel - y) / err)**2).sum() return loglikelihood if ((os.path.exists(savedir + 'spectrum_params.json') == False) or (done)): pymultinest.run(loglike, prior, n_params, outputfiles_basename=savedir + 'spectrum_', resume=False, verbose=True) json.dump(parameters, open(savedir + 'spectrum_params.json', 'w')) a = pymultinest.Analyzer(outputfiles_basename=savedir + 'spectrum0_', n_params=n_params) return a
def get_previous_periods(n_planets): if n_planets == 0: return [] basename = filename + '.out/%d/' % n_planets parameters = json.load(file('%sparams.json' % basename)) a = pymultinest.Analyzer(n_params=len(parameters), outputfiles_basename=basename) s = a.get_stats() return map( lambda (p, m): (m['5sigma'][0] - (m['5sigma'][1] - m['5sigma'][0]), m['5sigma'][1] + (m['5sigma'][1] - m['5sigma'][0])), filter(lambda (p, m): p.startswith('P'), zip(parameters, s['marginals'])))
def analyze(self): which = [0, 2, 3, 4, 5, 6] pars = [ r'$v_\mathrm{Doppler}$', r'$B$', r'$\theta_B$', r'$\chi_B$', r'$\sigma_I$ [x10$^{-2}$]', r'$\sigma_{QUV}$ [x10$^{-2}$]' ] self.chains = pymultinest.Analyzer(n_params=self.nParams) samples = self.chains.get_equal_weighted_posterior() samples[:, -3:] *= 1e2 fig, ax = pl.subplots(nrows=2, ncols=3, figsize=(16, 8)) ax = ax.flatten() for i in range(self.nParams - 1): n, bins, patches = ax[i].hist(samples[:, which[i]], bins=20) pl.setp(patches, 'facecolor', 'g', 'alpha', 0.75) ax[i].set_xlabel(pars[i]) pl.savefig("bayesHazel.png")
def analyze(inputDirectory, inputPrefix, outputDirectory, outputPrefix): ''' Helper function for analyzing distributions from PyMultiNest. The arguments are: inputDirectory - The directory containing the PyMultiNest output files to process. This should be the 'outputDirectory' that was used to generate those files. inputPrefix - The prefix for all input file names. This should be the 'outputPrefix' that was used to generate those files. outputDirectory - The directory in which to place output files. outputPrefix - The prefix for all output file names. The return value is a PyMultiNest Analyzer object. ''' prefix = inputDirectory + '/' + inputPrefix outputPrefix = outputDirectory + '/' + outputPrefix parameters = json.load(open(prefix + 'params.json')) n_params = len(parameters) a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename=prefix) s = a.get_stats() json.dump(s, open(outputPrefix + 'stats.json', 'w'), indent=4) print(' marginal likelihood:') print(' ln Z = %.1f +- %.1f' % (s['global evidence'], s['global evidence error'])) print(' parameters:') meds = [] for p, m in zip(parameters, s['marginals']): lo, hi = m['1sigma'] med = m['median'] meds.append(med) sigma = (hi - lo) / 2 print(sigma) i = max(0, int(-np.floor(np.log10(sigma))) + 1) fmt = '%%.%df' % i fmts = '\t'.join([' %-15s' + fmt + " +- " + fmt]) print(fmts % (p, med, sigma)) return a, meds, s['global evidence']
def get_system(self, path): sys = System(m_star=1, i=90) try: sys.info = json.load(open(path + 'info.json')) except IOError: warnings.warn('{}info.json does not exist'.format(path), UserWarning) try: sys.lightcurve = pd.read_json(path+'lightcurve.json') except ValueError: warnings.warn('{}lightcurve.json does not exist'.format(path), UserWarning) for i, planet in enumerate(sys.info): sys.add_planet(m=sys.info[planet]['m'], a = sys.info[planet]['a'], e=sys.info[planet]['e'], omega=sys.info[planet]['omega'], t0=sys.info[planet]['t0']) try: params = json.load(open(path + 'ps{}_params.json'.format(i+1))) except IOError: warnings.warn('{}ps{}_params.json does not exist'.format(path, i+1), UserWarning) try: sys.analyzer = pmn.Analyzer(len(sys.info) * 3, outputfiles_basename = path + 'ps{}_'.format(i+1)) bf_params = [sys.analyzer.get_stats()['modes'][0]['maximum']][0] # model_RVs = [ # sum([sys.calculate_RV(date, bf_params[3*i], bf_params[3*i+1], # 0, 0, bf_params[3*i+2]) # for i in range(len(sys.info))])[0] # for date in sys.lightcurve.JD ] model_RVs = [ sum([sys.calculate_RV(date, 10**bf_params[3*i], 10**bf_params[3*i+1], 0, 0, bf_params[3*i+2]) for i in range(len(sys.info))])[0] for date in sys.lightcurve.JD ] sys.lightcurve[planet] = model_RVs #except (IOError, IndexError, UnicodeDecodeError): except: sys.analyzer = None warnings.warn('{}ps{}_.txt does not exist'.format(path, i+1), UserWarning) return sys
def run_nested(spec, model, basename='run/test_run'): pymultinest.run( model.loglikelihood, model.prior_transform, model.n_params, outputfiles_basename=basename, resume=False, verbose=True, evidence_tolerance=0.3, n_live_points=400, sampling_efficiency=0.3, n_iter_before_update=2000, ) analyzer = pymultinest.Analyzer( outputfiles_basename=basename, n_params=model.n_params, ) lnZ = analyzer.get_stats()['global evidence'] print(':: Evidence Z:', lnZ / np.log(10)) return analyzer
def test_multinest(): model_name = "LuminosityLikelihood" redshifts = [6, 7, 8, 10] F_STAR10 = [-1.3, -3, 0, 1.0] ALPHA_STAR = [0.5, -0.5, 1.0, 1.0] M_TURN = [8.69897, 8, 10, 1.0] t_STAR = [0.5, 0.01, 1, 0.3] mcmc_options = { "n_live_points": 10, "max_iter": 10, } mcmc.run_mcmc( [ mcmc.CoreLuminosityFunction(redshift=z, sigma=0, name="lfz%d" % z) for z in redshifts ], [ mcmc.LikelihoodLuminosityFunction(name="lfz%d" % z) for z in redshifts ], model_name=model_name, params={ "F_STAR10": F_STAR10, "ALPHA_STAR": ALPHA_STAR, "M_TURN": M_TURN, "t_STAR": t_STAR, }, use_multinest=True, **mcmc_options, ) import pymultinest nest = pymultinest.Analyzer(4, outputfiles_basename="./MultiNest/%s" % model_name) data = nest.get_data() assert data.shape[1] == 6
def run_pymultinest(likelihood_function, model, label, prior, n_params): # run MultiNest pymultinest.run(likelihood_function, prior, n_params, outputfiles_basename=datafile + label, resume=False) json.dump(parameters, open(datafile + label + 'params.json', 'w')) # save parameter names run = pymultinest.Analyzer(outputfiles_basename=datafile + label, n_params=n_params) a_lnZ = run.get_stats()['global evidence'] print() print('************************') print('MAIN RESULT: Evidence Z ') print('************************') print(f'log Z for model {label} = {a_lnZ:.1f}\n') return a_lnZ
def plotMarginal(n_params): import numpy as np import pymultinest from matplotlib import pyplot as plt outputFiles_rawbase = raw_input('Type path to chains folder: ') prefix = '%s/chains/1-' % outputFiles_rawbase if n_params == 8: paramNames = [ r'$\epsilon_e$', 'E0', 'n', r'$\Gamma_0$', '$\epsilon_B$', 'p', r'$\theta_0$', r'$\alpha$' ] a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename=prefix) s = a.get_stats() p = pymultinest.PlotMarginalModes(a) for i in range(1, n_params): # plt.subplot(n_params, n_params, n_params * i + i + 1) #p.plot_marginal(i, ls='-', color='blue', linewidth=3) #p.plot_marginal(i, with_ellipses = True, dim2 = True, with_points = False, grid_points=50) for j in range(i): plt.subplot(n_params - 1, n_params - 1, (n_params - 1) * j + i) p.plot_conditional(i, j, with_ellipses=False, with_points=True, grid_points=30) plt.subplot(n_params - 1, n_params - 1, (n_params - 1) * (i - 1) + i) plt.xlabel(paramNames[i]) plt.ylabel(paramNames[i - 1]) plt.show()
def pyorbit_multinest(config_in, input_datasets=None, return_output=None): output_directory = './' + config_in['output'] + '/multinest/' mc = ModelContainerMultiNest() pars_input(config_in, mc, input_datasets) if mc.nested_sampling_parameters['shutdown_jitter']: for dataset_name, dataset in mc.dataset_dict.items(): dataset.shutdown_jitter() mc.model_setup() mc.create_variables_bounds() mc.initialize_logchi2() mc.create_starting_point() results_analysis.results_resumen(mc, None, skip_theta=True) mc.output_directory = output_directory os.system("mkdir -p " + output_directory + mc.nested_sampling_parameters['base_dir'] + "/clusters") #os.system("mkdir -p " +polychord_dir_output + "chains/clusters") print() print('Reference Time Tref: ', mc.Tref) print() print('*************************************************************') print() ''' On Linux system (BASH): export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib export LD_PRELOAD=/usr/lib/openmpi/lib/libmpi.so:$LD_PRELOAD export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libgfortran.so.3 mpirun -np 4 python run_PyPolyChord.py on Mac: export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libgfortran.so.3 export LD_PRELOAD=/opt/local/lib/openmpi/lib/libmpi.so:$LD_PRELOAD mpirun -np 4 python run_PyPolyChord.py ''' # parameters = mc.get_theta_dictionary() if 'nlive' in mc.nested_sampling_parameters: nlive = mc.nested_sampling_parameters['nlive'] elif 'nlive_mult' in mc.nested_sampling_parameters: nlive = mc.ndim * mc.nested_sampling_parameters['nlive_mult'] print(' Sampling efficiency: ', mc.nested_sampling_parameters['sampling_efficiency']) print(' N live points:', nlive) import pymultinest mnest_kwargs = dict(n_live_points=nlive, outputfiles_basename=output_directory + './') for key_name, key_value in mc.nested_sampling_parameters.items(): if key_name in mc.pymultinest_signature: mnest_kwargs[key_name] = key_value print('Including priors to log-likelihood calculation (must be False):', mc.include_priors) pymultinest.run(LogLikelihood= mc.multinest_call, Prior=mc.multinest_priors, n_dims=mc.ndim, **mnest_kwargs) nested_sampling_save_to_cpickle(mc) analyzer = pymultinest.Analyzer(mc.ndim, outputfiles_basename=output_directory) stats = analyzer.get_stats() samples = analyzer.get_equal_weighted_posterior()[:, :-1] result = dict(logZ=stats['nested sampling global log-evidence'], logZerr=stats['nested sampling global log-evidence error'], samples=samples, ) nested_sampling_save_to_cpickle(mc, 'result') print() print('MultiNest COMPLETED') print() #result = pymultinest.solve(LogLikelihood=mc.multinest_call, Prior=mc.multinest_priors, # n_dims=mc.ndim, outputfiles_basename=output_directory + './', # n_live_points=1000, sampling_efficiency=0.3, multimodal=True, # verbose=True, resume=True) print('evidence: %(logZ).1f +- %(logZerr).1f' % result) print(result['logZ']//np.log(10.00), result['logZerr']//np.log(10.00)) if return_output: return mc else: return
def run_qufit(dataFile, modelNum, outDir="", polyOrd=3, nBits=32, noStokesI=False, showPlots=False, debug=False, verbose=False): """Function controlling the fitting procedure.""" # Get the processing environment if mpiSwitch: mpiComm = MPI.COMM_WORLD mpiSize = mpiComm.Get_size() mpiRank = mpiComm.Get_rank() else: mpiSize = 1 mpiRank = 0 # Default data types dtFloat = "float" + str(nBits) dtComplex = "complex" + str(2 * nBits) # Output prefix is derived from the input file name prefixOut, ext = os.path.splitext(dataFile) nestOut = prefixOut + "_nest/" if mpiRank == 0: if os.path.exists(nestOut): shutil.rmtree(nestOut, True) os.mkdir(nestOut) if mpiSwitch: mpiComm.Barrier() # Read the data file in the root process if mpiRank == 0: dataArr = np.loadtxt(dataFile, unpack=True, dtype=dtFloat) else: dataArr = None if mpiSwitch: dataArr = mpiComm.bcast(dataArr, root=0) # Parse the data array # freq_Hz, I, Q, U, dI, dQ, dU try: (freqArr_Hz, IArr, QArr, UArr, dIArr, dQArr, dUArr) = dataArr if mpiRank == 0: print("\nFormat [freq_Hz, I, Q, U, dI, dQ, dU]") except Exception: # freq_Hz, Q, U, dQ, dU try: (freqArr_Hz, QArr, UArr, dQArr, dUArr) = dataArr if mpiRank == 0: print("\nFormat [freq_Hz, Q, U, dQ, dU]") noStokesI = True except Exception: print("\nError: Failed to parse data file!") if debug: print(traceback.format_exc()) if mpiSwitch: MPI.Finalize() return # If no Stokes I present, create a dummy spectrum = unity if noStokesI: if mpiRank == 0: print("Note: no Stokes I data - assuming fractional polarisation.") IArr = np.ones_like(QArr) dIArr = np.zeros_like(QArr) # Convert to GHz for convenience freqArr_GHz = freqArr_Hz / 1e9 lamSqArr_m2 = np.power(C / freqArr_Hz, 2.0) # Fit the Stokes I spectrum and create the fractional spectra if mpiRank == 0: dataArr = create_frac_spectra(freqArr=freqArr_GHz, IArr=IArr, QArr=QArr, UArr=UArr, dIArr=dIArr, dQArr=dQArr, dUArr=dUArr, polyOrd=polyOrd, verbose=True) else: dataArr = None if mpiSwitch: dataArr = mpiComm.bcast(dataArr, root=0) (IModArr, qArr, uArr, dqArr, duArr, IfitDict) = dataArr # Plot the data and the Stokes I model fit if mpiRank == 0: print("Plotting the input data and spectral index fit.") freqHirArr_Hz = np.linspace(freqArr_Hz[0], freqArr_Hz[-1], 10000) IModHirArr = poly5(IfitDict["p"])(freqHirArr_Hz / 1e9) specFig = plt.figure(figsize=(10, 6)) plot_Ipqu_spectra_fig(freqArr_Hz=freqArr_Hz, IArr=IArr, qArr=qArr, uArr=uArr, dIArr=dIArr, dqArr=dqArr, duArr=duArr, freqHirArr_Hz=freqHirArr_Hz, IModArr=IModHirArr, fig=specFig) # Use the custom navigation toolbar try: specFig.canvas.toolbar.pack_forget() CustomNavbar(specFig.canvas, specFig.canvas.toolbar.window) except Exception: pass # Display the figure if showPlots: specFig.canvas.draw() specFig.show() #-------------------------------------------------------------------------# # Load the model and parameters from the relevant file if mpiSwitch: mpiComm.Barrier() if mpiRank == 0: print("\nLoading the model from 'models_ns/m%d.py' ..." % modelNum) mod = imp.load_source("m%d" % modelNum, "models_ns/m%d.py" % modelNum) global model model = mod.model # Let's time the sampler if mpiRank == 0: startTime = time.time() # Unpack the inParms structure parNames = [x["parname"] for x in mod.inParms] labels = [x["label"] for x in mod.inParms] values = [x["value"] for x in mod.inParms] bounds = [x["bounds"] for x in mod.inParms] priorTypes = [x["priortype"] for x in mod.inParms] wraps = [x["wrap"] for x in mod.inParms] nDim = len(priorTypes) fixedMsk = [0 if x == "fixed" else 1 for x in priorTypes] nFree = sum(fixedMsk) # Set the prior function given the bounds of each parameter prior = prior_call(priorTypes, bounds, values) # Set the likelihood function given the data lnlike = lnlike_call(parNames, lamSqArr_m2, qArr, dqArr, uArr, duArr) # Let's time the sampler if mpiRank == 0: startTime = time.time() # Run nested sampling using PyMultiNest nestArgsDict = merge_two_dicts(init_mnest(), mod.nestArgsDict) nestArgsDict["n_params"] = nDim nestArgsDict["n_dims"] = nDim nestArgsDict["outputfiles_basename"] = nestOut nestArgsDict["LogLikelihood"] = lnlike nestArgsDict["Prior"] = prior pmn.run(**nestArgsDict) # Do the post-processing on one processor if mpiSwitch: mpiComm.Barrier() if mpiRank == 0: # Query the analyser object for results aObj = pmn.Analyzer(n_params=nDim, outputfiles_basename=nestOut) statDict = aObj.get_stats() fitDict = aObj.get_best_fit() endTime = time.time() # NOTE: The Analyser methods do not work well for parameters with # posteriors that overlap the wrap value. Use np.percentile instead. pMed = [None] * nDim for i in range(nDim): pMed[i] = statDict["marginals"][i]['median'] lnLike = fitDict["log_likelihood"] lnEvidence = statDict["nested sampling global log-evidence"] dLnEvidence = statDict["nested sampling global log-evidence error"] # Get the best-fitting values & uncertainties directly from chains chains = aObj.get_equal_weighted_posterior() chains = wrap_chains(chains, wraps, bounds, pMed) p = [None] * nDim errPlus = [None] * nDim errMinus = [None] * nDim g = lambda v: (v[1], v[2] - v[1], v[1] - v[0]) for i in range(nDim): p[i], errPlus[i], errMinus[i] = \ g(np.percentile(chains[:, i], [15.72, 50, 84.27])) # Calculate goodness-of-fit parameters nData = 2.0 * len(lamSqArr_m2) dof = nData - nFree - 1 chiSq = chisq_model(parNames, p, lamSqArr_m2, qArr, dqArr, uArr, duArr) chiSqRed = chiSq / dof AIC = 2.0 * nFree - 2.0 * lnLike AICc = 2.0 * nFree * (nFree + 1) / (nData - nFree - 1) - 2.0 * lnLike BIC = nFree * np.log(nData) - 2.0 * lnLike # Summary of run print("") print("-" * 80) print("SUMMARY OF SAMPLING RUN:") print("#-PROCESSORS = %d" % mpiSize) print("RUN-TIME = %.2f" % (endTime - startTime)) print("DOF = %d" % dof) print("CHISQ: = %.3g" % chiSq) print("CHISQ RED = %.3g" % chiSqRed) print("AIC: = %.3g" % AIC) print("AICc = %.3g" % AICc) print("BIC = %.3g" % BIC) print("ln(EVIDENCE) = %.3g" % lnEvidence) print("dLn(EVIDENCE) = %.3g" % dLnEvidence) print("") print("-" * 80) print("RESULTS:\n") for i in range(len(p)): print("%s = %.4g (+%3g, -%3g)" % \ (parNames[i], p[i], errPlus[i], errMinus[i])) print("-" * 80) print("") # Create a save dictionary and store final p in values outFile = prefixOut + "_m%d_nest.json" % modelNum IfitDict["p"] = toscalar(IfitDict["p"].tolist()) saveDict = { "parNames": toscalar(parNames), "labels": toscalar(labels), "values": toscalar(p), "errPlus": toscalar(errPlus), "errMinus": toscalar(errMinus), "bounds": toscalar(bounds), "priorTypes": toscalar(priorTypes), "wraps": toscalar(wraps), "dof": toscalar(dof), "chiSq": toscalar(chiSq), "chiSqRed": toscalar(chiSqRed), "AIC": toscalar(AIC), "AICc": toscalar(AICc), "BIC": toscalar(BIC), "IfitDict": IfitDict } json.dump(saveDict, open(outFile, "w")) print("Results saved in JSON format to:\n '%s'\n" % outFile) # Plot the data and best-fitting model lamSqHirArr_m2 = np.linspace(lamSqArr_m2[0], lamSqArr_m2[-1], 10000) freqHirArr_Hz = C / np.sqrt(lamSqHirArr_m2) IModArr = poly5(IfitDict["p"])(freqHirArr_Hz / 1e9) pDict = {k: v for k, v in zip(parNames, p)} quModArr = model(pDict, lamSqHirArr_m2) specFig.clf() plot_Ipqu_spectra_fig(freqArr_Hz=freqArr_Hz, IArr=IArr, qArr=qArr, uArr=uArr, dIArr=dIArr, dqArr=dqArr, duArr=duArr, freqHirArr_Hz=freqHirArr_Hz, IModArr=IModArr, qModArr=quModArr.real, uModArr=quModArr.imag, fig=specFig) specFig.canvas.draw() # Plot the posterior samples in a corner plot chains = aObj.get_equal_weighted_posterior() chains = wrap_chains(chains, wraps, bounds, p)[:, :nDim] iFixed = [i for i, e in enumerate(fixedMsk) if e == 0] chains = np.delete(chains, iFixed, 1) for i in sorted(iFixed, reverse=True): del (labels[i]) del (p[i]) cornerFig = corner.corner(xs=chains, labels=labels, range=[0.99999] * nFree, truths=p, quantiles=[0.1572, 0.8427], bins=30) # Save the figures outFile = nestOut + "fig_m%d_specfit.pdf" % modelNum specFig.savefig(outFile) print("Plot of best-fitting model saved to:\n '%s'\n" % outFile) outFile = nestOut + "fig_m%d_corner.pdf" % modelNum cornerFig.savefig(outFile) print("Plot of posterior samples saved to \n '%s'\n" % outFile) # Display the figures if showPlots: specFig.show() cornerFig.show() print("> Press <RETURN> to exit ...", end="") sys.stdout.flush() input() # Clean up plt.close(specFig) plt.close(cornerFig) # Clean up MPI environment if mpiSwitch: MPI.Finalize()
def MN_analysis(self, basename): ''' Analysis of MultiNest output. ''' try: import pymultinest except: print("********************") print("Could not import pyMultiNest! Make sure that both this is in your PYTHONPATH.") print("MultiNest must also be on your LD_LIBRARY_PATH") raise ValueError("Abort BSFC fit") #### ##Only works for MultiNest v3.11+, but we use MultiNest 3.10 ## Read output: #try: # import nestcheck.data_processing # import nestcheck.estimators as estim #except: # print("********************") # print("Could not import nestcheck! Make sure that this is in your PYTHONPATH.") # raise ValueError("Abort BSFC analysis") # ## for testing #run = nestcheck.data_processing.process_multinest_run( # basename.split('/')[-1], # os.path.dirname(basename)+'/') #### # after MultiNest run, read results a = pymultinest.Analyzer( n_params= self.lineModel.thetaLength(), outputfiles_basename=basename ) # get chains and weights data = a.get_data() self.samples = data[:,2:] self.sample_weights = data[:,0] # Used for sampling self.cum_sample_weights = np.cumsum(self.sample_weights) self.sample_n2ll = data[:,1] # save statistics stats = a.get_stats() self.multinest_stats = stats self.modes=stats['modes'][0] self.maximum= self.modes['maximum'] self.maximum_a_posterior= self.modes['maximum a posterior'] self.mean=np.asarray(self.modes['mean']) self.sigma=np.asarray(self.modes['sigma']) # get log-evidence estimate and uncertainty (from INS, if this is used) self.lnev = (stats['global evidence'], stats['global evidence error']) g=gptools.summarize_sampler(data[:, 2:], weights=data[:, 0], burn=0, ci=0.95, chain_mask=None) self.params_mean = np.asarray(g[0]) self.params_ci_l = np.asarray(g[1]) self.params_ci_u = np.asarray(g[2]) # summarize results #self.m_map = self.lineModel.modelMoments(self.maximum_a_posterior) #self.m_map_mean = self.lineModel.modelMoments(self.mean) #m1 = self.lineModel.modelMoments(self.mean+self.sigma) #m2 = self.lineModel.modelMoments(self.mean - self.sigma) #self.m_map_std = (m1 - m2)/2.0 #temporary # marginalized (fully-Bayesian) results: self.m_bayes_marg = self.lineModel.modelMoments(self.params_mean) self.m_bayes_marg_low = self.lineModel.modelMoments(self.params_ci_l) self.m_bayes_marg_up = self.lineModel.modelMoments(self.params_ci_u) # temporary, for compatibility with MCMC methods: self.theta_avg = self.params_mean self.m_avg = self.m_bayes_marg #self.m_std = self.m_map_std return True
def optimize(self, num: int, args_nld: Iterable, guess: Dict[str, float]) -> Tuple[Dict[str, Tuple[float, float]], Dict[str, List[float]]]: # noqa """Find parameters given model constraints and an initial guess Employs Multinest. Args: num (int): Loop number args_nld (Iterable): Additional arguments for the nld lnlike guess (Dict[str, float]): The initial guess of the parameters Returns: Tuple: - popt (Dict[str, Tuple[float, float]]): Median and 1sigma of the parameters - samples (Dict[str, List[float]]): Multinest samplesø. Note: They are still importance weighted, not random draws from the posterior. Raises: ValueError: Invalid parameters for automatix prior Note: You might want to adjust the priors for your specific case! Here we just propose a general solution that might often work out of the box. """ if guess['alpha'] < 0: raise NotImplementedError("Prior selection not implemented for " "α < 0") alpha_exponent = np.log10(guess['alpha']) if guess['T'] < 0: raise ValueError("Prior selection not implemented for T < 0; " "negative temperature is unphysical") T_exponent = np.log10(guess['T']) A = guess['A'] B = guess["B"] # truncations from absolute values lower_A, upper_A = 0., np.inf mu_A, sigma_A = A, 10*A a_A = (lower_A - mu_A) / sigma_A b_A = (upper_A - mu_A) / sigma_A lower_Eshift, upper_Eshift = -5., 5 mu_Eshift, sigma_Eshift = 0, 5 a_Eshift = (lower_Eshift - mu_Eshift) / sigma_Eshift b_Eshift = (upper_Eshift - mu_Eshift) / sigma_Eshift lower_B, upper_B = 0., np.inf mu_B, sigma_B = B, 10*B a_B = (lower_B - mu_B) / sigma_B b_B = (upper_B - mu_B) / sigma_B def prior(cube, ndim, nparams): # NOTE: You may want to adjust this for your case! # truncated normal prior cube[0] = truncnorm_ppf(cube[0], a_A, b_A)*sigma_A + mu_A # log-uniform prior # if alpha = 1e2, it's between 1e1 and 1e3 cube[1] = 10**(cube[1]*2 + (alpha_exponent-1)) # log-uniform prior # if T = 1e2, it's between 1e1 and 1e3 cube[2] = 10**(cube[2]*2 + (T_exponent-1)) # truncated normal prior cube[3] = truncnorm_ppf(cube[3], a_Eshift, b_Eshift)*sigma_Eshift + mu_Eshift # truncated normal prior cube[4] = truncnorm_ppf(cube[4], a_B, b_B)*sigma_B + mu_B if np.isinf(cube[3]): self.LOG.debug("Encountered inf in cube[3]:\n%s", cube[3]) def loglike(cube, ndim, nparams): return self.lnlike(cube, args_nld=args_nld) # parameters are changed in the lnlike norm_pars_org = copy.deepcopy(self.normalizer_gsf.norm_pars) self.multinest_path.mkdir(exist_ok=True) path = self.multinest_path / f"sim_norm_{num}_" assert len(str(path)) < 60, "Total path length too long for multinest" self.LOG.info("Starting multinest: ") self.LOG.debug("with following keywords %s:", self.multinest_kwargs) # Hack where stdout from Multinest is redirected as info messages self.LOG.write = lambda msg: (self.LOG.info(msg) if msg != '\n' else None) with redirect_stdout(self.LOG): pymultinest.run(loglike, prior, len(guess), outputfiles_basename=str(path), **self.multinest_kwargs) # Save parameters for analyzer names = list(guess.keys()) json.dump(names, open(str(path) + 'params.json', 'w')) analyzer = pymultinest.Analyzer(len(guess), outputfiles_basename=str(path)) stats = analyzer.get_stats() samples = analyzer.get_equal_weighted_posterior()[:, :-1] samples = dict(zip(names, samples.T)) # Format the output popt = dict() vals = [] for name, m in zip(names, stats['marginals']): lo, hi = m['1sigma'] med = m['median'] sigma = (hi - lo) / 2 popt[name] = (med, sigma) i = max(0, int(-np.floor(np.log10(sigma))) + 1) fmt = '%%.%df' % i fmts = '\t'.join([fmt + " ± " + fmt]) vals.append(fmts % (med, sigma)) self.LOG.info("Multinest results:\n%s", tt.to_string([vals], header=['A', 'α [MeV⁻¹]', 'T [MeV]', 'Eshift [MeV]', 'B'])) # reset state self.normalizer_gsf.norm_pars = norm_pars_org return popt, samples
def localize_frb(beam_data, out_name, max_baseline=12., out_dir="./", save=True, verbose=False): xoff = beam_data.loc[beam_data['flux'].idxmax()].xpos yoff = beam_data.loc[beam_data['flux'].idxmax()].ypos # The offset, (x,y), is related to a true sky coordinate, (RA,DEC), by # x = (RA - RA0) * cos(DEC0) # y = DEC - DEC0 # correct beam positions to relative positions accounting for cos(dec) beam_data['xpos_new'] = (beam_data.xpos - xoff)*np.cos(yoff*np.pi/180.) beam_data['ypos_new'] = (beam_data.ypos - yoff) fwhm = beam_fwhm(beam_data.freq, max_baseline=max_baseline)[0] # select beams surrounding highest detection SNR print("fwhm: {}".format(fwhm)) beam_mapfig, mask = beam_select(beam_data, radius=fwhm/2) frb_data = beam_data[~mask] frb_data.reset_index(drop=True, inplace=True) nbeam = len(frb_data) xpos = frb_data.xpos_new ypos = frb_data.ypos_new beam_name = frb_data.beam flux_data = frb_data.flux ferr_data = frb_data.ferr freq_beam = frb_data.freq print(beam_name) # normalize sensitivity sens = 2000./frb_data.sefd print(freq_beam) fwhm = beam_fwhm(freq_beam, max_baseline=max_baseline) rad = fwhm/2. rad1400 = rad*(freq_beam/1.4) print(fwhm) ######################################################################################### def beam_gain(x, y, fwhm): w = fwhm / (2.0*sqrt(2*log(2.))) arg = x*x +y*y val = exp(-arg/2./w/w) return val def prior(cube, ndim, nparams): cube[0] = -2 + 4*cube[0] # uniform prior between -2:2 cube[1] = -2 + 4*cube[1] # uniform prior between -2:2 cube[2] = 10**(4*cube[2] - 1) # log-uniform prior between 10^-1 and 10^3 #nbeam = (ndim-3) / 4 for ibeam in range(nbeam): mean = 1.0 ; sigma = 0.1 # Gaussian prior: mean=1, sigma=0.1 cube[3+4*ibeam+0] = mean + (2**0.5)*sigma*erfinv(2*cube[3+4*ibeam+0] - 1) cube[3+4*ibeam+1] = mean + (2**0.5)*sigma*erfinv(2*cube[3+4*ibeam+1] - 1) mean = 0.0 ; sigma = 1./60. # Gaussian prior: mean=0, sigma=1.0 arcminute cube[3+4*ibeam+2] = (2**0.5)*sigma*erfinv(2*cube[3+4*ibeam+2]-1) cube[3+4*ibeam+3] = (2**0.5)*sigma*erfinv(2*cube[3+4*ibeam+3]-1) def loglike(cube, ndim, nparams): loglike = 0 x, y, flux = cube[0], cube[1], cube[2] #nbeam = (ndim-3) / 4 for ibeam in range(nbeam): gain_err = cube[3+4*ibeam+0] width_err = cube[3+4*ibeam+1] xpos_err = cube[3+4*ibeam+2] ypos_err = cube[3+4*ibeam+3] gain = beam_gain(x-(xpos[ibeam]+xpos_err), y-(ypos[ibeam]+ypos_err), \ width_err*fwhm[ibeam]) gain *= sens[ibeam] arg = gain*gain_err*flux - flux_data[ibeam] loglike += -arg*arg/(2.0*ferr_data[ibeam]**2.0) cube[3+4*nbeam+ibeam] = gain return loglike ############################################################################ # number of dimensions our problem has parameters = ["x_pos", "y_pos", "SNR"] for ibeam in range(nbeam): parameters.append("gain_err_" + beam_name[ibeam]) parameters.append("width_err_" + beam_name[ibeam]) parameters.append("xpos_err_" + beam_name[ibeam]) parameters.append("ypos_err_" + beam_name[ibeam]) n_dims = len(parameters) # dimensionality (no. of free parameters) for ibeam in range(nbeam): parameters.append("gain_" + beam_name[ibeam]) n_params = len(parameters) # total parameters (free + derived) rootbase = "chains/%s-" % (out_name) # root for output files chaindir = os.path.join(os.path.abspath(out_dir), "chains") root = os.path.join(os.path.abspath(out_dir), rootbase) os.system("mkdir -p -v " + chaindir) # create temprory sub-dir # Tunable MultiNest Parameters mmodal = False # do mode separation nlive = 1000 # number of live points tol = 0.1 # defines the stopping criteria (0.5, good enough) efr = 1.0 # sampling efficiency. 0.8 and 0.3 are recommended updInt = 1000 # after # iterations feedback & the posterior files update resume = False # resume from a previous job maxiter = 0 # max no. of iteration. 0 is unlimited initMPI = True # initialize MPI routines?, False if main program handles init # run MultiNest pymultinest.run(loglike, prior, n_dims, n_params=n_params, multimodal=mmodal, n_live_points=nlive, \ evidence_tolerance=tol, sampling_efficiency=efr, n_iter_before_update=updInt, \ outputfiles_basename=root, verbose = verbose, resume=resume, max_iter=maxiter, \ init_MPI=initMPI) # other default inputs # n_clustering_params=None, wrapped_params=None, importance_nested_sampling=True, # const_efficiency_mode=False, null_log_evidence=-1e+90, max_modes=100, seed=-1, # mode_tolerance=-1e+90, context=0, write_output=True, log_zero=-1e+100, dump_callback=None ######################################################################################### check_files(root) a = pymultinest.Analyzer(n_params = n_params, outputfiles_basename = root) s = a.get_stats() # store name of parameters, always useful with open('%sparams.json' % root, 'w') as f: json.dump(parameters, f, indent=2) # store derived stats with open('%sstats.json' % root, mode='w') as f: json.dump(s, f, indent=2) print(" marginal likelihood:") print(" ln Z = %.1f +- %.1f'" % (s['global evidence'], s['global evidence error'])) print(" parameters:") for p, m in zip(parameters, s['marginals']): lo, hi = m['1sigma'] med = m['median'] sigma = (hi - lo) / 2 if sigma == 0: i = 3 else: i = max(0, int(-np.floor(np.log10(sigma))) + 1) fmt = '%%.%df' % i fmts = '\t'.join([' %-15s' + fmt + " +- " + fmt]) print(fmts % (p, med, sigma)) ######################################################################################### print("creating marginal plot ...") bins = 50 postdata = a.get_equal_weighted_posterior()[:,:3] # only x_pos, y_pos, and SNR cornerdata = postdata.copy() cornerdata[:,2] = np.log10(cornerdata[:,2]) cornerfig = corner.corner(cornerdata, labels=["x_pos", "y_pos", "log SNR"], show_titles=True, \ bins=50, smooth=True, smooth1d=True) beam_posfig = plot_beam_pos(postdata, frb_data, rad1400, bins, color="blue") outfile = os.path.join(os.path.abspath(out_dir), out_name) if save: beam_mapfig.savefig(outfile+'_beammap.pdf', bbox_inches='tight', papertype='letter', \ orientation='landscape') cornerfig.savefig(outfile+'_cornerplot.pdf', bbox_inches='tight', papertype='letter', \ orientation='landscape') beam_posfig.savefig(outfile+'_beampos.pdf', bbox_inches='tight', papertype='letter', \ orientation='landscape') plt.close("all") else: plt.show() # write posterior image in fits file write_fits(postdata, bins, outfile, xoff, yoff, weights=None) return frb_data, postdata, rad1400
ssfr2d = np.tile(ssfr[np.newaxis, :], (b.size, 1)) sam_ssfr2d = np.tile(sam_ssfr[np.newaxis, :], (b.size, 1)) #Run MultiNest pymultinest.run(myloglike, myprior, n_params, importance_nested_sampling=False, resume=False, verbose=True, sampling_efficiency='model', n_live_points=500, outputfiles_basename='chains2/q_PL_twogal_redd_ssfr-') #Analyse the results and plot the marginals ana = pymultinest.Analyzer( n_params=n_params, outputfiles_basename='chains2/q_PL_twogal_redd_ssfr-') plt.clf() # Here we will plot all the marginals and whatnot, just to show off # You may configure the format of the output here, or in matplotlibrc # All pymultinest does is filling in the data of the plot. # Copy and edit this file, and play with it. p = pymultinest.PlotMarginalModes(ana) plt.figure(figsize=(5 * n_params, 5 * n_params)) #plt.subplots_adjust(wspace=0, hspace=0) for i in range(n_params): plt.subplot(n_params, n_params, n_params * i + i + 1) p.plot_marginal(i, with_ellipses=True, with_points=False, grid_points=50)
n_params = len(parameters) pymultinest.run(myloglike, myprior, n_params, importance_nested_sampling=False, resume=True, verbose=True, sampling_efficiency='parameter', n_live_points=1000, outputfiles_basename='%s/2-' % plotDir, evidence_tolerance=0.001, multimodal=False) # lets analyse the results a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename='%s/2-' % plotDir) s = a.get_stats() import json # store name of parameters, always useful with open('%sparams.json' % a.outputfiles_basename, 'w') as f: json.dump(parameters, f, indent=2) # store derived stats with open('%sstats.json' % a.outputfiles_basename, mode='w') as f: json.dump(s, f, indent=2) print() print("-" * 30, 'ANALYSIS', "-" * 30) print("Global Evidence:\n\t%.15e +- %.15e" % (s['nested sampling global log-evidence'], s['nested sampling global log-evidence error']))
def multinest(nu, D, Ninv, beam_mat, ndim, models_fit, label): import pymultinest import json if not os.path.exists("chains"): os.mkdir("chains") parameters = ["dust_beta", "dust_Td", "sync_beta"] n_params = len(parameters) def prior_multi(cube, ndim, nparams): cube[0] = 0 + 3 * cube[0] cube[1] = 5 + 95 * cube[1] cube[2] = -5 + 5 * cube[2] def loglike_multi(cube, ndim, nparams): dust_beta, dust_Td, sync_beta = cube[0], cube[1], cube[2] dust_params = np.array([dust_beta, dust_Td]) sync_params = np.array([sync_beta]) cmb_params = np.array([]) (F_fg, F_cmb, F) = F_matrix(nu, dust_params, sync_params, cmb_params, models_fit) H = F_fg.T * Ninv * F_fg x_mat = np.linalg.inv(F.T * beam_mat.T * Ninv * beam_mat * F) * F.T * beam_mat.T * Ninv * D # Equation A3 chi_square = (D - beam_mat * F * x_mat).T * Ninv * ( D - beam_mat * F * x_mat) # Equation A4 return -chi_square - 0.5 * np.log(np.linalg.det(H)) pymultinest.run(loglike_multi, prior_multi, n_params, outputfiles_basename='chains/single_pixel_', resume=False, verbose=True, n_live_points=1000, importance_nested_sampling=False) a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename='chains/single_pixel_') s = a.get_stats() output = a.get_equal_weighted_posterior() outfile = 'test.out' pickle.dump(output, open(outfile, "wb")) # store name of parameters, always useful with open('%sparams.json' % a.outputfiles_basename, 'w') as f: json.dump(parameters, f, indent=2) # store derived stats with open('%sstats.json' % a.outputfiles_basename, mode='w') as f: json.dump(s, f, indent=2) print() print("-" * 30, 'ANALYSIS', "-" * 30) print("Global Evidence:\n\t%.15e +- %.15e" % (s['nested sampling global log-evidence'], s['nested sampling global log-evidence error'])) # Plots p = pymultinest.PlotMarginalModes(a) plt.figure(figsize=(5 * n_params, 5 * n_params)) for i in range(n_params): plt.subplot(n_params, n_params, n_params * i + i + 1) p.plot_marginal(i, with_ellipses=True, with_points=False, grid_points=50) plt.ylabel("Probability") plt.xlabel(parameters[i]) for j in range(i): plt.subplot(n_params, n_params, n_params * j + i + 1) p.plot_conditional(i, j, with_ellipses=False, with_points=True, grid_points=30) plt.xlabel(parameters[i]) plt.ylabel(parameters[j]) plt.savefig( "chains/single_pixel_marginals_multinest.pdf") #, bbox_inches='tight') for i in range(n_params): outfile = '%s-mode-marginal-%d.pdf' % (a.outputfiles_basename, i) p.plot_modes_marginal(i, with_ellipses=True, with_points=False) plt.ylabel("Probability") plt.xlabel(parameters[i]) plt.savefig(outfile, format='pdf', bbox_inches='tight') plt.close() outfile = '%s-mode-marginal-cumulative-%d.pdf' % ( a.outputfiles_basename, i) p.plot_modes_marginal(i, cumulative=True, with_ellipses=True, with_points=False) plt.ylabel("Cumulative probability") plt.xlabel(parameters[i]) plt.savefig(outfile, format='pdf', bbox_inches='tight') plt.close()
if n_comp == 2: n_sec = [6, 3] n_sled = 2 * sled_to_j * n_mol else: n_sec = [3] n_sled = sled_to_j * n_mol n_params = n_dims + np.sum(n_sec) + n_sled meas = pickle.load(open("measdata.pkl", "rb")) lw = np.log10(meas['head']['lw']) # If meas doesn't include tbg, just the old default, 2.73 K if 'tbg' not in meas: meas['tbg'] = 2.73 # If not calculated using multimol, won't have secmol. if 'secmol' not in meas['head']: meas['head']['secmol'] = [] a = pymultinest.Analyzer(n_params=n_params) s = a.get_stats() data = a.get_data() # Check if a.post_file exists; this separates the data by mode. #### TEMPORARY FIX, in case old version of pymultinest with typo is being used. if a.post_file == u'chains/1-post_seperate.dat': a.post_file = u'chains/1-post_separate.dat' if os.path.isfile(a.post_file): datsep = post_sep(a.post_file) # Divide the "data" up by mode. else: datsep = {} datsep[0] = data datsep['all'] = data bestfit = a.get_best_fit() cube = bestfit[ 'parameters'] # The best fit is not the same as the mode, cube=s['modes'][0]['maximum']
os.makedirs('out') parameters = ["beta1", "beta2", "p_F", "p_b", "F_0", r"$nu_{b_0}$"] n_params = len(parameters) pymultinest.run(loglike, prior, n_params, outputfiles_basename='out/' + GRB + '_fit_', resume=False, verbose=True) json.dump(parameters, open('out/' + GRB + '_fit_' + 'params.json', 'w')) # plot the distribution of a posteriori possible models plt.figure() # plt.plot(x, ydata, '+ ', color='red', label='data') a = pymultinest.Analyzer(outputfiles_basename='out/' + GRB + '_fit_', n_params=n_params) for (beta1, beta2, p_F, p_b, F_0, nu_b0) in a.get_equal_weighted_posterior()[::100, :-1]: plt.plot(t_data, model_ph(t_data, nu, beta1, beta2, p_F, p_b, F_0, nu_b0), '-', color='blue', alpha=0.3, label='data') plt.xscale('log') plt.savefig('out/' + GRB + '_fit_posterior.png') a_lnZ = a.get_stats()
n_params = 3 out_file = 'out_multinest' if not os.path.exists('fit.pkl'): # Run MultiNest: pymultinest.run(loglike, prior, n_params, n_live_points=500, outputfiles_basename=out_file, resume=False, verbose=True) # Get output: output = pymultinest.Analyzer(outputfiles_basename=out_file, n_params=n_params) # Get out parameters: this matrix has (samples,n_params+1): posterior_samples = output.get_equal_weighted_posterior()[:, :-1] # Save matrix: pickle.dump(posterior_samples, open('fit.pkl', 'wb')) print('Done! Run again to plot') sys.exit() else: posterior_samples = pickle.load(open('fit.pkl', 'rb')) xi = posterior_samples[:, 0] T_n = posterior_samples[:, 1] delta_T = posterior_samples[:, 2] for i in range(5): t, f = all_t[i], all_f[i]
b = ns_setup.Priors(1, n_params) pymultinest.run( b.loglike, b.prior, n_params, loglike_args=[len_x, x_full, bin_indices, opacity_grid, ydata, yerr], outputfiles_basename=output_directory + planet_name + '_', resume=False, verbose=True, n_live_points=live) json.dump(parameters, open(output_directory + planet_name + '_params.json', 'w')) # save parameter names a = pymultinest.Analyzer(outputfiles_basename=output_directory + planet_name + '_', n_params=n_params) samples = a.get_equal_weighted_posterior()[:, :-1] bestfit_params = a.get_best_fit() stats = a.get_stats() ## set up results ## retrieved_results = list( map(lambda v: (v[1], v[2] - v[1], v[1] - v[0]), zip(*np.percentile(samples, [16, 50, 84], axis=0)))) plot_percentiles = [] new_param_dict = parameter_dict retrieved_parameters_full = {} retrieved_parameters_list = [] for i in range(n_params):
def check_solution(folder, Ld_dir, finesse_dir, recover=False, w0=487.98634, mu=39.948): print("I'm here!") data = h5_2_dict(join(folder, 'input_plasma_data.h5')) ix = data['fit_ix'] r = data['r'] sig = data['sig'] Lpost, dpost = read_Ld_results(Ld_dir) Fpost, _, _, _ = read_finesse_results(finesse_dir) nL = len(Lpost) nF = len(Fpost) i = np.random.choice(nL) j = np.random.choice(nF) L = Lpost[i] d = dpost[i] F = Fpost[j] Lstep = 100 Fstep = 100 Tistep = 100 analyzer = pymultinest.Analyzer(3, outputfiles_basename=join(folder, "Ti_")) modes = analyzer.get_mode_stats() Ti, V, A = modes['modes'][0]['mean'] print(modes['modes'][0]['sigma']) print(Ti, V, A) post = analyzer.get_equal_weighted_posterior() Tipost = post[::, 0] Vpost = post[::, 1] Apost = post[::, 2] if recover: try: post_dict = h5_2_dict(join(folder, "Ti_solver_model_post.h5")) sig_post = post_dict["signal post"] except: print( "Can't recover Ti solver q posterior. Calculating from scratch." ) sig_post = calculate_signal_post(r[ix], Lpost[::Lstep], dpost[::Lstep], Fpost[::Fstep], Tipost[::Tistep], Vpost[::Tistep], Apost[::Tistep], w0, mu, nprocs=32) dict_2_h5(join(folder, "Ti_solver_model_post.h5"), {"signal post": sig_post}) else: sig_post = calculate_signal_post(r[ix], Lpost[::Lstep], dpost[::Lstep], Fpost[::Fstep], Tipost[::Tistep], Vpost[::Tistep], Apost[::Tistep], w0, mu, nprocs=32) dict_2_h5(join(folder, "Ti_solver_model_post.h5"), {"signal post": sig_post}) sig_mean = np.mean(sig_post, axis=1) percentiles = calculate_percentile_ranges(sig_post) #vals = forward_model(r[ix], L, d, F, w0, mu, A, Ti, V, sm_ang=False, nlambda=1024) fig, ax = plt.subplots(figsize=(3.5, 3.5 / 1.61)) # ax.plot(r[ix], sig[ix], 'C1', alpha=0.5, label='Data') ax.plot(r[ix], (sig[ix] - 3000.0) / 100.0, 'C1', alpha=0.5, label='Data') #ax.plot(r[ix], vals, 'r') alphas = [0.8, 0.5, 0.2] keys = [68, 95, 99] for alpha, per in zip(alphas, keys): if per == 99: # ax.fill_between(r[ix], percentiles[per][0], percentiles[per][1], color='C3', alpha=alpha, label='Fit') ax.fill_between(r[ix], percentiles[per][0] / 100.0, percentiles[per][1] / 100.0, color='C3', alpha=alpha, label='Fit') else: # ax.fill_between(r[ix], percentiles[per][0], percentiles[per][1], color='C3', alpha=alpha) ax.fill_between(r[ix], percentiles[per][0] / 100.0, percentiles[per][1] / 100.0, color='C3', alpha=alpha) fig.legend(frameon=False, fontsize=8, loc='upper right', bbox_to_anchor=(0.5, 0.5)) ax.set_xlabel("R (px)", fontsize=8, labelpad=-1) ax.set_ylabel("Counts (Hundreds)", fontsize=8, labelpad=-1) ax.tick_params(labelsize=8) #fig.tight_layout() fig.savefig(join(folder, "Ti_Ar_fit.png"), dpi=400) plt.show(block=False) axis_labels = ["Ti (eV)", "V (m/s)", "A (Counts)"] ylabels = ["P(Ti)", "P(V)", "P(A)"] # fig, ax = plt.subplots(3, figsize=(6, 15)) fig, ax = plt.subplots(2, figsize=(3.5, 2 * 3.5 / 1.61)) # for n in range(3): for n in range(2): my_hist(ax[n], post[:, n]) ax[n].set_xlabel(axis_labels[n], fontsize=8, labelpad=-1) ax[n].set_ylabel(ylabels[n], fontsize=8, labelpad=-1) ax[n].tick_params(labelsize=8) #fig.tight_layout() fig.savefig(join(folder, "Ti_solver_histograms.png"), dpi=400) plt.show()
# run MultiNest result = solve(LogLikelihood=myloglike, Prior=myprior, n_dims=n_params, outputfiles_basename=prefix, verbose=True) print() #print('evidence: %(logZ).1f +- %(logZerr).1f' % result) print() print('parameter values:') for name, col in zip(parameters, result['samples'].transpose()): print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std())) # lets analyse the results a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename=prefix) s = a.get_stats() # make marginal plots by running: # $ python multinest_marginals.py chains/3- # For that, we need to store the parameter names: import json with open('%sparams.json' % prefix, 'w') as f: json.dump(parameters, f, indent=2) with open('%sstats.json' % a.outputfiles_basename, mode='w') as f: json.dump(s, f, indent=2) print() print("-" * 30, 'ANALYSIS', "-" * 30) print("Global Evidence:\n\t%.15e +- %.15e" % (s['nested sampling global log-evidence'],
def nlfit(xx, yy, yerr, objects, bounds, myloss='linear'): # have bounds that follow same format as objects # format bounds list blist = [bounds[0][0], bounds[0][1]] # tmid for i in range(1, len(bounds)): for k in bounds[i].keys(): blist.append(bounds[i][k][0]) blist.append(bounds[i][k][1]) # compute integrations for as long as the max epoch ndays = np.round(1.5 * (max(xx) + 1) * objects[1]['P']).astype(int) # prevents seg fault in MultiNest yerr[yerr == 0] = np.mean(yerr[yerr != 0]) def model_sim(params): c = 1 for i in range(1, len(bounds)): for k in bounds[i].keys(): objects[i][k] = params[c] c += 1 # create REBOUND simulation return get_ttv(objects, ndays) def myprior(cube, ndim, n_params): for i in range(int(len(blist) / 2)): # for only the free params cube[i] = (blist[2 * i + 1] - blist[2 * i]) * cube[i] + blist[2 * i] loss = { 'linear': lambda z: z, 'soft_l1': lambda z: 2 * ((1 + z)**0.5 - 1), } omegas = [] def myloglike(cube, ndim, n_params): epochs, ttv, tt = model_sim(cube) ttv_data = yy - (cube[1] * xx + cube[0]) try: loglike = -np.sum(loss[myloss]( ((ttv_data - ttv[xx.astype(int)]) / yerr)**2)) * 0.5 return loglike except: loglike = 0 for i in range(len(ttv)): loglike += loss[myloss](((ttv_data[i] - ttv[i]) / yerr[i])**2) return -10 * np.sum(loglike) # penalize for unstable orbits # period usually changes ~30 seconds to a minute after N-body integrations # therefore the method below subtracts the wrong period from the data #ttvm = tt[xx.astype(int)] - (cube[1]*xx+cube[0]) #return -np.sum( ((ttv_data-ttvm)/yerr)**2 )*0.5 pymultinest.run(myloglike, myprior, int(len(blist) / 2), resume=False, evidence_tolerance=0.5, sampling_efficiency=0.5, n_live_points=200, verbose=True) a = pymultinest.Analyzer(n_params=int(len(blist) / 2)) # gets the marginalized posterior probability distributions posteriors = a.get_data() stats = a.get_stats() stats['marginals'] = get_stats(posteriors) # map posteriors back to object dict obj = copy.deepcopy(objects) mask = posteriors[:, 1] < np.percentile(posteriors[:, 1], 50) c = 1 for i in range(1, len(bounds)): for k in bounds[i].keys(): obj[i][k] = np.median(posteriors[mask, 2 + c]) c += 1 return obj, posteriors, stats