def test_IndependentJoint_uniform_rejection():
# check that proposed samples are correctly rejected when using a
# IndependentJoint prior with some child distributions uniform. We used a
# Gaussian proposal to generate some samples that need to be rejected.
N = 1000
B1 = [-1.0, 1.0]
B2 = [-2.0, 2.0]
u1 = dd.Uniform(B1[0], B1[1])
u2 = dd.Uniform(B2[0], B2[1])
prior = dd.IndependentJoint([u1, u2])
m = [0., 0.]
S = [[
2.,
0.,
], [
0.,
2.,
]]
proposal = dd.Gaussian(m=m, S=S)
model = Gauss(dim=2)
s = ds.Identity()
g = dg.Default(model=model, prior=prior, summary=s)
g.proposal = proposal
params, stats = g.gen(N, verbose=False)
assert (params.min(axis=0) >= np.array([B1[0], B2[0]])).all() and \
(params.min(axis=0) <= np.array([B1[1], B2[1]])).all(), \
"rejection failed"
def test_IndependentJoint_eval():
N = 1000
B1 = [-1.0, 1.0]
B2 = [-2.0, 2.0]
u1 = dd.Uniform(B1[0], B1[1])
u2 = dd.Uniform(B2[0], B2[1])
dist = dd.IndependentJoint([u1, u2])
samples = dist.gen(N)
logprobs = dist.eval(samples, log=True)
lpdfval = -np.log((B2[1] - B2[0]) * (B1[1] - B1[0]))
assert np.isclose(logprobs, lpdfval).all()
assert samples.shape == (N, 2)
assert logprobs.shape == (N, )
def dont_test_apt_inference_atomicprop_maf_normalize(n_params, seed=47):
# normalization test is not finished yet.
m = Gauss(dim=n_params, noise_cov=0.1)
p = dd.Uniform(lower=-0.05 * np.ones(n_params),
upper=0.05 * np.ones(n_params))
s = ds.Identity()
g = dg.Default(model=m, prior=p, summary=s)
def plot_1d_posterior(env_params=None,
p_lower=[0.1, 0.1],
p_upper=[2.0, 2.0],
params_shape=2,
posterior=None):
p = dd.Uniform(lower=p_lower, upper=p_upper)
for i in range(params_shape):
minlim = p_lower[i] - 0.1 * p_lower[i]
maxlim = p_upper[i] + 0.1 * p_upper[i]
x_plot = np.arange(minlim, maxlim, 0.001).reshape(-1, 1)
y_plot = posterior.eval(x_plot, ii=[i], log=False)
y_plot_prior = p.eval(x_plot, ii=[i], log=False)
plt.plot(x_plot, y_plot, '-b', label=r'Predicted posterior')
plt.plot(x_plot, y_plot_prior, '-g', label=r'Uniform prior')
cur_true_param = true_obs.ravel()[i]
plt.axvline(cur_true_param,
c='r',
label=r'True value of ' + env_params[i])
plt.legend(fontsize=10)
plt.axis('on')
plt.xlabel(env_params[i] + ' values')
# fig.savefig('/tmp/'+env_params[i]+'.pdf', bbox_inches='tight')
plt.show()
def prior(true_params,
prior_uniform=True,
prior_extent=False,
prior_log=False,
seed=None):
"""Prior"""
if not prior_extent:
range_lower = param_transform(prior_log, 0.5 * true_params)
range_upper = param_transform(prior_log, 1.5 * true_params)
else:
range_lower = param_transform(
prior_log, np.array([.5, 1e-4, 1e-4, 1e-4, 50., 40., 1e-4, 35.]))
range_upper = param_transform(
prior_log, np.array([80., 15., .6, .6, 3000., 90., .15, 100.]))
range_lower = range_lower[0:len(true_params)]
range_upper = range_upper[0:len(true_params)]
if prior_uniform:
prior_min = range_lower
prior_max = range_upper
return dd.Uniform(lower=prior_min, upper=prior_max, seed=seed)
else:
prior_mn = param_transform(prior_log, true_params)
prior_cov = np.diag((range_upper - range_lower)**2) / 12
return dd.Gaussian(m=prior_mn, S=prior_cov, seed=seed)
def main(args):
log = prep_log(args)
log.info("Running {}.".format(args.name))
if args.verbose:
log.info(args)
prior_lims = np.array([[0, 1], [-10., 10.], [-120., 120.], [0., 2000],
[0., 0.5], [0, 0.05], [0., 0.5], [0, 0.05]])
if args.verbose:
log.info('prior')
log.info(prior_lims)
m = ChannelOmni(third_exp_model=False, seed=args.seed)
p = dd.Uniform(lower=prior_lims[:, 0], upper=prior_lims[:, 1])
s = ChannelStats()
g = Default(model=m, prior=p, summary=s)
tic = time.time()
dats = g.gen(args.n_samples)
toc = time.time()
log.info('Generation took {}s.'.format(toc - tic))
np.save('{}/theta.npy'.format(args.bp), dats[0])
np.save('{}/stats.npy'.format(args.bp), dats[1])
def test_TransformedDistribution(seed=5, nsamples=1000, ndim=2):
lower = np.random.rand(ndim)
upper = np.random.rand(ndim) + 2
dist = dd.Uniform(lower, upper)
dist.reseed(seed)
z = dist.gen(nsamples)
inputscale = lambda x: (x - lower) / (upper - lower)
bijection = lambda x: logit(inputscale(x)
) # logit function with scaled input
inverse_bijection = lambda y: expit(y) * (
upper - lower) + lower # logistic function with scaled output
bijection_jac_logD = lambda x: -(np.log(
inputscale(x) *
(1 - inputscale(x))) + np.log(upper - lower)).sum(axis=-1)
dist_transformed = dd.TransformedDistribution(
distribution=dist,
bijection=bijection,
inverse_bijection=inverse_bijection,
bijection_jac_logD=bijection_jac_logD)
dist_transformed.reseed(seed)
z_transformed = dist_transformed.gen(nsamples)
assert np.allclose(z_transformed, bijection(z), atol=1e-8)
dist_logistic = dd.Logistic(mu=np.zeros(ndim))
assert np.allclose(dist_logistic.eval(z_transformed, log=False), dist_transformed.eval(z_transformed, log=False)), \
"incorrect density"
assert np.allclose(dist_logistic.eval(z_transformed, log=True), dist_transformed.eval(z_transformed, log=True)), \
"incorrect log density"
def test_uniform_2d():
N = 1000
lower = [1., 3.]
upper = [2., 4.]
dist = dd.Uniform(lower, upper, seed=seed)
samples = dist.gen(N)
logprobs = dist.eval(samples)
assert samples.shape == (N, 2)
assert logprobs.shape == (N,)
def baseParamInit():
N = 20 # number of trials at each orientation
sensitivity_true = 1.2
# bias_true = .8
bias_true = 2
labels = ['sensitivity', 'bias']
true_params = [sensitivity_true, bias_true]
seed_p = 2
prior_apt = dd.Uniform(lower=np.asarray([0.1, -5]),
upper=np.asarray([9.9, 5]),
seed=seed_p)
analyticModel = None
apt_model = None
s = None
hyps = {
'prior': prior_apt,
'm': apt_model,
's': s,
'n_train': 5000,
'n_rounds': 3,
'n_hiddens': [50, 50],
'pilot_samples': 2000,
'val_frac': 0.05,
'minibatch': 500,
'epochs': 100,
'density': 'maf',
'n_mades': 5,
'seed_inf': 1
}
n_steps = 15000
fignames = ''
folderName = ''
param_dict = {
'N': N,
'true_params': true_params,
'hyps': hyps,
'analyticModel': analyticModel,
'fignames': fignames,
'folderName': folderName,
'n_steps': n_steps
}
return param_dict
def baseParamInit():
N = 1000
alpha_true = .5
beta_true = -2
err = 0.4 # err to be fixed
labels = ['slope', 'intercept']
true_params = [alpha_true, beta_true]
seed_p = 2
prior_apt = dd.Uniform(lower=np.asarray([-10, -10]),
upper=np.asarray([10, 10]),
seed=seed_p)
analyticModel = None
apt_model = None
s = None
hyps = {
'prior': prior_apt,
'm': apt_model,
's': s,
'n_train': 5000,
'n_rounds': 3,
'n_hiddens': [50, 50],
'pilot_samples': 2000,
'val_frac': 0.05,
'minibatch': 500,
'epochs': 100,
'density': 'maf',
'n_mades': 5,
'seed_inf': 1
}
n_steps = 15000
fignames = ''
folderName = ''
param_dict = {
'N': N,
'true_params': true_params,
'hyps': hyps,
'analyticModel': analyticModel,
'fignames': fignames,
'folderName': folderName,
'n_steps': n_steps,
'err': err
}
return param_dict
def get_maprf_prior_01(params_ls, seed=None, no_transform=False):
## prior over simulation parameters
prior = collections.OrderedDict()
if no_transform:
lims = np.array([[-1.5, -1.1, .001, 0.01, .001, 0.01, 0.01, -.999, -.999],
[ 1.5, 1.1, .999*np.pi, 2.49, 1.999*np.pi, 1.99, 3.99, .999, .999]]).T
p = dd.Uniform(lower=lims[:,0], upper=lims[:,1])
return p, prior
## prior over simulation parameters
if 'bias' in params_ls['glm']:
prior['bias'] = {'mu' : np.array([-0.57]), 'sigma' : np.array([np.sqrt(1.63)]) }
if 'gain' in params_ls['kernel']['s']:
# prior['A'] = {'mu' : np.zeros(1), 'sigma' : 2 * np.ones(1) }
prior['log_A'] = {'mu' : np.zeros(1), 'sigma' : np.ones(1) / 2 }
if 'phase' in params_ls['kernel']['s']:
prior['logit_φ'] = {'mu' : np.array([0]), 'sigma' : np.array([1.9]) }
if 'freq' in params_ls['kernel']['s']:
prior['log_f'] = {'mu' : np.zeros(1), 'sigma' : np.ones(1) / 2 }
if 'angle' in params_ls['kernel']['s']:
prior['logit_θ'] = {'mu' : np.zeros(1), 'sigma' : np.array([1.78]) }
if 'ratio' in params_ls['kernel']['s']:
prior['log_γ'] = {'mu' : np.zeros(1), 'sigma' : np.ones(1) / 2}
if 'width' in params_ls['kernel']['s']:
prior['log_b'] = {'mu' : np.zeros(1), 'sigma' : np.ones(1) / 2}
if 'xo' in params_ls['kernel']['l']:
prior['logit_xo'] = {'mu' : np.array([0.]), 'sigma' : np.array([1.78]) }
#prior['xo'] = {'mu' : np.array([0.]), 'sigma' : np.array([1./np.sqrt(4)]) }
if 'yo' in params_ls['kernel']['l']:
prior['logit_yo'] = {'mu' : np.array([0.]), 'sigma' : np.array([1.78]) }
#prior['yo'] = {'mu' : np.array([0.]), 'sigma' : np.array([1./np.sqrt(4)]) }
L = np.diag(np.concatenate([prior[i]['sigma'] for i in list(prior.keys())]))
if 'value' in params_ls['kernel']['t']:
ax_t = m.dt * np.arange(1,len_kt+1)
Λ = np.diag(ax_t / 0.075 * np.exp(1 - ax_t / 0.075))
D = np.eye(ax_t.shape[0]) - np.eye(ax_t.shape[0], k=-1)
F = np.dot(D, D.T)
Σ = np.dot(Λ, np.linalg.inv(F).dot(Λ))
prior['kt'] = {'mu': np.zeros_like(ax_t), 'sigma': np.linalg.inv(D).dot(Λ)}
L = np.block([[L, np.zeros((L.shape[0], ax_t.size))],
[np.zeros((ax_t.size, L.shape[1])), prior['kt']['sigma']]])
mu = np.concatenate([prior[i][ 'mu' ] for i in prior.keys()])
p = dd.Gaussian(m=mu, S=L.T.dot(L), seed=seed)
return p, prior
def eval_log_pdf(point, pdf, check_prior):
if check_prior:
prior = dd.Uniform(-np.sqrt(3) * np.ones(len(point)),
np.sqrt(3) * np.ones(len(point)))
if not np.all(params_are_bounded(point, prior, normalized=True)):
return 1e20
else:
try:
output = -pdf.eval([point])
except:
output = -pdf.eval(point)
return output
else:
try:
output = -pdf.eval([point])
except:
output = -pdf.eval(point)
return output
def prior(true_params, seed=None, prior_log=False, prior_uniform=False):
"""Prior"""
range_lower = param_transform(prior_log ,0.5*true_params)
range_upper = param_transform(prior_log, 1.5*true_params)
range_lower = range_lower[0:len(true_params)]
range_upper = range_upper[0:len(true_params)]
if prior_uniform:
prior_min = range_lower
prior_max = range_upper
return dd.Uniform(lower=prior_min, upper=prior_max,
seed=seed)
else:
prior_mn = param_transform(prior_log,true_params)
prior_cov = np.diag((range_upper - range_lower)**2)/12
return dd.Gaussian(m=prior_mn, S=prior_cov, seed=seed)
import delfi.distribution as dd
################################################################################
# seeding by time stamp
seed1 = time.time()
seed = int((seed1 % 1) * 1e7)
rng = np.random.RandomState(seed=seed)
################################################################################
hyper_params = netio.load_setup("train_31D_R1_BigPaper")
# define prior
seed_p = rng.randint(1e7)
hyper_params.seed = seed_p
num_dim = np.sum(hyper_params.use_membrane) + 7
p = dd.Uniform(-np.sqrt(3) * np.ones(num_dim), np.sqrt(3) * np.ones(num_dim), seed=hyper_params.seed)
################################################################################
# sample from prior and run simulations
pool_size = 28 # 28 worked
import dill as pickle
with open('results/31D_nets/191001_seed1_Exper11deg.pkl', 'rb') as file:
inf_SNPE_MAF, log, params = pickle.load(file)
summstats_experimental = np.load('results/31D_experimental/190807_summstats_prep845_082_0044.npz')['summ_stats']
posterior_prev_round = inf_SNPE_MAF.predict([summstats_experimental])
# sample from prior and run simulations
################################################################################
# Load data #
################################################################################
filedir = "results/31D_samples/pyloricsamples_31D_noNaN_3.npz"
pilot_data, _, params_mean, params_std = tu.load_trn_data_normalize(
filedir, params)
print('We use', len(pilot_data[0]), 'training samples.')
################################################################################
# Define prior #
################################################################################
# create standard prior for the actual conductances
prior = netio.create_prior(params, log=True)
prior_norm = dd.Uniform(lower=-np.sqrt(3) * np.ones(dimensions),
upper=np.sqrt(3) * np.ones(dimensions))
################################################################################
# Load pairs #
################################################################################
xo_stats = np.load(
'results/31D_experimental/190807_summstats_prep845_082_0044.npz'
)['summ_stats']
obs = xo_stats
################################################################################
# Define ss and g #
################################################################################
# Using the 'PrinzStats' here, defined in summstats.py. Inferring the summstats
def create_prior(params, log=False):
if params.novel_prior:
assert params.comp_neurons is None, "Is you are using a novel prior, you can not use comp_neurons"
# rows: LP, PY, PD
# columns: the eight membrane conductances
# contains the minimal values that were used by Prinz et al.
low_val = 0.0
membrane_cond_mins = np.asarray([
[100, 2.5, 2, 10, 5, 50, 0.01, low_val], # PM
[100, low_val, 4, 20, low_val, 25, low_val, 0.02], # LP
[100, 2.5, low_val, 40, low_val, 75, low_val, low_val]
]) * 0.628e-3 # PY
# contains the maximal values that were used by Prinz et al.
membrane_cond_maxs = np.asarray([
[400, 5.0, 6, 50, 10, 125, 0.01, low_val], # PM
[100, low_val, 10, 50, 5, 100, 0.05, 0.03], # LP
[500, 10, 2, 50, low_val, 125, 0.05, 0.03]
]) * 0.628e-3 # PY
ranges = np.asarray([100, 2.5, 2, 10, 5, 25, 0.01, 0.01]) * 0.628e-3
membrane_cond_mins = membrane_cond_mins - ranges
membrane_cond_maxs = membrane_cond_maxs + ranges
membrane_cond_mins[membrane_cond_mins < 0.0] = 0.0
use_membrane = np.asarray(params.use_membrane)
membrane_used_mins = membrane_cond_mins[use_membrane == True].flatten()
membrane_used_maxs = membrane_cond_maxs[use_membrane == True].flatten()
# proctolin
proctolin_gbar_mins = [0.0, 0.0, 0.0]
proctolin_gbar_maxs = np.asarray([6.0, 8.0, 0.0]) * 1e-6
use_proctolin = params.use_proctolin
syn_dim_mins = np.ones_like(
params.true_params
) * params.syn_min # syn_min is the start of uniform interval
syn_dim_maxs = np.ones_like(
params.true_params
) * params.syn_max # syn_max is the end of uniform interval
syn_dim_maxs[0] *= 10.0
if log:
syn_dim_mins = np.log(syn_dim_mins)
syn_dim_maxs = np.log(syn_dim_maxs)
# q10 values for synapses
gbar_q10_syn_mins = np.asarray([1.0, 1.0])
gbar_q10_syn_maxs = np.asarray([2.0, 2.0])
tau_q10_syn_mins = np.asarray([1.0, 1.0])
tau_q10_syn_maxs = np.asarray([4.0, 4.0])
use_gbar_syn = np.asarray(params.Q10_gbar_syn)
use_tau_syn = np.asarray(params.Q10_tau_syn)
gbar_q10_syn_used_mins = gbar_q10_syn_mins[use_gbar_syn].flatten()
gbar_q10_syn_used_maxs = gbar_q10_syn_maxs[use_gbar_syn].flatten()
tau_q10_syn_used_mins = tau_q10_syn_mins[use_tau_syn].flatten()
tau_q10_syn_used_maxs = tau_q10_syn_maxs[use_tau_syn].flatten()
# q10 values for membrane
gbar_q10_mem_mins = np.asarray(
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
gbar_q10_mem_maxs = np.asarray(
[2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0])
use_gbar_mem = np.asarray(params.Q10_gbar_mem)
gbar_q10_mem_used_mins = gbar_q10_mem_mins[use_gbar_mem].flatten()
gbar_q10_mem_used_maxs = gbar_q10_mem_maxs[use_gbar_mem].flatten()
if use_proctolin:
membrane_and_sny_mins = np.concatenate(
(membrane_used_mins, proctolin_gbar_mins, syn_dim_mins,
gbar_q10_syn_used_mins, tau_q10_syn_used_mins,
gbar_q10_mem_used_mins))
membrane_and_sny_maxs = np.concatenate(
(membrane_used_maxs, proctolin_gbar_maxs, syn_dim_maxs,
gbar_q10_syn_used_maxs, tau_q10_syn_used_maxs,
gbar_q10_mem_used_maxs))
else:
membrane_and_sny_mins = np.concatenate(
(membrane_used_mins, syn_dim_mins, gbar_q10_syn_used_mins,
tau_q10_syn_used_mins, gbar_q10_mem_used_mins))
membrane_and_sny_maxs = np.concatenate(
(membrane_used_maxs, syn_dim_maxs, gbar_q10_syn_used_maxs,
tau_q10_syn_used_maxs, gbar_q10_mem_used_maxs))
else:
if params.comp_neurons is not None:
neuron_1 = np.asarray(create_neurons(params.comp_neurons[0]))
neuron_2 = np.asarray(create_neurons(params.comp_neurons[1]))
membrane_cond_mins = np.minimum(neuron_1, neuron_2)
membrane_cond_maxs = np.maximum(neuron_1, neuron_2)
membrane_cond_mins[membrane_cond_mins == 0.0] += 1e-20
membrane_cond_maxs[membrane_cond_maxs == 0.0] += 1e-20
params.use_membrane = membrane_cond_mins != membrane_cond_maxs
else:
# rows: LP, PY, PD
# columns: the eight membrane conductances
# contains the minimal values that were used by Prinz et al.
low_val = 0.0
membrane_cond_mins = np.asarray([
[100, 2.5, 2, 10, 5, 50, 0.01, low_val], # PM
[100, low_val, 4, 20, low_val, 25, low_val, 0.02], # LP
[100, 2.5, low_val, 40, low_val, 75, low_val, low_val]
]) * 0.628e-3 # PY
# contains the maximal values that were used by Prinz et al.
membrane_cond_maxs = np.asarray([
[400, 5.0, 6, 50, 10, 125, 0.01, low_val], # PM
[100, low_val, 10, 50, 5, 100, 0.05, 0.03], # LP
[500, 10, 2, 50, low_val, 125, 0.05, 0.03]
]) * 0.628e-3 # PY
security_factor = 1.25 # factor that we increase the margin used by Prinz et al. with
membrane_cond_mins *= (2.0 - security_factor)
membrane_cond_maxs *= security_factor
membrane_cond_maxs[membrane_cond_maxs == 0.0] = np.asarray(
[1.0, 1.0, 0.01]) * 0.628e-3
use_membrane = np.asarray(params.use_membrane)
membrane_used_mins = membrane_cond_mins[use_membrane == True].flatten()
membrane_used_maxs = membrane_cond_maxs[use_membrane == True].flatten()
syn_dim_mins = np.ones_like(
params.true_params
) * params.syn_min # syn_min is the start of uniform interval
syn_dim_maxs = np.ones_like(
params.true_params
) * params.syn_max # syn_max is the end of uniform interval
if log:
syn_dim_mins = np.log(syn_dim_mins)
syn_dim_maxs = np.log(syn_dim_maxs)
membrane_and_sny_mins = np.concatenate(
(membrane_used_mins, syn_dim_mins))
membrane_and_sny_maxs = np.concatenate(
(membrane_used_maxs, syn_dim_maxs))
return dd.Uniform(membrane_and_sny_mins,
membrane_and_sny_maxs,
seed=int(params.seed))
