def test_progress_bar(ma2): thresholds = [.5, .2] N = 1000 rej = elfi.Rejection(ma2['d'], batch_size=20000) assert not rej.progress_bar.finished rej.sample(N) assert rej.progress_bar.finished smc = elfi.SMC(ma2['d'], batch_size=20000) assert not smc.progress_bar.finished smc.sample(N, thresholds=thresholds) assert smc.progress_bar.finished bolfi = elfi.BOLFI(ma2['d'], initial_evidence=10, update_interval=10, batch_size=5, bounds={ 't1': (-2, 2), 't2': (-1, 1) }) assert not bolfi.progress_bar.finished n = 20 bolfi.infer(n) assert bolfi.progress_bar.finished
def build(self, model, pattern, prior_pos, prior_cov=64, r_bound=47.9, pmt_mask=np.ones(127)): ### Build Priors px = elfi.Prior(BoundedNormal_x, r_bound, prior_pos, prior_cov) py = elfi.Prior(BoundedNormal_y, px, r_bound, prior_pos, prior_cov) ### Build Model model = elfi.tools.vectorize(model) Y = elfi.Simulator(model, px, py, observed=np.array([pattern])) # TODO implement PMT mask here #def summarize(data, key): # # Select either energy or time for model output. # return np.array([v[key] for v in data]) def summarize(data): return np.array( [list(v['energy']) + list(v['time']) for v in data]) # Build summary stat for energy and time #S1 = elfi.Summary(summarize, Y, 'energy') #S2 = elfi.Summary(summarize, Y, 'time') S1 = elfi.Summary(summarize, Y) d = elfi.Distance('braycurtis', S1) log_d = elfi.Operation(np.log, d) # set the ELFI model so we can remove it later self.model = px.model ### Setup BOLFI bounds = {'px': (-r_bound, r_bound), 'py': (-r_bound, r_bound)} target_model = GPyRegression(log_d.model.parameter_names, bounds=bounds) acquisition_method = ConstraintLCBSC(target_model, prior=ModelPrior(log_d.model), noise_var=[1, 1], exploration_rate=10) bolfi = elfi.BOLFI( log_d, batch_size=1, initial_evidence=50, update_interval=1, # bounds=bounds, # Not used when using target_model target_model=target_model, # acq_noise_var=[0.1, 0.1], # Not used when using acq method acquisition_method=acquisition_method, ) return bolfi
def test_optimization(self): self.set_simple_model(vectorized=False) self.set_basic_bolfi() bolfi = elfi.BOLFI(self.d, [self.p], self.n_batch, n_surrogate_samples=self.n_sim, n_opt_iters=10) post = bolfi.infer() assert bolfi.acquisition.finished is True assert bolfi.model.n_observations == self.n_sim
def test_bolfi(ma2): bs = 2 n_samples = 4 upd_int = 1 n_evi = 16 init_evi = 10 bounds = {'t1': (-2, 2), 't2': (-1, 1)} anv = .1 nchains = 2 bolfi = elfi.BOLFI( ma2, 'd', initial_evidence=init_evi, update_interval=upd_int, batch_size=bs, bounds=bounds, acq_noise_var=anv) sample = bolfi.sample(n_samples, n_evidence=n_evi, n_chains=nchains) seed = bolfi.seed bolfi = elfi.BOLFI( ma2, 'd', initial_evidence=init_evi, update_interval=upd_int, batch_size=bs, bounds=bounds, acq_noise_var=anv) sample_diff = bolfi.sample(n_samples, n_evidence=n_evi, n_chains=nchains) bolfi = elfi.BOLFI( ma2, 'd', seed=seed, initial_evidence=init_evi, update_interval=upd_int, batch_size=bs, bounds=bounds, acq_noise_var=anv) sample_same = bolfi.sample(n_samples, n_evidence=n_evi, n_chains=nchains) check_consistent_sample(sample, sample_diff, sample_same)
def test_BOLFI_short(ma2, distribution_test): # Log discrepancy tends to work better log_d = elfi.Operation(np.log, ma2['d']) bolfi = elfi.BOLFI(log_d, initial_evidence=10, update_interval=10, batch_size=5, bounds={ 't1': (-2, 2), 't2': (-1, 1) }) n = 20 res = bolfi.infer(n) assert bolfi.target_model.n_evidence == n acq_x = bolfi.target_model._gp.X # Test that you can continue the inference where we left off res = bolfi.infer(n + 5) assert bolfi.target_model.n_evidence == n + 5 assert np.array_equal(bolfi.target_model._gp.X[:n, :], acq_x) post = bolfi.extract_posterior() distribution_test(post, rvs=(acq_x[0, :], acq_x[1:2, :], acq_x[2:4, :])) n_samples = 10 n_chains = 2 res_sampling_nuts = bolfi.sample(n_samples, n_chains=n_chains) assert res_sampling_nuts.samples_array.shape[1] == 2 assert len(res_sampling_nuts.samples_array) == n_samples // 2 * n_chains res_sampling_metropolis = bolfi.sample(n_samples, n_chains=n_chains, algorithm='metropolis', sigma_proposals=np.ones(2)) assert res_sampling_metropolis.samples_array.shape[1] == 2 assert len( res_sampling_metropolis.samples_array) == n_samples // 2 * n_chains # check the cached predictions for RBF x = np.random.random((1, 2)) bolfi.target_model.is_sampling = True pred_mu, pred_var = bolfi.target_model._gp.predict(x) pred_cached_mu, pred_cached_var = bolfi.target_model.predict(x) assert (np.allclose(pred_mu, pred_cached_mu)) assert (np.allclose(pred_var, pred_cached_var)) grad_mu, grad_var = bolfi.target_model._gp.predictive_gradients(x) grad_cached_mu, grad_cached_var = bolfi.target_model.predictive_gradients( x) assert (np.allclose(grad_mu[:, :, 0], grad_cached_mu)) assert (np.allclose(grad_var, grad_cached_var))
def test_model_logging(self): self.set_simple_model(vectorized=False) self.set_basic_bolfi() db = DictListStore() bolfi = elfi.BOLFI(self.d, [self.p], self.n_batch, store=db, n_surrogate_samples=self.n_sim, n_opt_iters=10) post = bolfi.infer() assert bolfi.acquisition.finished is True assert bolfi.model.n_observations == self.n_sim # get initial model plus resulting model after each sample models = db.get("BOLFI-model", slice(0, self.n_sim + 1)) assert len(models) == self.n_sim + 1 for i in range(self.n_sim + 1): assert type(models[i]) == type(bolfi.model), i
def build(self, model, pattern, prior_pos, prior_cov=25, r_bound=47.9, pmt_mask=np.ones(127)): ### Build Priors px = elfi.Prior(BoundedNormal_x, r_bound, prior_pos, prior_cov) py = elfi.Prior(BoundedNormal_y, px, r_bound, prior_pos, prior_cov) ### Build Model model = elfi.tools.vectorize(model) Y = elfi.Simulator(model, px, py, observed=np.array([pattern])) # TODO implement PMT mask here d = elfi.Distance('braycurtis', Y) log_d = elfi.Operation(np.log, d) # set the ELFI model so we can remove it later self.model = px.model ### Setup BOLFI bounds = {'px': (-r_bound, r_bound), 'py': (-r_bound, r_bound)} target_model = GPyRegression(log_d.model.parameter_names, bounds=bounds) acquisition_method = ConstraintLCBSC(target_model, prior=ModelPrior(log_d.model), noise_var=[5, 5], exploration_rate=10) bolfi = elfi.BOLFI( log_d, batch_size=1, initial_evidence=50, update_interval=1, # bounds=bounds, # Not used when using target_model target_model=target_model, # acq_noise_var=[0.1, 0.1], # Not used when using acq method acquisition_method=acquisition_method, ) return bolfi
def predict(self, data_test): elfi.new_model("BOLFI") prior = elfi.Prior(MVUniform, self.p_lower, self.p_upper) sim = elfi.Simulator(self.simulator, prior, observed=data_test, name='sim') SS = elfi.Summary(self.identity, sim, name='identity') d = elfi.Distance('euclidean', SS, name='d') log_d = elfi.Operation(np.log, d) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=10, acq_noise_var=self.p_lower.size * [0.1], bounds=None, seed=42) bolfi.fit(n_evidence=self.n_particles) post = bolfi.extract_posterior(-1.) samples = post.model.X return samples
alphaprior6, tau, measurement_idx, observed=observeddata) summary = elfi.Summary(logdestack, simulator_results) d = elfi.Distance('euclidean', summary) #log_d = elfi.Operation(np.log, d) bolfi = elfi.BOLFI(d, batch_size=1, initial_evidence=100, update_interval=10, bounds={ 'alphaprior1': (0, 5), 'alphaprior2': (0, 5), 'alphaprior3': (0, 5), 'alphaprior4': (0, 5), 'alphaprior5': (0, 5), 'alphaprior6': (0, 5) }, acq_noise_var=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], seed=1) post = bolfi.fit(n_evidence=500) #bolfi.plot_state() #plt.savefig("bolfi_state.pdf") #plt.close() bolfi.plot_discrepancy() plt.savefig("bolfi_discrepancy.pdf")
a.write('parameter_bounds: ' + str(parameter_bounds) + '\n') a.write('fitting_steps: ' + str(fitting_steps) + '\n') a.write('samples: ' + str(samples) + '\n') a.close() except: pass # gp = elfi.GPyRegression(m.parameter_names, parameter_bounds) # prior = elfi.methods.utils.ModelPrior(m) # acq = elfi.methods.bo.acquisition.RandMaxVar(model=gp, prior=prior) # bolfi = elfi.BOLFI(nfds_simulator, batch_size=1, initial_evidence=rej_result.outputs, update_interval=update_interval, # bounds=parameter_bounds, seed=scipy.random.seed(), async = True, target_model=gp, acquisition_method=acq, # acq_noise_var=[0.1, 0.01, 0.1], batches_per_acquisition=1) bolfi = elfi.BOLFI(nfds_simulator, batch_size=1, initial_evidence=rej_result.outputs, update_interval=update_interval, bounds=parameter_bounds, seed=scipy.random.seed(), async=True, batches_per_acquisition=1) post = bolfi.fit( n_evidence=fitting_steps ) # fits hypermodel to data by minimizing the strain divergence metric - generates very wide probabiolity distributions try: with open(prefix + '_bolfi_with_posterior.pkl', 'wb') as a: pickle.dump(bolfi, a, pickle.HIGHEST_PROTOCOL) except: pass
def test_BOLFI(): m, true_params = setup_ma2_with_informative_data() # Log discrepancy tends to work better log_d = NodeReference(m['d'], state=dict(_operation=np.log), model=m, name='log_d') bolfi = elfi.BOLFI(log_d, initial_evidence=20, update_interval=10, batch_size=5, bounds={ 't1': (-2, 2), 't2': (-1, 1) }, acq_noise_var=.1) n = 300 res = bolfi.infer(300) assert bolfi.target_model.n_evidence == 300 acq_x = bolfi.target_model._gp.X # check_inference_with_informative_data(res, 1, true_params, error_bound=.2) assert np.abs(res.x_min['t1'] - true_params['t1']) < 0.2 assert np.abs(res.x_min['t2'] - true_params['t2']) < 0.2 # Test that you can continue the inference where we left off res = bolfi.infer(n + 10) assert bolfi.target_model.n_evidence == n + 10 assert np.array_equal(bolfi.target_model._gp.X[:n, :], acq_x) post = bolfi.extract_posterior() # TODO: make cleaner. post_ml = minimize(post._neg_unnormalized_loglikelihood, post.model.bounds, post._gradient_neg_unnormalized_loglikelihood, post.prior, post.n_inits, post.max_opt_iters, random_state=post.random_state)[0] # TODO: Here we cannot use the minimize method due to sharp edges in the posterior. # If a MAP method is implemented, one must be able to set the optimizer and # provide its options. post_map = stochastic_optimization(post._neg_unnormalized_logposterior, post.model.bounds)[0] vals_ml = dict(t1=np.array([post_ml[0]]), t2=np.array([post_ml[1]])) check_inference_with_informative_data(vals_ml, 1, true_params, error_bound=.2) vals_map = dict(t1=np.array([post_map[0]]), t2=np.array([post_map[1]])) check_inference_with_informative_data(vals_map, 1, true_params, error_bound=.2) n_samples = 400 n_chains = 4 res_sampling = bolfi.sample(n_samples, n_chains=n_chains) check_inference_with_informative_data(res_sampling.samples, n_samples // 2 * n_chains, true_params, error_bound=.2) # check the cached predictions for RBF x = np.random.random((1, len(true_params))) bolfi.target_model.is_sampling = True pred_mu, pred_var = bolfi.target_model._gp.predict(x) pred_cached_mu, pred_cached_var = bolfi.target_model.predict(x) assert (np.allclose(pred_mu, pred_cached_mu)) assert (np.allclose(pred_var, pred_cached_var)) grad_mu, grad_var = bolfi.target_model._gp.predictive_gradients(x) grad_cached_mu, grad_cached_var = bolfi.target_model.predictive_gradients( x) assert (np.allclose(grad_mu[:, :, 0], grad_cached_mu)) assert (np.allclose(grad_var, grad_cached_var)) # test calculation of prior logpdfs true_logpdf_prior = ma2.CustomPrior1.logpdf(x[0, 0], 2) true_logpdf_prior += ma2.CustomPrior2.logpdf(x[0, 1], x[0, 0, ], 1) assert np.isclose(true_logpdf_prior, post.prior.logpdf(x[0, :]))
#kernel = GPy.kern.Matern52(input_dim=len(parameter_names), ARD=True) # The White kernel is used as part of a sum-kernel where it explains the # noise-component of the signal kernel += GPy.kern.White(input_dim=len(parameter_names)) target_model = elfi.GPyRegression(parameter_names=parameter_names, kernel=kernel, mean_function=mf, bounds=bounds) # Bolfire with a custom target acq_noise_var = np.power([2e-3, 2e-3, 2e-3], 2) bolfire = elfi.BOLFI(lfire, batch_size=1, initial_evidence=50, update_interval=10, target_model=target_model, async_acq=False, acq_noise_var=acq_noise_var) # Set parameters step_size = 10 max_evidence = 500 # Run inference for k in np.arange(bolfire.n_initial_evidence, max_evidence + step_size, step_size): print('n_evidence = {}'.format(k)) print('Beginning bolfire fit at {}'.format(datetime.datetime.now())) elfi.set_client('multiprocessing') post = bolfire.fit(n_evidence=k, bar=True)
def run( task: Task, num_samples: int, num_simulations: int, num_observation: Optional[int] = None, observation: Optional[torch.Tensor] = None, num_chains: int = 10, num_warmup: int = 1000, ) -> (torch.Tensor, int, Optional[torch.Tensor]): """Runs BOLFI from elfi package Args: task: Task instance num_samples: Number of samples to generate from posterior num_simulations: Simulation budget num_observation: Observation number to load, alternative to `observation` observation: Observation, alternative to `num_observation` num_chains: Number of chains num_warmup: Warmup steps Returns: Samples from posterior, number of simulator calls, log probability of true params if computable """ assert not (num_observation is None and observation is None) assert not (num_observation is not None and observation is not None) logging.basicConfig(level=logging.INFO) log = logging.getLogger(__name__) log.warn("ELFI is not fully supported yet!") # Initialize model object m = elfi.ElfiModel() # Prior bounds = build_prior(task=task, model=m) # Observation if observation is None: observation = task.get_observation(num_observation) observation = observation.numpy() # Simulator simulator = task.get_simulator(max_calls=num_simulations) elfi.Simulator( Simulator(simulator), *[m[f"parameter_{dim}"] for dim in range(task.dim_parameters)], observed=observation, name=task.name, ) # Euclidean distance elfi.Distance("euclidean", m[task.name], name="distance") # Log distance elfi.Operation(np.log, m["distance"], name="log_distance") # Inference num_samples_per_chain = ceil(num_samples / num_chains) tic = time.time() bolfi = elfi.BOLFI(model=m, target_name="log_distance", bounds=bounds) bolfi.fit(n_evidence=num_simulations) result_BOLFI = bolfi.sample( num_samples_per_chain + num_warmup, warmup=num_warmup, n_chains=num_chains, info_freq=int(100), ) toc = time.time() samples = torch.from_numpy(result_BOLFI.samples_array.astype( np.float32)).reshape(-1, task.dim_parameters)[:num_samples, :] assert samples.shape[0] == num_samples # TODO: return log prob of true parameters return samples, simulator.num_simulations, None
def build(self, model, pattern, prior_pos, prior_cov=25, r_bound=47.9, pmt_mask=np.ones(127), pax_e=25): ### Build Priors mu_e = pax_e std_e = pax_e**0.5 px = elfi.Prior(BoundedNormal_x, r_bound, prior_pos, prior_cov) py = elfi.Prior(BoundedNormal_y, px, r_bound, prior_pos, prior_cov) pe = elfi.Prior( 'truncnorm', (10 - mu_e) / std_e, (90 - mu_e) / std_e, 25, # mu_e, 3, # std_e, name='pe') ### Build Model model = elfi.tools.vectorize(model) Y = elfi.Simulator(model, px, py, pe, observed=np.array([pattern])) def summarize(x, k): return np.array([e[k] for e in x]) S1 = elfi.Summary(summarize, Y, 'energy') S2 = elfi.Summary(summarize, Y, 'time') de = elfi.Distance('braycurtis', S1) dt = elfi.Distance('braycurtis', S2) d = elfi.Operation(lambda a, b: a + b, de, dt) # TODO implement PMT mask here #d = elfi.Distance('braycurtis', Y) log_d = elfi.Operation(np.log, d) # set the ELFI model so we can remove it later self.model = px.model print(self.model.parameter_names) self.d0 = self.model.parameter_names.index('px') self.d1 = self.model.parameter_names.index('py') self.d2 = self.model.parameter_names.index('pe') ### Setup BOLFI bounds = { 'px': (-r_bound, r_bound), 'py': (-r_bound, r_bound), 'pe': (10, 90) } noise_vars = [5, 5, 5] #noise_vars[self.d2] = 10 # energy noise variance target_model = GPyRegression(self.model.parameter_names, bounds=bounds) acquisition_method = ConstraintLCBSC(target_model, prior=ModelPrior(self.model), noise_var=noise_vars, exploration_rate=10) acquisition_method.d0 = self.d0 acquisition_method.d1 = self.d1 bolfi = elfi.BOLFI( log_d, batch_size=1, initial_evidence=50, update_interval=1, # bounds=bounds, # Not used when using target_model target_model=target_model, # acq_noise_var=[0.1, 0.1], # Not used when using acq method acquisition_method=acquisition_method, ) return bolfi
def run_BOLFI_single(index, true_x, true_y, folder): ### Setup model = Model('XENON1T_ABC_all_pmts_on.ini') model.change_defaults(s2_electrons = 25) prior_mean = PriorPosition() pattern = model(true_x, true_y) pax_pos = model.get_latest_pax_position() prior_pos = prior_mean(pattern) r_bound = 47.8 pmt_mask = model.pmt_mask[:127].astype(int) ### Build Priors px = elfi.Prior(BoundedNormal_x, r_bound, prior_pos, 64) py = elfi.Prior(BoundedNormal_y, px, r_bound, prior_pos, 64) ### Build Model model=elfi.tools.vectorize(model) Y = elfi.Simulator(model, px, py, observed=pattern) def likelihood_chisquare(y, n, w=None): if w is not None: y = y[:,w.astype(bool)] n = n[:,w.astype(bool)] n = np.clip(n, 1e-10, None) y = np.clip(y, 1e-10, None) res = 2 * np.sum(y - n + n * np.log(n/y), axis=1) lres = np.log(res) #if lres > 10: # lres = np.ones(lres.shape) * 9 return lres def chisquare(y, n, w=None): if w is not None: y = y[:,w.astype(bool)] n = n[:,w.astype(bool)] y = np.clip(y, 1e-1, None) #print('y shape', y.shape) #print('n shape', n.shape) chisq, p = sps.chisquare(n, y, axis=1) return np.array(np.log(chisq)) def k2_test(y, n, w=None): if w is not None: y = y[:,w.astype(bool)] n = n[:,w.astype(bool)] #d, p = sps.ks_2samp(n, y) # , axis=1) # ks_2samp does not have axis arg ds = [sps.ks_2samp(n[0], y[i])[0] for i in range(y.shape[0])] return np.array(ds) def sqrt_euclid(y, n, w=None): if w is not None: y = y[:,w.astype(bool)] n = n[:,w.astype(bool)] d = np.sum(np.sqrt(np.abs(y - n)), axis=1) return d #likelihood_chisquare_masked = partial(likelihood_chisquare, w=pmt_mask) #log_d = elfi.Distance(likelihood_chisquare_masked, Y) #chisquare_masked = partial(chisquare, w=pmt_mask) #log_d = elfi.Distance(chisquare_masked, Y) #k2_test_masked = partial(k2_test, w=pmt_mask) #d = elfi.Distance(k2_test_masked, Y) #log_d = elfi.Operation(np.log, d) #sqrt_euclid_masked = partial(sqrt_euclid, w=pmt_mask) #d = elfi.Distance(sqrt_euclid_masked, Y) #log_d = elfi.Operation(np.log, d) d = elfi.Distance('euclidean', Y, w=pmt_mask) log_d = elfi.Operation(np.log, d) ### Setup BOLFI bounds = {'px':(-r_bound, r_bound), 'py':(-r_bound, r_bound)} target_model = GPyRegression(log_d.model.parameter_names, bounds=bounds) acquisition_method = ConstraintLCBSC(target_model, prior=ModelPrior(log_d.model), noise_var=[0.1, 0.1], exploration_rate=10) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=1, # bounds=bounds, # Not used when using target_model target_model=target_model, # acq_noise_var=[0.1, 0.1], # Not used when using acq method acquisition_method=acquisition_method, ) ### Run BOLFI post = bolfi.fit(n_evidence=200) bolfi.plot_discrepancy() plt.savefig(folder + 'bolfi_disc_%d.png' % index, dpi = 150) plt.close() result_BOLFI = bolfi.sample(1000, info_freq=1000) samples = result_BOLFI.samples_array means = result_BOLFI.sample_means modes = sps.mode(samples).mode[0] medians = np.median(samples, axis=0) pax_pos['truth'] = {'x': true_x, 'y': true_y} pax_pos['BOLFI_mean'] = {'x': means['px'], 'y': means['py']} pax_pos['BOLFI_mode'] = {'x': modes[0], 'y': modes[1]} pax_pos['BOLFI_median'] = {'x': medians[0], 'y': medians[1]} return pax_pos
shell_command = create_shell_command(args) #builds shell command nfds_simulator = create_model(shell_command) #creates model # Set an arbitrary global seed to keep the randomly generated quantities the same seed = 1 np.random.seed(seed) bolfi = elfi.BOLFI( nfds_simulator, batch_size=1, initial_evidence=20, update_interval=10, bounds={ 't1': (0, 1), 't2': (0, 0.05), 't3': (0, 1) }, acq_noise_var=[0.1, 0.01, 0.1], seed=seed) #creates bolfi object which will be fited to data print('fitting') post = bolfi.fit( n_evidence=2000 ) # fits hypermodel to data by minimizing the strain divergence metric, generates very wide probabiolity distributions print('fitted') with open(posterior_file, 'wb') as output: pickle.dump(post, output, pickle.HIGHEST_PROTOCOL) result_BOLFI = bolfi.sample(
#result.summary() #smc = elfi.SMC(d, batch_size=1000, seed=seed) #N = 500 #schedule = [0.7, 0.2, 0.05] #%time result_smc = smc.sample(N, schedule) #%time result2 = rej.sample(N, threshold=3) #d = elfi.Distance('euclidean', SA, SB, Sg, Sk) log_d = elfi.Operation(np.log, d) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=10, acq_noise_var=[0.1, 0.1, 0.1, 0.1], bounds={'A':(-10, 10), 'B':(0, 10), 'g':(0, 10), 'k':(0, 10)}, seed=seed) %time post = bolfi.fit(n_evidence=500) bolfi.plot_state(); bolfi.target_model bolfi.plot_discrepancy(); bolfi.extract_result().x_min #%time result_BOLFI = bolfi.sample(1000, n_chains=2, target_prob=0.8, info_freq=1000) #result_BOLFI
# Distance d = elfi.Distance('euclidean', S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11) ################################ # BOLFI implementation: # log_d = elfi.Operation(np.log, sim.model['d']) output_pool = elfi.OutputPool(outputs=['wee','wei','wie','wii','be','bi','taue','taui','k','IH','psi_sigma','sim','d', 'S1','S2','S3','S4','S5','S6','S7','S8','S9','S10','S11']) # pool=output_pool bolfi = elfi.BOLFI(d, batch_size=1, initial_evidence=4, update_interval=4, bounds={'wee': (10, 30), 'wei': (6, 30), 'wie': (6, 30), 'wii': (0.6, 1.4), 'be':(1,5), 'bi':(3,7), 'taue':(11,26.2), 'taui':(5.7,24.5), 'k':(0.5,2.5), 'IH':(1.5,3.5), 'psi_sigma':(0.05,0.25)}, acq_noise_var=0.1, seed=seed) # np.save('bolfi_test_23112021_sim_data', bolfi) post = bolfi.fit(n_evidence=6) bolfi.plot_discrepancy() result_BOLFI = bolfi.sample(6) result_BOLFI.plot_marginals(); result_BOLFI.plot_pairs(); np.save('bolfi_test_19112021_sim_data_bolfisample', result_BOLFI.samples_array)
ie_connProbOB2I = np.asarray(ie_connProbOB2I) ie_connProbGC2E = np.asarray(ie_connProbGC2E) ie_connProbGC2I = np.asarray(ie_connProbGC2I) ie_scores = np.asarray(ie_scores) #ie_log_scores = np.log(ie_scores) if not ie_connProbOB2E.any(): ie = 10 print('0 prior runs detected') else: ie = {'connProbOB2E_prior': ie_connProbOB2E, 'connProbOB2I_prior': ie_connProbOB2I, 'connProbGC2E_prior': ie_connProbGC2E, 'connProbGC2I_prior': ie_connProbGC2I, 'd': ie_scores} print(str(ie_connProbOB2E.size) + ' prior runs detected... using as initial evidence') bolfi = elfi.BOLFI(d, batch_size=1, initial_evidence=ie, update_interval=1, bounds={'connProbOB2E_prior':(0,.5),'connProbOB2I_prior':(0,.5),'connProbGC2E_prior':(0,.5),'connProbGC2I_prior':(0,.5)},acq_noise_var=[0,0,0,0,0,0,0,0,0,0],pool=pool) posterior = bolfi.fit(n_evidence=10) with open(datadir / 'bolfi_result.pkl','wb') as fname: pickle.dump(bolfi,fname) bolfi.plot_state() bolfi.plot_discrepancy() plt.show(block=True)
import elfi from elfi.examples import ma2 model = ma2.get_model(seed_obs=seed) log_d = elfi.Operation(np.log, model['d']) pool = elfi.OutputPool(['log_d', 't1', 't2']) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=10, bounds={ 't1': (-2, 2), 't2': (-1, 1) }, acq_noise_var=[0.1, 0.1], seed=seed, pool=pool) post = bolfi.fit(n_evidence=200) bolfi.target_model bolfi.plot_state() bolfi.plot_discrepancy() plt.show(block=True)
def main(base, output, number_processes): # generate null (should only execute once) use = 'BOLFI' #use = 'SINGLE' if use != 'SINGLE': click.secho('Generating null dataset', fg='yellow') subprocess.check_call( ["snakemake", "null", "--profile", "elfi_profile"]) click.secho('Creating environments', fg='yellow') subprocess.check_call( ["snakemake", "--profile", "elfi_profile", "--create-envs-only"]) click.secho('Starting BOLFI', fg='yellow') if base: global base_output base_output = base if output: global summary_output summary_output = output # setup priors elfi.set_client(multiprocessing.Client(num_processes=number_processes)) model = elfi.ElfiModel(name='msprime') elfi.Prior('uniform', 0, 0.5, model=model, name='n1') elfi.Prior('uniform', 0, 0.5, model=model, name='n2') elfi.Prior('uniform', 0, 1, model=model, name='split_prop') elfi.Prior('uniform', 1, 1861, model=model, name='split_size') snake_sim = elfi.tools.external_operation(command, prepare_inputs=prepare_inputs, process_result=process_result, stdout=False) vec_snake = elfi.tools.vectorize(snake_sim) empirical = np.array([ 0, # desert MSE 0.291761, 0.328705, 0.335145, # pi 0.12985, 0.156539, 0.0921547, # fst 0.023, 0.019 ]) # admix snake_node = elfi.Simulator(vec_snake, model['n1'], model['n2'], model['split_prop'], model['split_size'], observed=empirical, name='snake_sim') snake_node.uses_meta = True distance = elfi.Distance('euclidean', snake_node, name='dist') if use == 'SINGLE': print( snake_sim(0.1, 0.1, 0.1, 100, seed=2, meta={ 'model_name': 'test', 'batch_index': 1, 'submission_index': 2 })) return elif use == 'BOLFI': pool = elfi.ArrayPool( ['n1', 'n2', 'split_prop', 'split_size', 'snake_sim'], name='bolfi_pool') bolfi = elfi.BOLFI(distance, batch_size=1, initial_evidence=20, update_interval=3, bounds={ 'n1': (0, 0.5), 'n2': (0, 0.5), 'split_prop': (0, 1), 'split_size': (1, 1861) }, pool=pool) post = bolfi.fit(n_evidence=10, bar=False) click.secho('Saving results', fg='yellow') pool.save() post.save() click.secho('Done', fg='green') return
# Fit w/ SMC ABC #sys.stderr.write("SMC inference\n") #smc = elfi.SMC(log_d, batch_size=10000, seed=1) #N = 1000 #schedule = [0.7, 0.2, 0.05] #result_smc = smc.sample(N, schedule) #result_smc.summary(all=True) #result_smc.plot_marginals(all=True, bins=25, figsize=(8, 2), fontsize=12) # Run fit w/ BOLFI sys.stderr.write("BOLFI inference\n") bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=10, bounds={ 'beta': (0.001, 3), 't_com': (1, 6) }, acq_noise_var=[0.01, 0.01], seed=1) post = bolfi.fit(n_evidence=200) # Save results dill.dump(bolfi, open("bolfi.pkl", "wb")) dill.dump(post, open("posterior.pkl", "wb")) # plot results bolfi.plot_state() plt.savefig("bolfi_state.pdf") plt.close()
log_d = elfi.Operation(np.log, d) ie = { 'm_prior': np.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 's_prior': np.asarray([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'log_d': np.asarray([2, 1.6, 1.2, .8, 0, .8, 1.2, 1.6, 2, 2.4]) } pool = elfi.OutputPool(['m_prior', 's_prior', 'sim', 'S', 'd', 'log_d']) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=ie, update_interval=5, bounds={ 'm_prior': (0, 20), 's_prior': (0, 20) }, acq_noise_var=[0, 0], pool=pool) posterior = bolfi.fit(n_evidence=200) savedir = Path('/home/ben/phd/stfp/abc_results/') with open(savedir / 'test_save.pkl', 'wb') as fname: pickle.dump(bolfi, fname) #bolfi.plot_state() bolfi.plot_discrepancy() plt.show(block=True)
def main(): global eng datadir = Path('/home/ben/phd/stfp/abc_results/gradientNet') eng = matlab.engine.start_matlab() eng.addpath(eng.genpath('~/phd/stfp/abc_code')) eng.addpath(eng.genpath('~/phd/easySim')) maxConnProbOB2E_prior = elfi.Prior('uniform', 0, 1) maxConnProbOB2I_prior = elfi.Prior('uniform', 0, 1) maxConnProbGC2E_prior = elfi.Prior('uniform', 0, 1) maxConnProbGC2I_prior = elfi.Prior('uniform', 0, 1) sigmaOB2PC_prior = elfi.Prior('uniform', 1e-6, 1000e-6) sigmaGC2PC_prior = elfi.Prior('uniform', 1e-6, 1000e-6) sim = elfi.Simulator(simulator, maxConnProbOB2E_prior, maxConnProbOB2I_prior, maxConnProbGC2E_prior, maxConnProbGC2I_prior, sigmaOB2PC_prior, sigmaGC2PC_prior, observed=0) S = elfi.Summary(score_network, sim) d = elfi.Distance('euclidean', S) #log_d = elfi.Operation(np.log, d) pool = elfi.OutputPool([ 'connProbOB2E_prior', 'connProbOB2I_prior', 'connProbGC2E_prior', 'connProbGC2I_prior', 'sigmaOB2PC_prior', 'sigmaGC2PC_prior', 'S', 'd' ]) ie_maxConnProbOB2E, ie_maxConnProbOB2I, ie_maxConnProbGC2E, ie_maxConnProbGC2I, ie_sigmaOB2PC, ie_sigmaGC2PC, ie_scores = eng.load_initial_evidence_gradientNet( '/home/ben/phd/stfp/abc_results/gradientNet', nargout=7) ie_maxConnProbOB2E = np.asarray(ie_maxConnProbOB2E) ie_maxConnProbOB2I = np.asarray(ie_maxConnProbOB2I) ie_maxConnProbGC2E = np.asarray(ie_maxConnProbGC2E) ie_maxConnProbGC2I = np.asarray(ie_maxConnProbGC2I) ie_sigmaOB2PC = np.asarray(ie_sigmaOB2PC) ie_sigmaGC2PC = np.asarray(ie_sigmaGC2PC) ie_scores = np.asarray(ie_scores) #ie_log_scores = np.log(ie_scores) if not ie_maxConnProbOB2E.any(): ie = 10 print('0 prior runs detected') else: ie = { 'maxConnProbOB2E_prior': ie_maxConnProbOB2E, 'maxConnProbOB2I_prior': ie_maxConnProbOB2I, 'maxConnProbGC2E_prior': ie_maxConnProbGC2E, 'maxConnProbGC2I_prior': ie_maxConnProbGC2I, 'sigmaOB2PC_prior': ie_sigmaOB2PC, 'sigmaGC2PC_prior': ie_sigmaGC2PC, 'd': ie_scores } print( str(ie_maxConnProbOB2E.size) + ' prior runs detected... using as initial evidence') bolfi = elfi.BOLFI(d, batch_size=1, initial_evidence=ie, update_interval=1, bounds={ 'maxConnProbOB2E_prior': (0, 1), 'maxConnProbOB2I_prior': (0, 1), 'maxConnProbGC2E_prior': (0, 1), 'maxConnProbGC2I_prior': (0, 1), 'sigmaOB2PC_prior': (1e-6, 1000e-6), 'sigmaGC2PC_prior': (1e-6, 1000e-6) }, acq_noise_var=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], pool=pool) posterior = bolfi.fit(n_evidence=500) with open(datadir / 'bolfi_result.pkl', 'wb') as fname: pickle.dump(bolfi, fname) #bolfi.plot_state() bolfi.plot_discrepancy() plt.show(block=True)
Ms=50, IW_samples=5, pred_samples=20, opt_steps=20000, q=q) meth += '-' + surrogate meth += '-' + str(q) meth += '(' + str(evidence) + ')' acq = LCBSC(target_model, noise_var=noise_var, exploration_rate=10, seed=seed) bolfi = elfi.BOLFI(elfi_model, 'dist', batch_size=5, initial_evidence=init_ev, update_interval=init_ev, target_model=target_model, acquisition_method=acq, seed=seed) # conduct inference post, mses = bolfi.fit(n_evidence=evidence, bar=False) res = bolfi.extract_result() samples, weights = get_weighted_samples(post, N=100000) samples_df = None # posterior_samples = sample_posterior(samples, weights, cols=par_names, N=10000) elif meth == 'NDE': surrogate = str(args.surrogate) theta_dim = len(par_names) data_dim = len(compressed_data) if surrogate == 'MDN':