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 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 test_trainer_updates():
n_components = 1
n_params = 2
seed = 42
svi = True
m = Gauss(dim=n_params)
p = dd.Gaussian(m=np.zeros((n_params, )), S=np.eye(n_params))
s = ds.Identity()
g = dg.Default(model=m, prior=p, summary=s)
nn = NeuralNet(
n_components=n_components,
n_hiddens=[10],
n_inputs=n_params,
n_outputs=n_params,
seed=seed,
svi=svi)
loss = -tt.mean(nn.lprobs)
trn_inputs = [nn.params, nn.stats]
trn_data = g.gen(100) # params, stats
trn_data = tuple(x.astype(dtype) for x in trn_data)
t = Trainer(network=nn, loss=loss, trn_data=trn_data, trn_inputs=trn_inputs)
# single update
outputs = t.make_update(*trn_data)
# training
outputs = t.train(100, 50)
def runAPT2psychometric(obs0, hyps, labels, true_params, fignames, plot=True):
"""
obs0:
The data observation we made
This takes in a dict with the following parameters:
prior : prior estimate and bounds
m : The model we are going to run apt on
s : The summary statistics we care about
n_train : Number of param-samples drawn during a training round
n_rounds : Number of rounds you want to run APT for
n_hidden : A Number of Layers x 1 array containing the layer sizes
pilot_samples : Number of samples drawn during the pilot run
val_frac : Fraction of validation samples
minibatch : Size of a batch
epochs : Number of training iterations
density : 'mog' or 'maf' supported
n_mades : number of Mades, an MAF parameter
"""
g = dg.Default(model=hyps['m'], prior=hyps['prior'], summary=hyps['s'])
# define statsitics summary of observation
obs_stats = hyps['s'].calc([obs0])
seed_inf = hyps['seed_inf']
prior_norm = True
# MAF parameters
density = 'maf'
n_mades = 5 # number of MADES
# inference object
res = infer.SNPEC(g,
obs=obs_stats,
n_hiddens=hyps['n_hiddens'],
seed=seed_inf,
pilot_samples=hyps['pilot_samples'],
n_mades=hyps['n_mades'],
prior_norm=prior_norm,
density=hyps['density'])
# train
log, _, posterior = res.run(
n_train=hyps['n_train'],
n_rounds=hyps['n_rounds'],
minibatch=hyps['minibatch'],
epochs=hyps['epochs'],
silent_fail=False,
proposal='prior',
val_frac=hyps['val_frac'],
verbose=True,
)
if plot == True:
plot_APT(posterior, g, labels, true_params, fignames)
return posterior
def test_gauss_shape():
for n_params in range(1, 3):
m = Gauss(dim=n_params)
p = dd.Gaussian(m=np.zeros((n_params, )), S=np.eye(n_params))
s = ds.Identity()
g = dg.Default(model=m, prior=p, summary=s)
n_samples = 100
params, stats = g.gen(n_samples)
n_summary = n_params
assert params.shape == (n_samples, n_params)
assert stats.shape == (n_samples, n_summary)
def init_all_gaussian(n_params=2,
seed=42,
inferenceobj=None,
**inf_setup_opts):
model = Gauss(dim=n_params, seed=seed)
prior = dd.Gaussian(m=np.zeros((n_params, )),
S=np.eye(n_params),
seed=seed + 1)
s = ds.Identity(seed=seed + 2)
g = dg.Default(model=model, prior=prior, summary=s, seed=seed + 3)
obs = np.zeros((1, n_params)) # reseed generator etc. (?)
res = inferenceobj(g, obs=obs, seed=seed + 4, **inf_setup_opts)
res.reset(seed=seed + 4)
m_true, S_true = simplegaussprod(obs, model.noise_cov, prior.m, prior.S)
return res, m_true, S_true
def test_basic_inference(n_params=2, seed=42):
m = Gauss(dim=n_params, seed=seed)
p = dd.Gaussian(m=np.zeros((n_params, )), S=np.eye(n_params), seed=seed)
s = ds.Identity()
g = dg.Default(model=m, prior=p, summary=s)
# set up inference
res = infer.Basic(g, seed=seed)
# run with N samples
out = res.run(1000)
# check result
posterior = res.predict(np.array([0., 0.]).reshape(1, -1))
assert np.allclose(posterior.xs[0].S,
np.array([[0.1, 0.0], [0.0, 0.1]]),
atol=0.05)
assert np.allclose(posterior.xs[0].m, np.array([0.0, 0.0]), atol=0.05)
def test_rng_repeatability():
mu = np.atleast_1d([0.0])
S = np.atleast_2d(1.0)
# distributions
pG = dd.Gaussian(m=mu, S=S)
check_repeatability_dist(pG)
pMoG = dd.MoG(a=np.array([0.25, 0.75]), ms=[mu, mu], Ss=[S, S])
check_repeatability_dist(pMoG)
# simulators
mG = sims.Gauss()
check_repeatability_sim(mG, np.zeros(mG.dim_param).reshape(-1, 1))
mMoG = sims.GaussMixture()
check_repeatability_sim(mMoG, np.zeros(mMoG.dim_param).reshape(-1, 1))
# generators
g = gen.Default(model=mMoG, prior=pMoG, summary=Identity())
check_repeatability_gen(g)
# inference methods
# we're going to create each one with a different deepcopy of g to make
# sure thre are are no side effects e.g. changes to the proposal
x0 = g.gen(1, verbose=False)[1]
inf_opts = dict(obs=x0,
n_components=2,
n_hiddens=[5, 5],
verbose=False,
pilot_samples=0)
yB_nosvi = inf.Basic(deepcopy(g), svi=False, **inf_opts)
check_repeatability_infer(yB_nosvi)
yB_svi = inf.Basic(deepcopy(g), svi=True, **inf_opts)
check_repeatability_infer(yB_svi)
# skip CDELFI for now since it might crash if we don't use the prior
#yC = inf.CDELFI(deepcopy(g), **inf_opts)
#check_repeatability_infer(yC)
yS = inf.SNPE(deepcopy(g), prior_mixin=0.5, **inf_opts)
check_repeatability_infer(yS)
def test_basic_inference_inputsamples(n_params=2, seed=42, n_pilot=1000):
model = Gauss(dim=n_params, seed=seed)
prior = dd.Gaussian(m=np.zeros((n_params, )),
S=np.eye(n_params),
seed=seed + 1)
s = ds.Identity(seed=seed + 2)
g = dg.Default(model=model, prior=prior, summary=s, seed=seed + 3)
obs = np.zeros((1, n_params)) # reseed generator etc. (?)
m_true, S_true = simplegaussprod(obs, model.noise_cov, prior.m, prior.S)
params, stats = g.gen(n_pilot)
pilot_samples = (params, stats)
res = infer.Basic(g, obs=obs, seed=seed + 4, pilot_samples=pilot_samples)
res.reset(seed=seed + 4)
out = res.run(n_train=1000)
posterior = res.predict(res.obs.reshape(1, -1))
check_gaussian_posterior(posterior, m_true, S_true)
def test_snpe_inference(n_params=2, seed=42):
m = Gauss(dim=n_params, seed=seed)
p = dd.Gaussian(m=np.zeros((n_params, )), S=np.eye(n_params), seed=seed)
s = ds.Identity()
g = dg.Default(model=m, prior=p, summary=s)
# observation
_, obs = g.gen(1)
# set up inference
res = infer.SNPE(g, obs=obs)
# run with N samples
out = res.run(n_train=1000, n_rounds=1)
# check result
posterior = res.predict(np.array([0., 0.]).reshape(1, -1))
assert np.allclose(posterior.xs[0].S,
np.array([[0.1, 0.0], [0.0, 0.1]]),
atol=0.05)
assert np.allclose(posterior.xs[0].m, np.array([0.0, 0.0]), atol=0.05)
