def test_createChainContext(self): chain = LikelihoodComputationChain() p = np.array([1,2]) ctx = chain.createChainContext(p) assert ctx is not None assert np.all(ctx.getParams() == p)
def test_createChainContext(self): chain = LikelihoodComputationChain() p = np.array([1, 2]) ctx = chain.createChainContext(p) assert ctx is not None assert np.all(ctx.getParams() == p)
def mcmc_CH(self, walkerRatio, n_run, n_burn, mean_start, sigma_start, lowerLimit, upperLimit, threadCount=1, init_pos=None, mpi_monch=False): """ runs mcmc on the parameter space given parameter bounds with CosmoHammerSampler returns the chain """ params = np.array([mean_start, lowerLimit, upperLimit, sigma_start]).T chain = LikelihoodComputationChain( min=lowerLimit, max=upperLimit) temp_dir = tempfile.mkdtemp("Hammer") file_prefix = os.path.join(temp_dir, "logs") # chain.addCoreModule(CambCoreModule()) chain.addLikelihoodModule(self.chain) chain.setup() store = InMemoryStorageUtil() if mpi_monch is True: sampler = MpiCosmoHammerSampler( params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=1, initPositionGenerator=init_pos, storageUtil=store) else: sampler = CosmoHammerSampler( params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=threadCount, initPositionGenerator=init_pos, storageUtil=store) time_start = time.time() #if sampler.isMaster(): # print('Computing the MCMC...') # print('Number of walkers = ', len(mean_start)*walkerRatio) # print('Burn-in itterations: ', n_burn) # print('Sampling itterations:', n_run) sampler.startSampling() #if sampler.isMaster(): # time_end = time.time() # print(time_end - time_start, 'time taken for MCMC sampling') # if sampler._sampler.pool is not None: # sampler._sampler.pool.close() try: shutil.rmtree(temp_dir) except Exception as ex: print(ex) pass return store.samples, store.prob
def test_createChainContext_params(self): keys = ["a", "b"] params = Params((keys[0], 0), (keys[1], 1)) chain = LikelihoodComputationChain() chain.params = params p = np.array([1, 2]) ctx = chain.createChainContext(p) assert ctx is not None assert np.all(ctx.getParams().keys == keys) assert np.all(ctx.getParams()[0] == p[0]) assert np.all(ctx.getParams()[1] == p[1])
def test_createChainContext_params(self): keys = ["a", "b"] params = Params((keys[0], 0), (keys[1], 1)) chain = LikelihoodComputationChain() chain.params = params p = np.array([1,2]) ctx = chain.createChainContext(p) assert ctx is not None assert np.all(ctx.getParams().keys == keys) assert np.all(ctx.getParams()[0] == p[0]) assert np.all(ctx.getParams()[1] == p[1])
def setup(self): """ Initialise some data vectors used for the comparisons by the other functions. """ self.params = np.array([[70, 40, 100, 3], [0.0226, 0.005, 0.1, 0.001], [0.122, 0.01, 0.99, 0.01], [2.1e-9, 1.48e-9, 5.45e-9, 1e-10], [0.96, 0.5, 1.5, 0.02], [0.09, 0.01, 0.8, 0.03], [1,0,2,0.4] ]) #the real means.. means = [70.704, 0.02256, 0.1115, 2.18474E-09, 0.9688, 0.08920] # ...and non-trivial covariance matrix. cov = np.array([[6.11E+00, 0, 0, 0, 0, 0], [7.19E-04, 3.26E-07, 0, 0, 0, 0], [-1.19E-02, -3.37E-07, 3.14E-05, 0, 0, 0], [-3.56E-11, 1.43E-14, 1.76E-13, 5.96E-21, 0, 0], [2.01E-02, 6.37E-06, -2.13E-05, 3.66E-13, 1.90E-04, 0], [1.10E-02, 2.36E-06, -1.92E-05, 8.70E-13, 7.32E-05, 2.23E-04]]) cov += cov.T - np.diag(cov.diagonal()) # Invert the covariance matrix icov = np.linalg.inv(cov) chain = LikelihoodComputationChain() pseudoLikelihood = PseudoCmbModule(icov, means) chain.addLikelihoodModule(pseudoLikelihood) chain.setup() posGen = FlatPositionGenerator() self.sampler = CosmoHammerSampler( params= self.params, likelihoodComputationChain=chain, filePrefix=self._getTempFilePrefix(), walkersRatio=10, burninIterations=1, sampleIterations=11, initPositionGenerator=posGen, storageUtil=InMemoryStorageUtil())
def mcmc_CH(self, walkerRatio, n_run, n_burn, mean_start, sigma_start, threadCount=1, init_pos=None, mpi_monch=False): """ runs mcmc on the parameter space given parameter bounds with CosmoHammerSampler returns the chain """ lowerLimit, upperLimit = self.cosmoParam.param_bounds params = np.array([mean_start, lowerLimit, upperLimit, sigma_start]).T chain = LikelihoodComputationChain( min=lowerLimit, max=upperLimit) temp_dir = tempfile.mkdtemp("Hammer") file_prefix = os.path.join(temp_dir, "logs") # chain.addCoreModule(CambCoreModule()) chain.addLikelihoodModule(self.chain) chain.setup() store = InMemoryStorageUtil() if mpi_monch is True: sampler = MpiCosmoHammerSampler( params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=1, initPositionGenerator=init_pos, storageUtil=store) else: sampler = CosmoHammerSampler( params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=threadCount, initPositionGenerator=init_pos, storageUtil=store) time_start = time.time() if sampler.isMaster(): print('Computing the MCMC...') print('Number of walkers = ', len(mean_start)*walkerRatio) print('Burn-in itterations: ', n_burn) print('Sampling itterations:', n_run) sampler.startSampling() if sampler.isMaster(): time_end = time.time() print(time_end - time_start, 'time taken for MCMC sampling') # if sampler._sampler.pool is not None: # sampler._sampler.pool.close() try: shutil.rmtree(temp_dir) except Exception as ex: print(ex) pass return store.samples
def test_init(self): self.sampler = CosmoHammerSampler( params=self.params, likelihoodComputationChain=LikelihoodComputationChain(), filePrefix=self._getTempFilePrefix(), walkersRatio=10, burninIterations=1, sampleIterations=1) assert isinstance(self.sampler.storageUtil, SampleFileUtil) assert isinstance(self.sampler.stopCriteriaStrategy, IterationStopCriteriaStrategy) assert isinstance(self.sampler.initPositionGenerator, SampleBallPositionGenerator) assert self.sampler.likelihoodComputationChain.params is not None
def __init__(self, data, nbins, noise=0., div=1.0, like_func='c'): """ :param data: load your data :param nbins: number of k-modes in powerspectrum OR number of triangle contributions in bispectrum (for covariance matrix) :param noise: system noise, e.g. SKA, MWA noise response (if any), default 0.0, :param div: likelihood normalization factor, default 1.0, :param like_func: choose between complex likelihood function (use 'c'), and normal function (use 'n') """ chain = LikelihoodComputationChain(min=params[:, 1], max=params[:, 2]) chain.params = params if like_func == 'n': chain.addLikelihoodModule(LikeModule(data, nbins, noise, div)) else: chain.addLikelihoodModule(ComplexLikeModule(data, nbins, noise)) self.chain = chain
def setup(self): """ Initialise some data vectors used for the comparisons by the other functions. """ self.params = np.array([[70, 40, 100, 3], [0.0226, 0.005, 0.1, 0.001], [0.122, 0.01, 0.99, 0.01], [2.1e-9, 1.48e-9, 5.45e-9, 1e-10], [0.96, 0.5, 1.5, 0.02], [0.09, 0.01, 0.8, 0.03], [1, 0, 2, 0.4]]) #the real means.. means = [70.704, 0.02256, 0.1115, 2.18474E-09, 0.9688, 0.08920] # ...and non-trivial covariance matrix. cov = np.array( [[6.11E+00, 0, 0, 0, 0, 0], [7.19E-04, 3.26E-07, 0, 0, 0, 0], [-1.19E-02, -3.37E-07, 3.14E-05, 0, 0, 0], [-3.56E-11, 1.43E-14, 1.76E-13, 5.96E-21, 0, 0], [2.01E-02, 6.37E-06, -2.13E-05, 3.66E-13, 1.90E-04, 0], [1.10E-02, 2.36E-06, -1.92E-05, 8.70E-13, 7.32E-05, 2.23E-04]]) cov += cov.T - np.diag(cov.diagonal()) # Invert the covariance matrix icov = np.linalg.inv(cov) chain = LikelihoodComputationChain() pseudoLikelihood = PseudoCmbModule(icov, means) chain.addLikelihoodModule(pseudoLikelihood) chain.setup() posGen = FlatPositionGenerator() self.sampler = CosmoHammerSampler(params=self.params, likelihoodComputationChain=chain, filePrefix=self._getTempFilePrefix(), walkersRatio=10, burninIterations=1, sampleIterations=11, initPositionGenerator=posGen, storageUtil=InMemoryStorageUtil())
def mcmc_CH(self, walkerRatio, n_run, n_burn, mean_start, sigma_start, lowerLimit, upperLimit, X2_chain, threadCount=1, init_pos=None): """ runs mcmc on the parameter space given parameter bounds with CosmoHammerSampler returns the chain """ params = np.array([mean_start, lowerLimit, upperLimit, sigma_start]).T chain = LikelihoodComputationChain(min=lowerLimit, max=upperLimit) # chain.addCoreModule(CambCoreModule()) chain.addLikelihoodModule(X2_chain) chain.setup() store = InMemoryStorageUtil() sampler = CosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix="testHammer", walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=threadCount, initPositionGenerator=init_pos, storageUtil=store) sampler.startSampling() if sampler._sampler.pool is not None: sampler._sampler.pool.close() return store.samples
def mcmc_CH(self, walkerRatio, n_run, n_burn, mean_start, sigma_start, threadCount=1, init_pos=None, mpi=False): """ runs mcmc on the parameter space given parameter bounds with CosmoHammerSampler returns the chain """ lowerLimit, upperLimit = self.lower_limit, self.upper_limit mean_start = np.maximum(lowerLimit, mean_start) mean_start = np.minimum(upperLimit, mean_start) low_start = mean_start - sigma_start high_start = mean_start + sigma_start low_start = np.maximum(lowerLimit, low_start) high_start = np.minimum(upperLimit, high_start) sigma_start = (high_start - low_start) / 2 mean_start = (high_start + low_start) / 2 params = np.array([mean_start, lowerLimit, upperLimit, sigma_start]).T chain = LikelihoodComputationChain(min=lowerLimit, max=upperLimit) temp_dir = tempfile.mkdtemp("Hammer") file_prefix = os.path.join(temp_dir, "logs") #file_prefix = "./lenstronomy_debug" # chain.addCoreModule(CambCoreModule()) chain.addLikelihoodModule(self.chain) chain.setup() store = InMemoryStorageUtil() #store = None if mpi is True: sampler = MpiCosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=1, initPositionGenerator=init_pos, storageUtil=store) else: sampler = CosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix=file_prefix, walkersRatio=walkerRatio, burninIterations=n_burn, sampleIterations=n_run, threadCount=threadCount, initPositionGenerator=init_pos, storageUtil=store) time_start = time.time() if sampler.isMaster(): print('Computing the MCMC...') print('Number of walkers = ', len(mean_start) * walkerRatio) print('Burn-in iterations: ', n_burn) print('Sampling iterations:', n_run) sampler.startSampling() if sampler.isMaster(): time_end = time.time() print(time_end - time_start, 'time taken for MCMC sampling') # if sampler._sampler.pool is not None: # sampler._sampler.pool.close() try: shutil.rmtree(temp_dir) except Exception as ex: print(ex, 'shutil.rmtree did not work') pass #samples = np.loadtxt(file_prefix+".out") #prob = np.loadtxt(file_prefix+"prob.out") return store.samples, store.prob
from wmap9Wrapper import WmapExtLikelihoodModule as wmap9 from cambWrapper import CambCoreModule #parameter start center, min, max, start width params = Params(("hubble", [70, 65, 80, 3]), ("ombh2", [0.0226, 0.01, 0.03, 0.001]), ("omch2", [0.122, 0.09, 0.2, 0.01]), ("scalar_amp", [2.1e-9, 1.8e-9, 2.35e-9, 1e-10]), ("scalar_spectral_index", [0.96, 0.8, 1.2, 0.02]), ("re_optical_depth", [0.09, 0.01, 0.1, 0.03]), ("sz_amp", [1,0,2,0.4])) chain = LikelihoodComputationChain( min=params[:,1], max=params[:,2]) camb = CambCoreModule.CambCoreModule() chain.addCoreModule(camb) chain.addLikelihoodModule(wmap9.WmapExtLikelihoodModule()) chain.setup() sampler = MpiCosmoHammerSampler( params= params, likelihoodComputationChain=chain, filePrefix="cosmoHammerWmap9_",
from cosmoHammer.util import InMemoryStorageUtil from cosmoHammer.util import Params from cosmoHammer.modules import PseudoCmbModule from cosmoHammer.pso.ParticleSwarmOptimizer import ParticleSwarmOptimizer #parameter start center, min, max, start width params = Params(("hubble", [70, 65, 80, 3]), ("ombh2", [0.0226, 0.01, 0.03, 0.001]), ("omch2", [0.122, 0.09, 0.2, 0.01]), ("scalar_amp", [2.1e-9, 1.8e-9, 2.35e-9, 1e-10]), ("scalar_spectral_index", [0.96, 0.8, 1.2, 0.02]), ("re_optical_depth", [0.09, 0.01, 0.1, 0.03]), ("sz_amp", [1,0,2,0.4])) chain = LikelihoodComputationChain(params[:,1], params[:,2]) chain.params = params chain.addLikelihoodModule(PseudoCmbModule()) chain.setup() # find the best fit value and update our params knowledge print("find best fit point") pso = ParticleSwarmOptimizer(chain, params[:,1], params[:,2]) psoTrace = np.array([pso.gbest.position.copy() for _ in pso.sample()]) params[:, 0] = pso.gbest.position storageUtil = InMemoryStorageUtil() sampler = CosmoHammerSampler( params= params, likelihoodComputationChain=chain,
def test_isValid(self): chain = LikelihoodComputationChain() assert chain.isValid([0]) chain = LikelihoodComputationChain(min=[0]) assert chain.isValid([1]) assert chain.isValid([0]) assert not chain.isValid([-1]) chain = LikelihoodComputationChain(min=[0, 1]) assert chain.isValid([1, 2]) assert chain.isValid([0, 1]) assert not chain.isValid([-1, 1]) assert not chain.isValid([0, 0]) assert not chain.isValid([-1, 0]) chain = LikelihoodComputationChain(max=[1]) assert chain.isValid([1]) assert chain.isValid([0]) assert not chain.isValid([2]) chain = LikelihoodComputationChain(max=[1, 2]) assert chain.isValid([0, 1]) assert chain.isValid([1, 2]) assert not chain.isValid([2, 2]) assert not chain.isValid([1, 3]) assert not chain.isValid([2, 3]) chain = LikelihoodComputationChain(min=[0, 1], max=[1, 2]) assert chain.isValid([1, 2]) assert chain.isValid([0, 1]) assert chain.isValid([0, 1]) assert chain.isValid([1, 2]) assert not chain.isValid([-1, 1]) assert not chain.isValid([0, 0]) assert not chain.isValid([-1, 0]) assert not chain.isValid([2, 2]) assert not chain.isValid([1, 3]) assert not chain.isValid([2, 3]) like, data = chain([-1, 0]) assert like == -np.inf assert len(data) == 0 like, data = chain([2, 3]) assert like == -np.inf assert len(data) == 0
def test_modules(self): chain = LikelihoodComputationChain() assert len(chain.getCoreModules())==0 assert len(chain.getLikelihoodModules())==0 coreModule = DummyModule() likeModule = DummyModule() chain.addCoreModule(coreModule) chain.addLikelihoodModule(likeModule) assert len(chain.getCoreModules())==1 assert len(chain.getLikelihoodModules())==1 chain.setup() assert coreModule.init assert likeModule.init like, data = chain([0]) assert coreModule.called assert likeModule.compLike assert like == DummyModule.like assert len(data) == 1 assert data["data"] == DummyModule.data
from cosmoHammer import MpiCosmoHammerSampler from cosmoHammer import LikelihoodComputationChain from cosmoHammer.util import Params from wmap9Wrapper import WmapExtLikelihoodModule as wmap9 from cambWrapper import CambCoreModule #parameter start center, min, max, start width params = Params( ("hubble", [70, 65, 80, 3]), ("ombh2", [0.0226, 0.01, 0.03, 0.001]), ("omch2", [0.122, 0.09, 0.2, 0.01]), ("scalar_amp", [2.1e-9, 1.8e-9, 2.35e-9, 1e-10]), ("scalar_spectral_index", [0.96, 0.8, 1.2, 0.02]), ("re_optical_depth", [0.09, 0.01, 0.1, 0.03]), ("sz_amp", [1, 0, 2, 0.4])) chain = LikelihoodComputationChain(min=params[:, 1], max=params[:, 2]) camb = CambCoreModule.CambCoreModule() chain.addCoreModule(camb) chain.addLikelihoodModule(wmap9.WmapExtLikelihoodModule()) chain.setup() sampler = MpiCosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix="cosmoHammerWmap9_", walkersRatio=20, burninIterations=0, sampleIterations=50)
means = np.random.rand(ndim) # ...and a positive definite, non-trivial covariance matrix. cov = 0.5-np.random.rand(ndim**2).reshape((ndim, ndim)) cov = np.triu(cov) cov += cov.T - np.diag(cov.diagonal()) cov = np.dot(cov,cov) # Invert the covariance matrix first. icov = np.linalg.inv(cov) params = [[0, -5, 5, 1] ]*ndim params = np.array(params) chain = LikelihoodComputationChain(params[:,1],params[:,2]) multivarianteGaussian = MultivarianteGaussianModule(icov, means) chain.addLikelihoodModule(multivarianteGaussian) chain.setup() sampler = CosmoHammerSampler( params= params, likelihoodComputationChain=chain, filePrefix="multivariantGausian", walkersRatio=50, burninIterations=0, sampleIterations=100, ) print("start sampling")
def test_modules(self): chain = LikelihoodComputationChain() assert len(chain.getCoreModules()) == 0 assert len(chain.getLikelihoodModules()) == 0 coreModule = DummyModule() likeModule = DummyModule() chain.addCoreModule(coreModule) chain.addLikelihoodModule(likeModule) assert len(chain.getCoreModules()) == 1 assert len(chain.getLikelihoodModules()) == 1 chain.setup() assert coreModule.init assert likeModule.init like, data = chain([0]) assert coreModule.called assert likeModule.compLike assert like == DummyModule.like assert len(data) == 1 assert data["data"] == DummyModule.data
""" from __future__ import print_function, division, absolute_import, unicode_literals from cosmoHammer import CosmoHammerSampler from cosmoHammer import LikelihoodComputationChain from cosmoHammer.modules import RosenbrockModule from cosmoHammer.util import Params #parameter start center, min, max, start width params = Params(("x", [1, -10, 10, 0.1]), ("y", [1, -10, 10, 0.1])) chain = LikelihoodComputationChain() rosenbrock = RosenbrockModule() chain.addLikelihoodModule(rosenbrock) chain.setup() sampler = CosmoHammerSampler( params= params, likelihoodComputationChain=chain, filePrefix="rosenbrock", walkersRatio=50, burninIterations=100, sampleIterations=100) sampler.startSampling()
from cosmoHammer import MpiCosmoHammerSampler from cosmoHammer import LikelihoodComputationChain from cosmoHammer.util import Params from MCMC.Power_sampler.Power_like import PSlikeModule as slk from MCMC.Power_sampler.Power_core import PScore #======================================================================================================================# params = Params(("n_ion", [250., 10.0, 510.0, 1.0]), ("R_mfp", [38.0, 5.0, 70.0, .5]), ("NoH", [750.0, 10.0, 1510.0, 1.0])) #==========The parameter space is defined================================# #======================================================================================================================# chain = LikelihoodComputationChain(min=params[:, 1], max=params[:, 2]) chain.addCoreModule( PScore()) #=========setting up the modules===================# chain.addLikelihoodModule(slk()) chain.setup() #======================================================================================================================# sampler = MpiCosmoHammerSampler( params=params, likelihoodComputationChain= chain, #=============mpi sampler===============================# filePrefix="Powerspectrum_THANN_", walkersRatio=10, burninIterations=250,
from cosmoHammer import CosmoHammerSampler from cosmoHammer.util import InMemoryStorageUtil from cosmoHammer.util import Params from cosmoHammer.modules import PseudoCmbModule from cosmoHammer.pso.ParticleSwarmOptimizer import ParticleSwarmOptimizer #parameter start center, min, max, start width params = Params( ("hubble", [70, 65, 80, 3]), ("ombh2", [0.0226, 0.01, 0.03, 0.001]), ("omch2", [0.122, 0.09, 0.2, 0.01]), ("scalar_amp", [2.1e-9, 1.8e-9, 2.35e-9, 1e-10]), ("scalar_spectral_index", [0.96, 0.8, 1.2, 0.02]), ("re_optical_depth", [0.09, 0.01, 0.1, 0.03]), ("sz_amp", [1, 0, 2, 0.4])) chain = LikelihoodComputationChain(params[:, 1], params[:, 2]) chain.params = params chain.addLikelihoodModule(PseudoCmbModule()) chain.setup() # find the best fit value and update our params knowledge print("find best fit point") pso = ParticleSwarmOptimizer(chain, params[:, 1], params[:, 2]) psoTrace = np.array([pso.gbest.position.copy() for _ in pso.sample()]) params[:, 0] = pso.gbest.position storageUtil = InMemoryStorageUtil() sampler = CosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix="pseudoCmb_pso",
else: hmparams = None else: cosmo = hmparams = None param_mapping = {} nparams = len(fit_params.keys()) params = np.zeros((nparams, 4)) for key in fit_params.keys(): param_mapping[key] = fit_params[key][0] params[fit_params[key][0], :] = fit_params[key][1:] # Set up CosmoHammer chain = LikelihoodComputationChain( min=params[:, 1], max=params[:, 2]) tracers = config['tracers'] trc_combs = [] if config['fit_comb'] == 'all': logger.info('Fitting auto- and cross-correlations of tracers.') i = 0 for tr_i in tracers: for tr_j in tracers[:i + 1]: # Generate the appropriate list of tracer combinations to plot trc_combs.append([tr_j, tr_i]) i += 1 elif config['fit_comb'] == 'auto': logger.info('Fitting auto-correlations of tracers.')
with h5py.File(init, 'r') as hf: params = np.array(hf.get("params")) inpos = np.array(hf.get("positions")) szs = np.array(hf.get("szs_parms")).astype(int) mins = params[:, 1] maxs = params[:, 2] nparam = len(mins) #-------------------------------------------------------------------------------- ################################################################################################# ####################################### LIKELIHOOD CHAIN ######################## #-------------------- Setup the Chain -------- # if mins, and maxs included, the code performs checkin # and can calculate a null iteration of Generated Quantities in case of rejection print 'Setting up chain' chain = LikelihoodComputationChain() coremodule = CoreModule(szs) logPosterior = LogPosteriorModule(data, threads=k) chain.addCoreModule(coremodule) chain.addLikelihoodModule(logPosterior) chain.setup() ####################################################################################### ############################### Particle Swarm Optimizer ############################# pso = MPSO(chain, low=mins, high=maxs, particleCount=partCount, req=req, threads=1, InPos=inpos) smp = emcee.EnsembleSampler(
#!/usr/bin/env python """ Runs CosmoHammer with a rosenbrock density module """ from __future__ import print_function, division, absolute_import, unicode_literals from cosmoHammer import CosmoHammerSampler from cosmoHammer import LikelihoodComputationChain from cosmoHammer.modules import RosenbrockModule from cosmoHammer.util import Params #parameter start center, min, max, start width params = Params(("x", [1, -10, 10, 0.1]), ("y", [1, -10, 10, 0.1])) chain = LikelihoodComputationChain() rosenbrock = RosenbrockModule() chain.addLikelihoodModule(rosenbrock) chain.setup() sampler = CosmoHammerSampler(params=params, likelihoodComputationChain=chain, filePrefix="rosenbrock", walkersRatio=50, burninIterations=100, sampleIterations=100) sampler.startSampling() try: