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)
示例#2
0
    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)
示例#3
0
文件: mcmc.py 项目: DES-SL/EasyLens
    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
示例#4
0
    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())
示例#7
0
    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
示例#9
0
    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())
示例#11
0
    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
示例#12
0
    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
示例#13
0
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
示例#17
0
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")
示例#19
0
    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
示例#20
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 __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()
示例#22
0
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",
示例#24
0
    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.')
示例#25
0
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: