Exemplo n.º 1
0
    def test_emulator_setup_loglik(self):
        # set up regular model
        d = SepiaData(x_sim=self.x_sim,
                      y_sim=self.y_sim,
                      y_ind_sim=np.array([0, 1]))
        d.create_K_basis(K=np.eye(2))
        d.transform_xt(x_notrans=True)
        d.standardize_y(scale='columnwise')
        print(d)
        mod = SepiaModel(d)
        print('Emulator model LL=%f \n' % compute_log_lik(mod))

        # set up kron model
        kd = SepiaData(xt_sim_sep=self.x_sim_kron,
                       y_sim=self.y_sim,
                       y_ind_sim=self.y_ind_sim)
        kd.create_K_basis(K=np.eye(2))
        kd.transform_xt(x_notrans=True)
        kd.standardize_y(scale='columnwise')
        print(kd)
        kmod = SepiaModel(kd)
        print('Emulator Sep model LL=%f \n' % compute_log_lik(kmod))

        self.assertAlmostEqual(compute_log_lik(mod),
                               compute_log_lik(kmod),
                               places=5)
        pass
    def test_sim_only_x_and_t(self):
        m = 20
        x = np.random.uniform(-1, 3, (m, 3))
        t = np.random.uniform(-1, 3, (m, 2))
        y = np.random.normal(size=(m, 1))

        data = SepiaData(x_sim=x, t_sim=t, y_sim=y)
        call_data_methods(data)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()
    def test_multivariate_sim_only_setup(self):
        """
        Tests setup for multivariate sim only model
        """

        d = SepiaData(t_sim=self.data_dict['t_sim'], y_sim=self.data_dict['y_sim'], y_ind_sim=self.data_dict['y_ind_sim'])
        print('Testing multivariate sim-only SepiaModelSetup...', flush=True)
        print(d, flush=True)

        # Try it without doing standardization/transform to be sure it doesn't break
        model_notrans = SepiaModel(copy.deepcopy(d))

        # Do explicit transformation
        d.transform_xt()
        d.standardize_y()
        model = SepiaModel(d)

        # Check that either way gives same transformation
        self.assertTrue(np.allclose(model_notrans.data.sim_data.orig_y_mean, model.data.sim_data.orig_y_mean))
        self.assertTrue(np.allclose(model_notrans.data.sim_data.orig_y_sd, model.data.sim_data.orig_y_sd))
        self.assertTrue(np.allclose(model_notrans.data.sim_data.y_std, model.data.sim_data.y_std))
        self.assertTrue(np.allclose(model_notrans.data.sim_data.t_trans, model.data.sim_data.t_trans))

        # Check model components are set up as expected
        self.assertTrue(not model.num.scalar_out)
        self.assertTrue(model.num.sim_only)
        self.assertTrue(model.num.m == 100)
        self.assertTrue(model.num.n == 0)
        self.assertTrue(model.num.p == 1)
        self.assertTrue(model.num.q == 3)
        self.assertTrue(model.num.pu == 5)
        self.assertTrue(model.num.pv == 0)
        #self.assertTrue(np.allclose(model.num.w, model.data.sim_data.y_std)) # TODO compute projection

        # Check parameter setup -- betaU
        betaU = model.params.betaU
        self.assertTrue(betaU.val_shape == (model.num.q + model.num.p, model.num.pu))
        self.assertTrue(betaU.prior.dist == 'Beta')
        self.assertTrue(betaU.mcmc.stepType == 'BetaRho')

        # Check parameter setup -- lamUz
        lamUz = model.params.lamUz
        self.assertTrue(lamUz.val_shape == (1, model.num.pu))
        self.assertTrue(lamUz.prior.dist == 'Gamma')
        self.assertTrue(lamUz.mcmc.stepType == 'PropMH')

        # Check parameter setup -- lamWOs
        lamWOs = model.params.lamWOs
        self.assertTrue(lamWOs.val_shape == (1, 1))
        self.assertTrue(lamWOs.prior.dist == 'Gamma')
        self.assertTrue(lamWOs.mcmc.stepType == 'PropMH')

        # Check parameter setup -- lamWs
        lamWs = model.params.lamWs
        self.assertTrue(lamWs.val_shape == (1, model.num.pu))
        self.assertTrue(lamWs.prior.dist == 'Gamma')
        self.assertTrue(lamWs.mcmc.stepType == 'PropMH')

        mcmc_list_names = [p.name for p in model.params.mcmcList]
        self.assertTrue(set(mcmc_list_names) == set(['betaU', 'lamUz', 'lamWOs', 'lamWs']))
    def test_sim_only_x_only(self):
        m = 20
        x = np.random.uniform(-1, 3, (m, 3))
        y = np.random.normal(size=(m, 50))
        y_ind = np.linspace(0, 1, 50)

        data = SepiaData(x_sim=x, y_sim=y, y_ind_sim=y_ind)
        call_data_methods(data, discrep=False)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        pred.get_y(std=True)
        xpred.get_mu_sigma()
Exemplo n.º 5
0
    def setUp(self, m=100, n=1, nt_sim=50, nt_obs=20, n_theta=3, n_basis=5, sig_n=0.1, seed=42):
        n_hier = 3
        self.hier_idx = np.array([[0, 0, 0]])
        #self.hier_idx = np.array([[1, 1, 1], [2, -1, 2]]) # TODO this fails for multivariate; cant use for univariate now
        multi_data_list = []
        univ_data_list = []
        for si in range(n_hier):
            multi_data_dict = generate_data.generate_multi_sim_and_obs(m=m, n=n, nt_sim=nt_sim, nt_obs=nt_obs,
                                                                       n_theta=n_theta, n_basis=n_basis,
                                                                       sig_n=sig_n, seed=seed)
            univ_data_dict = generate_data.generate_univ_sim_and_obs(m=m, n=n, sig_n=sig_n, seed=seed)

            d = SepiaData(t_sim=univ_data_dict['t_sim'], y_sim=univ_data_dict['y_sim'], y_obs=univ_data_dict['y_obs'])
            d.transform_xt()
            d.standardize_y()
            univ_data_list.append(d)

            d = SepiaData(t_sim=multi_data_dict['t_sim'], y_sim=multi_data_dict['y_sim'],
                          y_ind_sim=multi_data_dict['y_ind_sim'], y_obs=multi_data_dict['y_obs'],
                          y_ind_obs=multi_data_dict['y_ind_obs'])
            d.transform_xt()
            d.standardize_y()
            d.create_K_basis(5)
            d.create_D_basis('constant')
            multi_data_list.append(d)

        self.univ_model_list = [SepiaModel(d) for d in univ_data_list]
        self.multi_model_list = [SepiaModel(d) for d in multi_data_list]
    def test_sim_and_obs_noD_t_only_cat(self):
        m = 20
        n = 10
        t = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 3)), 1 + np.random.choice(3, size=(m, 1))
        ],
                           axis=1)
        y = np.random.normal(size=(m, 50))
        y_ind = np.linspace(0, 1, 50)
        y2 = np.random.normal(size=(n, 20))
        y_ind2 = np.linspace(0, 1, 20)
        cat_inds = [0, 0, 0, 3]

        data = SepiaData(t_sim=t,
                         y_sim=y,
                         y_ind_sim=y_ind,
                         y_obs=y2,
                         y_ind_obs=y_ind2,
                         t_cat_ind=cat_inds)
        call_data_methods(data, discrep=False)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        pred.get_y(std=True)
        xpred.get_mu_sigma()

        pred = SepiaFullPrediction(t_pred=t,
                                   samples=samples,
                                   model=model,
                                   addResidVar=True,
                                   storeMuSigma=True)
        pred.get_u_v()
        pred.get_mu_sigma()
        pred.get_ysim()
        pred.get_ysim(as_obs=True)
        pred.get_ysim(as_obs=True, std=True)
        pred.get_yobs()
        pred.get_yobs(as_obs=True)
        pred.get_yobs(as_obs=True, std=True)
    def test_sim_and_obs_noD_x_and_t(self):
        m = 20
        n = 10
        x = np.random.uniform(-1, 3, (m, 3))
        x2 = np.random.uniform(-1, 3, (n, 3))
        t = np.random.uniform(-1, 3, (m, 2))
        y = np.random.normal(size=(m, 50))
        y_ind = np.linspace(0, 1, 50)
        y2 = np.random.normal(size=(n, 20))
        y_ind2 = np.linspace(0, 1, 20)

        data = SepiaData(x_sim=x,
                         t_sim=t,
                         y_sim=y,
                         y_ind_sim=y_ind,
                         x_obs=x2,
                         y_obs=y2,
                         y_ind_obs=y_ind2)
        call_data_methods(data, discrep=False)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()

        pred = SepiaFullPrediction(x_pred=x,
                                   t_pred=t,
                                   samples=samples,
                                   model=model,
                                   addResidVar=True,
                                   storeMuSigma=True)
        pred.get_u_v()
        pred.get_mu_sigma()
        pred.get_ysim()
        pred.get_ysim(as_obs=True)
        pred.get_ysim(as_obs=True, std=True)
        pred.get_yobs()
        pred.get_yobs(as_obs=True)
        pred.get_yobs(as_obs=True, std=True)
Exemplo n.º 8
0
    def setUp(self,
              m=20,
              n=1,
              nt_sim=30,
              nt_obs=20,
              n_theta=3,
              n_basis=5,
              sig_n=0.1,
              seed=42):
        multi_data_dict = generate_data.generate_multi_sim_and_obs(
            m=m,
            n=n,
            nt_sim=nt_sim,
            nt_obs=nt_obs,
            n_theta=n_theta,
            n_basis=n_basis,
            sig_n=sig_n,
            seed=seed)
        univ_data_dict = generate_data.generate_univ_sim_and_obs(m=m,
                                                                 n=n,
                                                                 sig_n=sig_n,
                                                                 seed=seed)

        d = SepiaData(t_sim=univ_data_dict['t_sim'],
                      y_sim=univ_data_dict['y_sim'])
        d.transform_xt()
        d.standardize_y()
        self.univ_sim_only_model = SepiaModel(d)

        d = SepiaData(t_sim=univ_data_dict['t_sim'],
                      y_sim=univ_data_dict['y_sim'],
                      y_obs=univ_data_dict['y_obs'])
        d.transform_xt()
        d.standardize_y()
        self.univ_sim_and_obs_model = SepiaModel(d)

        d = SepiaData(t_sim=multi_data_dict['t_sim'],
                      y_sim=multi_data_dict['y_sim'],
                      y_ind_sim=multi_data_dict['y_ind_sim'])
        d.transform_xt()
        d.standardize_y()
        d.create_K_basis(5)
        self.multi_sim_only_model = SepiaModel(d)

        t = np.concatenate([
            multi_data_dict['t_sim'],
            np.random.choice(range(1, 5), (m, 1), replace=True)
        ],
                           axis=1)
        d = SepiaData(t_sim=t,
                      y_sim=multi_data_dict['y_sim'],
                      y_ind_sim=multi_data_dict['y_ind_sim'],
                      t_cat_ind=[0, 0, 0, 4])
        d.transform_xt()
        d.standardize_y()
        d.create_K_basis(5)
        self.multi_sim_only_catind_model = SepiaModel(d)
    def test_sim_only_x_and_t_cat(self):
        m = 20
        x = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 3)), 1 + np.random.choice(3, size=(m, 1))
        ],
                           axis=1)
        t = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 2)), 1 + np.random.choice(4, size=(m, 1))
        ],
                           axis=1)
        x_cat_ind = [0, 0, 0, 3]
        t_cat_ind = [0, 0, 4]

        y = np.random.normal(size=(m, 50))
        y_ind = np.linspace(0, 1, 50)

        data = SepiaData(x_sim=x,
                         t_sim=t,
                         x_cat_ind=x_cat_ind,
                         t_cat_ind=t_cat_ind,
                         y_sim=y,
                         y_ind_sim=y_ind)
        call_data_methods(data, discrep=False)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()
Exemplo n.º 10
0
def setup_univ_sim_only(m=300,
                        seed=42.,
                        n_lik=0,
                        n_mcmc=0,
                        n_pred=0,
                        n_lev=0,
                        n_burn=0,
                        sens=0):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_univ_sim_only(m,
                                      seed,
                                      n_lik,
                                      n_mcmc,
                                      n_pred,
                                      n_lev,
                                      n_burn,
                                      sens,
                                      nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)
    xt = np.array(res['xt'], dtype=float)
    data = SepiaData(x_sim=xt[:, 0][:, None], t_sim=xt[:, 1][:, None], y_sim=y)
    print(data)
    data.standardize_y()
    data.transform_xt()
    model = SepiaModel(data)
    return model, res
Exemplo n.º 11
0
def setup_multi_sim_and_obs_sharedtheta(m=100,
                                        n=10,
                                        nt_sim=20,
                                        nt_obs=15,
                                        noise_sd=0.1,
                                        nx=5,
                                        n_pc=10,
                                        seed=42.,
                                        n_lik=0,
                                        n_mcmc=0,
                                        n_pred=0,
                                        n_shared=2,
                                        clist=[],
                                        fix_K=False):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_multi_sim_and_obs_sharedtheta(m,
                                                      n,
                                                      nt_sim,
                                                      nt_obs,
                                                      noise_sd,
                                                      nx,
                                                      n_pc,
                                                      seed,
                                                      n_lik,
                                                      n_mcmc,
                                                      n_pred,
                                                      n_shared,
                                                      matlab.double(clist),
                                                      nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)  # (m, nt_sim, n_shared)
    y_ind = np.array(res['y_ind'], dtype=float).squeeze()  # (nt_sim, n_shared)
    xt = np.array(res['xt'], dtype=float)  # (m, nx, n_shared)
    y_obs = np.array(res['y_obs'], dtype=float)  # (n, nt_sim, n_shared)
    y_ind_obs = np.array(res['y_ind_obs'],
                         dtype=float).squeeze()  # (nt_obs, n_shared)
    x_obs = np.array(res['x_obs'], dtype=float)  # (n, 1, n_shared)
    model_list = []
    for i in range(n_shared):
        data = SepiaData(x_sim=xt[:, 0, i][:, None],
                         t_sim=xt[:, 1:, i],
                         y_sim=y[:, :, i],
                         y_ind_sim=y_ind[:, i],
                         x_obs=x_obs[:, :, i],
                         y_obs=y_obs[:, :, i],
                         y_ind_obs=y_ind_obs[:, i])
        data.standardize_y()
        data.transform_xt()
        data.create_K_basis(n_pc)
        model = SepiaModel(data)
        model_list.append(model)
    return model_list, res
Exemplo n.º 12
0
def setup_univ_sim_and_obs(m=100, n=50, seed=42., n_lik=0, n_mcmc=0, n_pred=0):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_univ_sim_and_obs(m,
                                         n,
                                         seed,
                                         n_lik,
                                         n_mcmc,
                                         n_pred,
                                         nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)
    xt = np.array(res['xt'], dtype=float)
    y_obs = np.array(res['y_obs'], dtype=float)
    x_obs = np.array(res['x_obs'], dtype=float).reshape((n, 1))
    data = SepiaData(x_sim=xt[:, 0][:, None],
                     t_sim=xt[:, 1][:, None],
                     y_sim=y,
                     x_obs=x_obs,
                     y_obs=y_obs)
    data.standardize_y()
    data.transform_xt()
    print(data)
    model = SepiaModel(data)
    return model, res
    def test_sim_and_obs_t_only(self):
        m = 20
        n = 10
        t = np.random.uniform(-1, 3, (m, 3))
        y = np.random.normal(size=(m, 1))
        y2 = np.random.normal(size=(n, 1))

        data = SepiaData(t_sim=t, y_sim=y, y_obs=y2)
        call_data_methods(data)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()

        pred = SepiaFullPrediction(t_pred=t,
                                   samples=samples,
                                   model=model,
                                   addResidVar=True,
                                   storeMuSigma=True)
        pred.get_u_v()
        pred.get_mu_sigma()
        pred.get_ysim()
        pred.get_ysim(as_obs=True)
        pred.get_ysim(as_obs=True, std=True)
        pred.get_yobs()
        pred.get_yobs(as_obs=True)
        pred.get_yobs(as_obs=True, std=True)
Exemplo n.º 14
0
def setup_multi_sim_and_obs(m=100,
                            n=10,
                            nt_sim=20,
                            nt_obs=15,
                            noise_sd=0.1,
                            nx=5,
                            n_pc=10,
                            seed=42.,
                            n_lik=0,
                            n_mcmc=0,
                            n_pred=0,
                            fix_K=False):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_multi_sim_and_obs(m,
                                          n,
                                          nt_sim,
                                          nt_obs,
                                          noise_sd,
                                          nx,
                                          n_pc,
                                          seed,
                                          n_lik,
                                          n_mcmc,
                                          n_pred,
                                          nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)
    y_ind = np.array(res['y_ind'], dtype=float).squeeze()
    xt = np.array(res['xt'], dtype=float)
    y_obs = np.array(res['y_obs'], dtype=float)
    y_ind_obs = np.array(res['y_ind_obs'], dtype=float).squeeze()
    x_obs = np.array(res['x_obs'], dtype=float)
    data = SepiaData(x_sim=xt[:, 0][:, None],
                     t_sim=xt[:, 1:],
                     y_sim=y,
                     y_ind_sim=y_ind,
                     x_obs=x_obs,
                     y_obs=y_obs,
                     y_ind_obs=y_ind_obs)
    data.standardize_y()
    data.transform_xt()
    if fix_K:  # means use the K from matlab - avoid issues with positive/negative component ambiguity
        data.create_K_basis(n_pc, K=np.array(res['K']).T)
    else:
        data.create_K_basis(n_pc)
    data.create_D_basis('constant')
    print(data)
    model = SepiaModel(data)
    return model, res
Exemplo n.º 15
0
    def setUp(self, m=100, n=1, nt_sim=50, nt_obs=20, n_theta=3, n_basis=5, sig_n=0.1, seed=42):
        multi_data_dict = generate_data.generate_multi_sim_and_obs(m=m, n=n, nt_sim=nt_sim, nt_obs=nt_obs,
                                                                   n_theta=n_theta, n_basis=n_basis,
                                                                   sig_n=sig_n, seed=seed)
        univ_data_dict = generate_data.generate_univ_sim_and_obs(m=m, n=n, sig_n=sig_n, seed=seed)

        d = SepiaData(x_sim=univ_data_dict['t_sim'], y_sim=univ_data_dict['y_sim'])
        d.transform_xt()
        d.standardize_y()
        self.univ_sim_only_model = SepiaModel(d)

        d = SepiaData(t_sim=univ_data_dict['t_sim'], y_sim=univ_data_dict['y_sim'], y_obs=univ_data_dict['y_obs'])
        d.transform_xt()
        d.standardize_y()
        self.univ_sim_and_obs_model = SepiaModel(d)

        d = SepiaData(x_sim=multi_data_dict['t_sim'], y_sim=multi_data_dict['y_sim'],
                      y_ind_sim=multi_data_dict['y_ind_sim'])
        d.transform_xt()
        d.standardize_y()
        d.create_K_basis(5)
        self.multi_sim_only_model = SepiaModel(d)

        d = SepiaData(t_sim=multi_data_dict['t_sim'], y_sim=multi_data_dict['y_sim'],
                      y_ind_sim=multi_data_dict['y_ind_sim'], y_obs=multi_data_dict['y_obs'],
                      y_ind_obs=multi_data_dict['y_ind_obs'])
        d.transform_xt()
        d.standardize_y()
        d.create_K_basis(5)
        self.multi_sim_and_obs_noD_model = SepiaModel(d)

        d = SepiaData(t_sim=multi_data_dict['t_sim'], y_sim=multi_data_dict['y_sim'],
                      y_ind_sim=multi_data_dict['y_ind_sim'], y_obs=multi_data_dict['y_obs'],
                      y_ind_obs=multi_data_dict['y_ind_obs'])
        d.transform_xt()
        d.standardize_y()
        d.create_K_basis(5)
        d.create_D_basis('linear')
        self.multi_sim_and_obs_model = SepiaModel(d)
    def test_multivariate_sim_and_obs_ragged_setup(self):
        m = 700  # number of simulated observations
        p = 3  # dimension of x (simulation inputs)
        ell_sim = 1000  # dimension of y output sim
        pu = 3  # number of PCs
        q = 2  # dimension of t (extra sim inputs)
        n = 5  # number of observed observations

        ell_obs = np.random.randint(100, 600, n)

        y_ind_sim = np.linspace(0, 100, ell_sim)
        K_true_sim = np.vstack([
            0.5 * (np.sin(y_ind_sim) + 1),
            np.square(-y_ind_sim + 50) / 2500, y_ind_sim / 100
        ])
        y_sim = np.transpose(
            np.log(1 + y_ind_sim)[:, None] + np.dot(
                K_true_sim.T, 2 * np.array([1, 0.5, 0.2])[:, None] *
                np.random.normal(0, 1, (pu, m))))
        x_sim = 0.5 * np.random.uniform(-1, 3, (m, p))
        t = np.random.uniform(-10, 10, (m, q))

        y_ind_obs = [
            np.linspace(0, 100, ell_obs[i]) +
            np.random.uniform(-3, 3, ell_obs[i]) for i in range(len(ell_obs))
        ]
        for yi in y_ind_obs:
            yi[yi < 0] = 0
        K_true_obs = [
            np.vstack(
                [0.5 * (np.sin(yi) + 1),
                 np.square(-yi + 50) / 2500, yi / 100]) for yi in y_ind_obs
        ]
        y_obs = [
            10 + np.squeeze(
                np.log(1 + y_ind_obs[i])[:, None] + np.dot(
                    K_true_obs[i].T, 2 * np.array([1, 0.5, 0.2])[:, None] *
                    np.random.normal(0, 1, (pu, 1))))
            for i in range(len(y_ind_obs))
        ]
        x_obs = 0.5 * np.random.uniform(-1, 3, (n, p))

        d = SepiaData(x_sim=x_sim,
                      y_sim=y_sim,
                      t_sim=t,
                      y_ind_sim=y_ind_sim,
                      x_obs=x_obs,
                      y_obs=y_obs,
                      y_ind_obs=y_ind_obs)

        model = SepiaModel(d)
Exemplo n.º 17
0
def setup_multi_sim_and_obs_noD(m=100,
                                n=10,
                                nt_sim=20,
                                nt_obs=15,
                                noise_sd=0.1,
                                nx=5,
                                n_pc=10,
                                seed=42.,
                                n_lik=0,
                                n_mcmc=0):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_multi_sim_and_obs_noD(m,
                                              n,
                                              nt_sim,
                                              nt_obs,
                                              noise_sd,
                                              nx,
                                              n_pc,
                                              seed,
                                              n_lik,
                                              n_mcmc,
                                              nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)
    y_ind = np.array(res['y_ind'], dtype=float).squeeze()
    xt = np.array(res['xt'], dtype=float)
    y_obs = np.array(res['y_obs'], dtype=float)
    y_ind_obs = np.array(res['y_ind_obs'], dtype=float).squeeze()
    x_obs = np.array(res['x_obs'], dtype=float)
    data = SepiaData(x_sim=xt[:, 0][:, None],
                     t_sim=xt[:, 1:],
                     y_sim=y,
                     y_ind_sim=y_ind,
                     x_obs=x_obs,
                     y_obs=y_obs,
                     y_ind_obs=y_ind_obs)
    data.standardize_y()
    data.transform_xt()
    data.create_K_basis(n_pc)
    print(data)
    model = SepiaModel(data)
    return model, res
    def test_sim_only_x_only_cat(self):
        m = 20
        x = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 3)), 1 + np.random.choice(3, size=(m, 1))
        ],
                           axis=1)
        y = np.random.normal(size=(m, 1))
        cat_inds = [0, 0, 0, 3]

        data = SepiaData(x_sim=x, y_sim=y, x_cat_ind=cat_inds)
        call_data_methods(data)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()
Exemplo n.º 19
0
def setup_multi_sim_only(m=300,
                         nt=20,
                         nx=5,
                         n_pc=10,
                         seed=42.,
                         n_lik=0,
                         n_mcmc=0,
                         n_pred=0,
                         fix_K=False,
                         sens=0):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        res = eng.setup_multi_sim_only(m,
                                       nt,
                                       nx,
                                       n_pc,
                                       seed,
                                       n_lik,
                                       n_mcmc,
                                       n_pred,
                                       sens,
                                       nargout=1)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )
    y = np.array(res['y'], dtype=float)
    y_ind = np.array(res['y_ind'], dtype=float).squeeze()
    xt = np.array(res['xt'], dtype=float)
    data = SepiaData(x_sim=xt[:, 0][:, None],
                     t_sim=xt[:, 1:],
                     y_sim=y,
                     y_ind_sim=y_ind)
    data.standardize_y()
    data.transform_xt()
    data.create_K_basis(n_pc)
    if fix_K:
        data.sim_data.K = np.array(res['K']).T
    print(data)
    model = SepiaModel(data)
    return model, res
Exemplo n.º 20
0
def setup_neddermeyer(seed=42., n_mcmc=100, sens=1, n_burn=0, n_lev=0):
    try:
        eng = matlab.engine.start_matlab()
        eng.cd(root_path)
        eng.addpath('matlab/', nargout=0)
        #dataStruct = eng.neddeg(0, nargout=1)
        res = eng.setup_neddermeyer(seed, n_mcmc, sens, n_burn, n_lev)
        eng.quit()
    except Exception as e:
        print(e)
        print(
            'Matlab error; make sure matlab.engine installed, check Matlab code for errors.'
        )

    # get python model
    import pickle
    data_dict = pickle.load(
        open('../../examples/Neddermeyer/pkls/nedderDataDict.pkl', 'rb'))
    data = SepiaData(x_sim=data_dict['x_sim'],t_sim=data_dict['t_sim'],y_sim=data_dict['y_sim'],\
                 y_ind_sim=data_dict['y_ind_sim'],x_obs=data_dict['x_obs'],y_obs=data_dict['y_obs'],\
                 y_ind_obs=data_dict['y_ind_obs'])
    data.transform_xt()
    # set orig sim vals and Ksim
    data.sim_data.orig_y_mean = data_dict['sim_orig_y_mean']
    data.sim_data.orig_y_sd = data_dict['sim_orig_y_sd']
    data.sim_data.y_std = data_dict['sim_y_std']
    data.sim_data.K = data_dict['Ksim']
    # set orig obs vals and Kobs
    data.obs_data.orig_y_mean = data_dict['obs_orig_y_mean']
    data.obs_data.orig_y_sd = data_dict['obs_orig_y_sd']
    data.obs_data.y_std = data_dict['obs_orig_y_std']
    data.obs_data.K = data_dict['Kobs']
    # call create_D_basis
    data.create_D_basis(D_obs=data_dict['Dobs'], D_sim=data_dict['Dsim'])
    model = SepiaModel(data)

    return model, res
Exemplo n.º 21
0
    def test_multivariate_sim_and_obs_mcmc_thetacon(self):
        """
        Tests mcmc for multivariate sim and obs model with theta constraint function
        """

        print(
            'Testing multivariate sim and obs SepiaMCMC w theta constraint...',
            flush=True)

        data = self.multi_sim_and_obs_data

        def fcon(x):
            return (x[:, 0] + x[:, 1]) < 0.8

        theta_init = np.array([[0.2, 0.3, 0.5]])

        model = SepiaModel(data, theta_init=theta_init, theta_fcon=fcon)

        model.tune_step_sizes(50, 10)
        model.do_mcmc(100)
        samples = model.get_samples()
        self.assertTrue(
            np.all(samples['theta'][:, 0] + samples['theta'][:, 1] < 0.8))
Exemplo n.º 22
0
def setup_model(data, Sigy=None, lamVzGroup=None):
    """
    Sets up SepiaModel object based on SepiaData object.

    :param data: SepiaData object
    :param Sigy: observation covariance matrix (default is identity)
    :param lamVzGroup: groups for lamVz (otherwise single lamVz for all D basis functions)
    :return: instantiated SepiaModel object
    """

    # Check if things transformed, do a default thing, but give warning if not done by user
    if data.sim_data.y_std is None:
        print('Warning: you did not standardize y!')
        print('Continuing with default standardization.')
        print(
            'To customize, call data.standardize_y on your SepiaData object first, or do manual standardization.'
        )
        data.standardize_y(center=True, scale='scalar')

    if data.sim_data.x_trans is None and data.sim_data.t_trans is None:
        print('Warning: you did not rescale x/t to unit cube!')
        print('Continuing with default transformation to unit cube.')
        print(
            'To customize, call data.transform_xt on your SepiaData object first, or do manual transformation.'
        )
        data.transform_xt()

    # If not scalar out, check that K/D are set appropriately
    if not data.scalar_out:
        if data.sim_data.K is None:
            print('Warning: you did not set up the K basis!')
            print('Continuing with default PCA basis.')
            print(
                'To customize, call data.create_K_basis on your SepiaData object.'
            )
            data.create_K_basis()
        else:
            if not data.sim_only:
                if data.ragged_obs:
                    obs_K_shapes = np.array(
                        [k.shape[0] for k in data.obs_data.K])
                    if not np.all(data.sim_data.K.shape[0] == obs_K_shapes):
                        raise ValueError('Sim and obs K shapes not conformal.')
                else:
                    if data.sim_data.K.shape[0] != data.obs_data.K.shape[0]:
                        raise ValueError('Sim and obs K shapes not conformal.')
        if not data.sim_only and data.obs_data.D is None:
            print('Warning: you did not set up a D basis!')
            print(
                'To use one, call data.create_D_basis on your SepiaData object.'
            )

    # Set up model object to modify
    model = SepiaModel()
    model.data = data
    num = model.num
    num.scalar_out = data.scalar_out
    num.sim_only = data.sim_only

    # Local references to data for initialization of model
    sim_data = data.sim_data
    obs_data = data.obs_data

    # Infer p, q, n, m, pu, pv
    m, p = sim_data.x.shape
    if sim_data.t is not None:
        q = sim_data.t.shape[1]
    else:
        q = 0
    ell_sim = sim_data.y.shape[1]
    if data.scalar_out:
        pu = 1
    else:
        pu = sim_data.K.shape[0]
    num.m, num.p, num.q, num.pu = m, p, q, pu
    if not data.sim_only:
        if data.ragged_obs:
            ell_obs = [obs_data.y[i].shape for i in range(len(obs_data.y))]
        else:
            ell_obs = obs_data.y.shape[1]
        n = obs_data.x.shape[0]
        if data.scalar_out or obs_data.D is None:
            pv = 0
        else:
            if data.ragged_obs:
                pv = obs_data.D[0].shape[0]
            else:
                pv = obs_data.D.shape[0]
        num.n, num.pv = n, pv
    else:
        num.n = 0
        num.pv = 0

    # Set up Sigy/Lamy
    if not data.sim_only:
        if Sigy is None:
            if data.ragged_obs:
                Sigy = [
                    np.atleast_2d(np.diag(np.ones(ell_obs[i])))
                    for i in range(len(ell_obs))
                ]
            else:
                Sigy = np.diag(np.ones(ell_obs))
        if data.scalar_out:
            Lamy = 1 / Sigy
        else:
            if data.ragged_obs:
                Lamy = [np.linalg.inv(Sigy[i]) for i in range(len(Sigy))]
            else:
                Lamy = np.linalg.inv(Sigy)

    # Set up GP inputs/DistCov objects
    if not data.sim_only:
        data.x = obs_data.x_trans
    else:
        data.x = np.array([], dtype=np.float).reshape((0, 1))
    num.x0Dist = SepiaDistCov(data.x)
    if sim_data.t_trans is not None:
        data.zt = np.concatenate([sim_data.x_trans, sim_data.t_trans], axis=1)
    else:
        data.zt = sim_data.x_trans
    num.ztDist = SepiaDistCov(data.zt)

    if not data.sim_only:
        # Check for lamVzGroups, validate TODO validate
        if lamVzGroup is not None:
            lamVzGnum = np.unique(lamVzGroup).shape[0]
        else:
            lamVzGroup = [0] * pv
            lamVzGnum = 1
        num.lamVzGroup = lamVzGroup
        num.lamVzGnum = lamVzGnum
        #assert (lamVzGnum == np.unique(lamVzGroup).shape[0])

    # Transform obs data using D, Kobs -> v, u
    if not data.sim_only:
        if data.scalar_out:
            u = obs_data.y_std
            v = np.array([], dtype=float)
        else:
            DKridge = 1e-6 * np.diag(np.ones(pu + pv))  # (pu+pv, pu+pv)
            if data.ragged_obs:
                v = []
                u = []
                for i in range(len(data.obs_data.y)):
                    if obs_data.D is None:
                        DK = obs_data.K[i]
                    else:
                        DK = np.concatenate([obs_data.D[i], obs_data.K[i]
                                             ])  # (pu+pv, ell_obs)
                    DKprod = np.linalg.multi_dot([DK, Lamy[i],
                                                  DK.T])  # (pu+pv, pu+pv)
                    y_tmp = obs_data.y_std[i][:, None]
                    vu = np.dot(np.linalg.inv(DKprod + DKridge),
                                np.linalg.multi_dot([DK, Lamy[i], y_tmp]))
                    v.append(vu[:pv, :].T)
                    u.append(vu[pv:, :].T)
                v = np.concatenate(v)
                u = np.concatenate(u)
            else:
                if obs_data.D is None:
                    DK = obs_data.K
                else:
                    DK = np.concatenate([obs_data.D,
                                         obs_data.K])  # (pu+pv, ell_obs)
                DKprod = np.linalg.multi_dot([DK, Lamy,
                                              DK.T])  # (pu+pv, pu+pv)
                vu = np.dot(np.linalg.inv(DKprod + DKridge),
                            np.linalg.multi_dot([DK, Lamy, obs_data.y_std.T]))
                v = vu[:pv, :].T
                u = vu[pv:, :].T
        num.u = u.reshape((n * pu, 1), order='F').copy()
        num.v = v.reshape((n * pv, 1), order='F').copy()
    else:
        num.u = np.array([], dtype=np.float).reshape((0, 1))
        num.v = np.array([], dtype=np.float).reshape((0, 1))

    # Transform sim data using Ksim -> w
    if data.scalar_out:
        w = sim_data.y_std
    else:
        w = np.dot(np.linalg.pinv(sim_data.K).T, sim_data.y_std.T).T
    num.w = w.reshape((m * pu, 1), order='F').copy()

    if num.scalar_out:
        num.uw = np.concatenate((num.u, num.w), axis=0)
    else:
        num.vuw = np.concatenate((num.v, num.u, num.w), axis=0)
        num.vu = np.concatenate((num.v, num.u), axis=0)

    # Compute LamSim
    if data.scalar_out:
        LamSim = np.ones(1)
    else:
        LamSim = np.diag(np.dot(sim_data.K, sim_data.K.T))
    num.LamSim = LamSim

    # Compute LamObs
    if not data.sim_only:
        if data.scalar_out:
            LamObs = Lamy * np.diag(np.ones(n))
            rankLO = np.linalg.matrix_rank(LamObs)
        else:
            if obs_data.D is None:
                if data.ragged_obs:
                    DK = [obs_data.K[i] for i in range(n)]
                else:
                    DK = obs_data.K
            else:
                if data.ragged_obs:
                    DK = [
                        np.concatenate([obs_data.D[i], obs_data.K[i]])
                        for i in range(n)
                    ]
                else:
                    DK = np.concatenate([obs_data.D, obs_data.K
                                         ])  # Note: our DK = DK' in matlab
            DKridge = 1e-6 * np.diag(np.ones(pu + pv))
            if data.ragged_obs:
                DKprod = [
                    np.linalg.multi_dot([DK[i], Lamy[i], DK[i].T])
                    for i in range(n)
                ]
            else:
                DKprod = [
                    np.linalg.multi_dot([DK, Lamy, DK.T]) for i in range(n)
                ]
            LamObs = scipy.linalg.block_diag(*DKprod)
            rankLO = np.linalg.matrix_rank(
                LamObs, hermitian=True)  # Same as value in matlab
            LamObs = LamObs + scipy.linalg.block_diag(
                *[DKridge for i in range(n)])
            # Reorder indices: is currently v1 u1 v2 u2 ... want v1 v2 v3 ... u1 u2 ...
            inew = []
            for kk in range(pv):
                inew += list(range(kk, n * (pu + pv), pu + pv))
            for kk in range(pu):
                inew += list(range(pv + kk, n * (pu + pv), pu + pv))
            inew = np.array(inew)
            LamObs = LamObs[inew[:, None], inew[None, :]]
        SigObs = np.linalg.inv(LamObs +
                               1e-8 * np.diag(np.ones(LamObs.shape[0])))
        num.SigObs = SigObs
    else:
        rankLO = 0

    # Compute prior correction for lamOs, lamWOs
    if not data.sim_only:
        if data.ragged_obs:
            tot_elements = np.sum(ell_obs)
        else:
            tot_elements = ell_obs * n
        lamOs_a_corr = 0.5 * (tot_elements - rankLO)
        lamOs_b_corr = 0
        if not data.scalar_out:
            if obs_data.D is None:
                if data.ragged_obs:
                    DK = [obs_data.K[i] for i in range(n)]
                else:
                    DK = obs_data.K
            else:
                if data.ragged_obs:
                    DK = [
                        np.concatenate([obs_data.D[i], obs_data.K[i]])
                        for i in range(n)
                    ]
                else:
                    DK = np.concatenate([obs_data.D, obs_data.K
                                         ])  # Note: our DK = DK' in matlab
            if data.ragged_obs:
                DKvu = [
                    np.dot(
                        DK[i].T,
                        np.concatenate([v[None, i, :], u[None, i, :]],
                                       axis=1).T) for i in range(n)
                ]
                for i in range(n):
                    resid = obs_data.y_std[i] - DKvu[i].squeeze()
                    lamOs_b_corr += 0.5 * np.sum(
                        np.linalg.multi_dot([resid, Lamy[i], resid]))
            else:
                DKvu = np.dot(DK.T, np.concatenate([v, u], axis=1).T)
                for i in range(n):
                    resid = obs_data.y_std[i, :] - DKvu[:, i]
                    lamOs_b_corr += 0.5 * np.sum(
                        np.linalg.multi_dot([resid, Lamy, resid]))

    lamWOs_a_corr = 0.5 * (ell_sim - pu) * m
    if data.scalar_out:
        lamWOs_b_corr = 0
    else:
        y_sim_std_hat = np.dot(w, sim_data.K)
        lamWOs_b_corr = 0.5 * np.sum(
            np.square(sim_data.y_std - y_sim_std_hat))  # same as matlab

    # Set up params/priors
    if model.num.sim_only:
        model.set_params_sim_only(lamWOs_a_corr, lamWOs_b_corr)
    elif pv == 0:
        model.set_params_noD(lamOs_a_corr, lamOs_b_corr, lamWOs_a_corr,
                             lamWOs_b_corr)
    else:
        model.set_params_full(lamOs_a_corr, lamOs_b_corr, lamWOs_a_corr,
                              lamWOs_b_corr)

    return model
