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_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()
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)
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_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()
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)
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))
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()
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)
print('Multi-process worker mcmc and samples return took %f s' % (tref2 - tref1)) print(' with overhead of %f s' % ((tref1 - tref0) + (tref3 - tref2))) print(' total = %f s' % (tref3 - tref0)) # # The samples from the parallel chains are in the Sepia model object now # Can proceed with the Sepia model object as normal # # Compare the trace plots for qualitative equivalence of samples # between the "regular" model object and the model object constituted with samples samples_dict_ref = model_ref.get_samples() samples_dict = model.get_samples() theta_names = ['C'] mcmc_trace_ref = SepiaPlot.mcmc_trace(samples_dict_ref, theta_names) mcmc_trace = SepiaPlot.mcmc_trace(samples_dict, theta_names) mcmc_trace_ref.show() mcmc_trace.show() p_stats_ref = SepiaPlot.param_stats(samples_dict_ref, theta_names=theta_names, q1=.05, q2=.95, digits=4)
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)
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
for j in range(param_shape): plt.subplot(nrow, ncol, j + 1) plt.hist(samples_dict[k][:, j]) plt.xlabel(k) plt.show() #%% Emulator-only predictions model.verbose=True from sepia.SepiaPredict import SepiaEmulatorPrediction x_pred=np.linspace(0,1,9).reshape((9,1)) # make t_pred most like the calibrated thetas for comparison to below t_pred=np.tile(np.array([1,0,1]).reshape(1,3),(9,1)) pred_samples=model.get_samples(numsamples=7) pred=SepiaEmulatorPrediction(x_pred=x_pred, samples=pred_samples, model=model, t_pred=t_pred) predw=pred.get_w() plt.figure() plt.plot(np.mean(predw,0).T) plt.xlabel('PCA weights w') plt.ylabel('w value for each predicted x \n mean over samples') plt.show() predystd=pred.get_y(std=True) plt.figure() plt.plot(model.data.sim_data.y_ind,np.mean(predystd,0).T) plt.xlabel('native data space y') plt.ylabel('standardized predicted y for each predicted x \n mean over samples') plt.show()
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): pred = uvPred([0.5], psamps, model.num, model.data, returnMuSigma=True, useAltW=False) print('\nuvPred x10') do_uvPred() print('wPred x10')