Example #1
0
    def testKalmanp(self):
        pModel  = 4
        qModel  = 0
        sampler = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                          self.xdata, self.ydata, self.dydata, 
                                          pModel, qModel, self.nWalkers, False, self.nThin)
        psampler = carmcmc.CarmaSample(np.array(self.xdata), np.array(self.ydata), np.array(self.dydata), sampler)
        sigsqr   = (psampler._samples["sigma"][0]**2)[0]
        ma_coefs = carmcmc.vecD()
        ma_coefs0 = psampler._samples["ma_coefs"][0]
        if len(ma_coefs0) != pModel:
            ma_coefs0 = np.append(ma_coefs0, np.zeros(pModel - qModel - 1))
        ma_coefs.extend(ma_coefs0)

        omega    = carmcmc.vecC()
        for i in range(psampler.p):
            omega.append(psampler._samples["ar_roots"][0][i])
        #import pdb; pdb.set_trace()

        kfilter = carmcmc.KalmanFilterp(self.xdata, self.ydata, self.dydata, sigsqr, omega, ma_coefs)
        kfilter.Filter()
        pred0 = kfilter.Predict(self.xdata[0]) # evaluate at data point
        val0  = pred0.first
        var0  = pred0.second
        predN = kfilter.Predict(self.xdata[-1]+1)  # extrapolate
        valN  = predN.first
        varN  = predN.second
        self.assertTrue(varN > var0)
Example #2
0
    def testKalmanp(self):
        pModel = 4
        qModel = 0
        sampler = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                         self.xdata, self.ydata, self.dydata,
                                         pModel, qModel, self.nWalkers, False,
                                         self.nThin)
        psampler = carmcmc.CarmaSample(np.array(self.xdata),
                                       np.array(self.ydata),
                                       np.array(self.dydata), sampler)
        sigsqr = (psampler._samples["sigma"][0]**2)[0]
        ma_coefs = carmcmc.vecD()
        ma_coefs0 = psampler._samples["ma_coefs"][0]
        if len(ma_coefs0) != pModel:
            ma_coefs0 = np.append(ma_coefs0, np.zeros(pModel - qModel - 1))
        ma_coefs.extend(ma_coefs0)

        omega = carmcmc.vecC()
        for i in range(psampler.p):
            omega.append(psampler._samples["ar_roots"][0][i])
        #import pdb; pdb.set_trace()

        kfilter = carmcmc.KalmanFilterp(self.xdata, self.ydata, self.dydata,
                                        sigsqr, omega, ma_coefs)
        kfilter.Filter()
        pred0 = kfilter.Predict(self.xdata[0])  # evaluate at data point
        val0 = pred0.first
        var0 = pred0.second
        predN = kfilter.Predict(self.xdata[-1] + 1)  # extrapolate
        valN = predN.first
        varN = predN.second
        self.assertTrue(varN > var0)
Example #3
0
    def __init__(self, t, y, dy, p=2, q=1):
        self._t = t.copy()
        self._y = y.copy()
        self._dy = dy.copy()

        self._p = p
        self._q = q

        self._tv = cm.vecD()
        self._tv.extend(t)

        self._yv = cm.vecD()
        self._yv.extend(y)

        self._dyv = cm.vecD()
        self._dyv.extend(dy)

        self._carma_process = cm.run_mcmc_carma(1, 1, self._tv, self._yv,
                                                self._dyv, self.p, self.q, 1,
                                                False, 1)

        self._carma_process.SetMLE(True)

        self._T = self.t[-1] - self.t[0]
        self._dt_min = np.min(np.diff(self.t))

        self._mean_variance()
Example #4
0
def doit(args):
    pModel   = int(args[0])
    x, y, dy = args[1]

    nSample    = 10000
    nBurnin    = 1000
    nThin      = 1
    nWalkers   = 10

    # Should not have to do this...
    xv         = carmcmc.vecD()
    xv.extend(x)
    yv         = carmcmc.vecD()
    yv.extend(y)
    dyv        = carmcmc.vecD()
    dyv.extend(dy)

    if pModel == 1:
        sampler = carmcmc.run_mcmc_car1(nSample, nBurnin, xv, yv, dyv, nWalkers, nThin)
        samplep = carmcmc.CarSample1(x, y, dy, sampler)
    else:
        sampler = carmcmc.run_mcmc_carma(nSample, nBurnin, xv, yv, dyv, pModel, 0, nWalkers, False, nThin)
        samplep = carmcmc.CarmaSample(x, y, dy, sampler)
        
    dic = samplep.DIC()
    print "DIC", pModel, dic
    return samplep
Example #5
0
 def testCarpDefaults(self):
     pModel  = 3
     qModel  = 1
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers, False)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers, False, self.nThin)
     guess     = cppSample.getSamples()[0]
     print "Should be using:", np.array(guess)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers, False, self.nThin, guess)
Example #6
0
 def testCarpDefaults(self):
     pModel = 3
     qModel = 1
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers,
                                        False)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers,
                                        False, self.nThin)
     guess = cppSample.getSamples()[0]
     print "Should be using:", np.array(guess)
     cppSample = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                        self.xdata, self.ydata, self.dydata,
                                        pModel, qModel, self.nWalkers,
                                        False, self.nThin, guess)
Example #7
0
    def testCarpq(self, pModel=3, qModel=2):
        sampler = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin, 
                                         self.xdata, self.ydata, self.dydata, 
                                         pModel, qModel, self.nWalkers, False, self.nThin)
        psampler = carmcmc.CarmaSample(np.array(self.xdata), np.array(self.ydata), np.array(self.dydata), sampler)
        self.assertEqual(psampler.p, pModel+qModel)

        psamples  = np.array(sampler.getSamples())
        ploglikes = np.array(sampler.GetLogLikes())
        sample0   = carmcmc.vecD()
        sample0.extend(psamples[0])
        logprior0 = sampler.getLogPrior(sample0)
        loglike0  = sampler.getLogDensity(sample0)
        # OK, this is where I truly test that sampler is of class CARp and not CAR1
        self.assertAlmostEqual(ploglikes[0], loglike0)
Example #8
0
    def __setstate__(self, d):
        self.__dict__.update(d)

        self._tv = cm.vecD()
        self._tv.extend(self.t)

        self._yv = cm.vecD()
        self._yv.extend(self.y)

        self._dyv = cm.vecD()
        self._dyv.extend(self.dy)

        self._carma_process = cm.run_mcmc_carma(1, 1, self._tv, self._yv,
                                                self._dyv, self.p, self.q, 1,
                                                False, 1)
        self._carma_process.SetMLE(True)
Example #9
0
    def testCarpq(self, pModel=3, qModel=2):
        sampler = carmcmc.run_mcmc_carma(self.nSample, self.nBurnin,
                                         self.xdata, self.ydata, self.dydata,
                                         pModel, qModel, self.nWalkers, False,
                                         self.nThin)
        psampler = carmcmc.CarmaSample(np.array(self.xdata),
                                       np.array(self.ydata),
                                       np.array(self.dydata), sampler)
        self.assertEqual(psampler.p, pModel + qModel)

        psamples = np.array(sampler.getSamples())
        ploglikes = np.array(sampler.GetLogLikes())
        sample0 = carmcmc.vecD()
        sample0.extend(psamples[0])
        logprior0 = sampler.getLogPrior(sample0)
        loglike0 = sampler.getLogDensity(sample0)
        # OK, this is where I truly test that sampler is of class CARp and not CAR1
        self.assertAlmostEqual(ploglikes[0], loglike0)