Exemplo n.º 23
0
plt.xlabel('y index')
plt.ylabel('y')
plt.show()

#%%

data.transform_xt()
data.standardize_y(scale='columnwise')
data.create_K_basis(5)
data.create_D_basis(type='linear')

print(data)

#%%

model = SepiaModel(data)

#%%

cachefile_name='multivariate_example_with_prediction.pkl'
import os.path
import pickle

use_save_file=False

if use_save_file and os.path.isfile(cachefile_name):
   model=pickle.load(open(cachefile_name, "rb" ))
else:
    model.tune_step_sizes(50, 20)
    model.do_mcmc(1000)
    if use_save_file:
Exemplo n.º 24
0
    def test_univariate_sim_and_obs_saveload(self):
        """
        Tests save/load for univariate sim and obs model
        """

        print('Testing univariate sim and obs save/load...', flush=True)

        data = self.univ_sim_and_obs_data

        model = SepiaModel(data)
        model.tune_step_sizes(50, 10)
        model.do_mcmc(100)
        model.save_model_info(overwrite=True)

        new_model = SepiaModel(data)
        new_model.restore_model_info()

        # check num stuff
        self.assertEqual(model.num.logLik, new_model.num.logLik)
        self.assertTrue(np.allclose(model.num.uw, new_model.num.uw))
        self.assertTrue(np.allclose(model.num.SigWl, new_model.num.SigWl))

        # check param stuff
        for p1, p2 in zip(model.params, new_model.params):
            self.assertTrue(p1.name == p2.name)
            self.assertTrue(np.allclose(p1.fixed, p2.fixed))
            self.assertTrue(np.allclose(p1.val, p2.val))
            self.assertTrue(np.allclose(np.array(p1.mcmc.draws), np.array(p2.mcmc.draws)))
            if p1.name != 'logPost':
                self.assertTrue(np.allclose(p1.mcmc.stepParam, p2.mcmc.stepParam))
                self.assertTrue(p1.mcmc.stepType == p2.mcmc.stepType)
                self.assertTrue(np.allclose(np.array(p1.prior.bounds), np.array(p2.prior.bounds)))
                self.assertTrue(np.allclose(np.array(p1.prior.params), np.array(p2.prior.params)))
                self.assertTrue(p1.prior.dist == p2.prior.dist)

        new_model.do_mcmc(10)
