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':