Exemplo n.º 25
0
y_sim = matfile['y'].T
y_ind_sim = matfile['y_ind'].squeeze()
xt_sim = matfile['x']
y_obs = matfile['y_obs']
y_ind_obs = matfile['y_ind_obs'].squeeze()
x_obs = matfile['x_obs']
data = SepiaData(x_sim=xt_sim[:, 0][:, None], t_sim=xt_sim[:, 1][:, None], y_sim=y_sim, y_ind_sim=y_ind_sim,
                 x_obs=x_obs, y_obs=y_obs, y_ind_obs=y_ind_obs)
data.standardize_y()
data.transform_xt()
data.create_K_basis(n_pc=n_pc)
data.create_D_basis(D_obs=matfile['Dobs'].T)
print(data)

np.random.seed(int(seed))
model = SepiaModel(data)
if lamWOs_init > 0:
    model.params.lamWOs.val = np.array([[lamWOs_init]])

model.do_mcmc(nburn + nsamp)
np.random.seed(seed)
psamps = model.get_samples(sampleset=range(50), flat=True)

@timeit
def do_wPred():
    for _ in range(10):
        pred = wPred([0.5], psamps, model.num, model.data, returnMuSigma=True, addResidVar=True, returnRlz=True)

@timeit
def do_uvPred():
    for _ in range(50):
Exemplo n.º 26
0
    def test_full_setup_LL_pred(self):
        # Set up and check calibration model
        x_obs = np.ones((3, 2)) * np.array([0.5, 0.75, 0.25]).reshape((-1, 1))
        y_obs = np.block([[-0.1, 0.1], [-0.2, 0.3], [0.1, 0]])

        # augment to also test more than scalar dimensions in x and t
        x_sim_cal = np.hstack((0.5 * np.ones(
            (self.x_sim.shape[0], 1)), self.x_sim[:, :1]))
        t_sim_cal = self.x_sim[:, 1:]
        xt_sim_sep = [np.array(0.5).reshape(1, 1)] + self.x_sim_kron

        y_sim_std = (self.y_sim - np.mean(self.y_sim, axis=0).reshape(
            1, -1)) / np.std(self.y_sim, axis=0, ddof=1).reshape(1, -1)

        dc = SepiaData(x_sim=x_sim_cal,
                       t_sim=t_sim_cal,
                       y_sim=y_sim_std,
                       x_obs=x_obs,
                       y_obs=y_obs,
                       y_ind_sim=self.y_ind_sim,
                       y_ind_obs=self.y_ind_sim)
        dc.create_K_basis(K=np.eye(2))
        dc.create_D_basis(D_sim=np.eye(2), D_obs=np.eye(2))
        dc.transform_xt(x_notrans=True, t_notrans=True)
        dc.standardize_y(y_mean=0, y_sd=1)
        print(dc)
        cmod = SepiaModel(dc)

        print('Calibration model LL=%f' % compute_log_lik(cmod))

        kdc = SepiaData(xt_sim_sep=xt_sim_sep,
                        y_sim=y_sim_std,
                        x_obs=x_obs,
                        y_obs=y_obs,
                        y_ind_sim=self.y_ind_sim,
                        y_ind_obs=self.y_ind_sim)
        kdc.create_K_basis(K=np.eye(2))
        kdc.create_D_basis(D_sim=np.eye(2), D_obs=np.eye(2))
        kdc.transform_xt(x_notrans=True, t_notrans=True)
        kdc.standardize_y(y_mean=0, y_sd=1)
        print(kdc)
        kcmod = SepiaModel(kdc)

        print('Calibration Sep model LL=%f' % compute_log_lik(kcmod))

        self.assertAlmostEqual(compute_log_lik(cmod),
                               compute_log_lik(kcmod),
                               places=5)

        print(
            'Running MCMC on Calibration model in Sep pred mode, regular design'
        )
        np.random.seed(42)
        t1 = time()
        cmod.do_mcmc(10)
        print('sampling time %f' % (time() - t1))
        csamp = cmod.get_samples(sampleset=[cmod.get_last_sample_ind()])
        cpred = SepiaFullPrediction(mode='Sep',
                                    model=cmod,
                                    samples=csamp,
                                    storeMuSigma=True,
                                    x_pred=np.array([0.5, 0.5]).reshape(
                                        (1, -1)))
        print(cpred.get_ysim())
        csm, css = cpred.get_mu_sigma()
        print(csm)
        print(css)

        print(
            'Running MCMC on Calibration model in Sep pred mode, separable design'
        )
        np.random.seed(42)
        t1 = time()
        kcmod.do_mcmc(10)
        print('sampling time %f' % (time() - t1))
        kcsamp = kcmod.get_samples(sampleset=[kcmod.get_last_sample_ind()])
        kcpred = SepiaFullPrediction(mode='Sep',
                                     model=kcmod,
                                     samples=kcsamp,
                                     storeMuSigma=True,
                                     x_pred=np.array([0.5, 0.5]).reshape(
                                         (1, -1)))
        print(kcpred.get_ysim())
        kcsm, kcss = kcpred.get_mu_sigma()
        print(kcsm)
        print(kcss)

        print('testing max difference which is %g' % np.max(abs(csm - kcsm)))
        self.assertAlmostEqual(0, np.max(abs(csm - kcsm)))

        print('testing max difference which is %g' % np.max(abs(css - kcss)))
        self.assertAlmostEqual(0, np.max(abs(css - kcss)))

        ###### Timing for predictions

        test_x_pred = np.random.rand(10, 2)

        csamp = cmod.get_samples()
        t1 = time()
        cpred0 = SepiaFullPrediction(mode='notSep',
                                     model=cmod,
                                     samples=csamp,
                                     storeMuSigma=True,
                                     x_pred=test_x_pred)
        print('predict time non-Sep in non-Sep mode %f' % (time() - t1))
        t1 = time()
        cpred = SepiaFullPrediction(mode='Sep',
                                    model=cmod,
                                    samples=csamp,
                                    storeMuSigma=True,
                                    x_pred=test_x_pred)
        print('predict time non-sep in Sep mode %f' % (time() - t1))

        kcsamp = kcmod.get_samples()
        t1 = time()
        kcpred = SepiaFullPrediction(mode='Sep',
                                     model=kcmod,
                                     samples=kcsamp,
                                     storeMuSigma=True,
                                     x_pred=test_x_pred)
        print('predict time Sep %f' % (time() - t1))

        pass
h_dense = data_dict['h_dense']
D_dense = np.zeros(shape=(h_dense.shape[0], pv))
for j in range(pv):
    D_obs[:, j] = norm.pdf(h_field, D_grid[j], D_width)
    D_sim[:, j] = norm.pdf(h_sim, D_grid[j], D_width)
    D_dense[:, j] = norm.pdf(h_dense, D_grid[j], D_width)
data.create_D_basis(D_obs=D_obs.T, D_sim=D_sim)
#
# Data setup completed
#

nmcmc = 5000
#
# Standard mcmc reference model setup and sampling
#
model_ref = SepiaModel(data)
model_ref.tune_step_sizes(50, 20, verbose=False)
# burn in the model. This is qualitative, and needs to be assessed on trace plots
# This model is actually OK, but do 10 samples for 'burn-in'
model_ref.do_mcmc(10, prog=False)
# and discard those samples
model_ref.clear_samples()
tref = time()  # timing start
model_ref.do_mcmc(nmcmc)
print('Single-process mcmc took %f s' % (time() - tref), flush=True)

#
# Perform the same operation with parallel mcmc chains
#
model = SepiaModel(data)  # new model instance
model.tune_step_sizes(50, 20, verbose=False)  # optimize step sizes
    def test_sim_and_obs_x_and_t_cat(self):
        m = 20
        n = 10
        x = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 3)), 1 + np.random.choice(3, size=(m, 1))
        ],
                           axis=1)
        x2 = np.concatenate([
            np.random.uniform(-1, 3,
                              (n, 3)), 1 + np.random.choice(3, size=(n, 1))
        ],
                            axis=1)
        t = np.concatenate([
            np.random.uniform(-1, 3,
                              (m, 2)), 1 + np.random.choice(4, size=(m, 1))
        ],
                           axis=1)
        y = np.random.normal(size=(m, 50))
        y_ind = np.linspace(0, 1, 50)
        y2 = np.random.normal(size=(n, 20))
        y_ind2 = np.linspace(0, 1, 20)
        x_cat_ind = [0, 0, 0, 3]
        t_cat_ind = [0, 0, 4]

        data = SepiaData(x_sim=x,
                         t_sim=t,
                         x_cat_ind=x_cat_ind,
                         t_cat_ind=t_cat_ind,
                         y_sim=y,
                         y_ind_sim=y_ind,
                         x_obs=x2,
                         y_obs=y2,
                         y_ind_obs=y_ind2)
        call_data_methods(data)

        model = SepiaModel(data)
        call_model_methods(model)
        call_plot_functions(model)

        samples = model.get_samples()
        pred = SepiaEmulatorPrediction(x_pred=x,
                                       t_pred=t,
                                       samples=samples,
                                       model=model,
                                       addResidVar=True,
                                       storeMuSigma=True)
        pred.get_w()
        pred.get_y()
        pred.get_y(std=True)
        pred.get_mu_sigma()

        xpred = SepiaXvalEmulatorPrediction(samples=samples,
                                            model=model,
                                            addResidVar=True,
                                            storeMuSigma=True)
        xpred.get_w()
        xpred.get_y()
        xpred.get_y(std=True)
        xpred.get_mu_sigma()

        pred = SepiaFullPrediction(x_pred=x,
                                   t_pred=t,
                                   samples=samples,
                                   model=model,
                                   addResidVar=True,
                                   storeMuSigma=True)
        pred.get_u_v()
        pred.get_mu_sigma()
        pred.get_ysim()
        pred.get_ysim(as_obs=True)
        pred.get_ysim(as_obs=True, std=True)
        pred.get_yobs()
        pred.get_yobs(as_obs=True)
        pred.get_yobs(as_obs=True, std=True)
        pred.get_discrepancy()
        pred.get_discrepancy(as_obs=True)
        pred.get_discrepancy(as_obs=True, std=True)
Exemplo n.º 29
0
data = SepiaData(t_sim=design,
                 y_sim=y_sim,
                 y_ind_sim=y_ind,
                 y_obs=y_obs,
                 y_ind_obs=y_ind)
data.standardize_y()
data.transform_xt()
data.create_K_basis(n_features - 1)
print(data)

# Setup model
# We have a known observation error
Sigy = np.diag(
    np.squeeze(
        (0.01 * np.ones(n_features) * y_obs) / data.sim_data.orig_y_sd**2))
model = SepiaModel(data, Sigy)

# Modify priors to match Matlab
model.params.lamWs.prior.bounds[1] = np.inf
model.params.lamWs.prior.params = [np.ones((1, 11)), np.zeros((1, 11))]

# Do mcmc
model.tune_step_sizes(100, 25)
model.do_mcmc(10000)
samples_dict = model.get_samples()

with open('data/sepia_mcmc_samples1-5000.pkl', 'wb') as f:
    pickle.dump(samples_dict, f)

with open('data/sepia_model.pkl', 'wb') as f:
    pickle.dump(model, f)
Exemplo n.º 30
0
y_sim = matfile['y'].T
y_ind_sim = matfile['y_ind'].squeeze()
xt_sim = matfile['x']
y_obs = matfile['y_obs']
y_ind_obs = matfile['y_ind_obs'].squeeze()
x_obs = matfile['x_obs']
data = SepiaData(x_sim=xt_sim[:, 0][:, None], t_sim=xt_sim[:, 1][:, None], y_sim=y_sim, y_ind_sim=y_ind_sim,
                 x_obs=x_obs, y_obs=y_obs, y_ind_obs=y_ind_obs)
data.standardize_y()
data.transform_xt()
data.create_K_basis(n_pc=2)
data.create_D_basis(D_obs=matfile['Dobs'].T)
print(data)

model = SepiaModel(data)

nsamp = int(matfile['nsamp'])
nburn = int(matfile['nburn'])

@timeit
def run_mcmc():
    model.do_mcmc(nburn + nsamp)

print('Python mcmc time:')
run_mcmc()

# import cProfile
# cProfile.run('run_mcmc()', 'mcmc.profile')
#
# import os