def fit_latent_simplex_v2(X, iter=20000, burn=10000, thin=10):
vars = latent_simplex_v2(X)
m = mc.MAP([vars['alpha'], vars['X_obs']])
m.fit(method='fmin_powell', verbose=1)
print vars['pi'].value
m = mc.MAP([vars['sigma'], vars['X_obs']])
m.fit(method='fmin_powell', verbose=1)
print[['%.2f' % sigma_tj.value for sigma_tj in sigma_t]
for sigma_t in vars['sigma']]
m = mc.MCMC(vars)
for alpha_t, beta_t, sigma_t in zip(m.alpha, m.beta, m.sigma):
m.use_step_method(mc.AdaptiveMetropolis, alpha_t + [beta_t])
#m.use_step_method(mc.AdaptiveMetropolis, sigma_t)
m.sample(iter, burn, thin, verbose=1)
pi = m.pi.trace()
print 'mean: ', pl.floor(m.pi.stats()['mean'] * 100. + .5) / 100.
print 'ui:\n', pl.floor(m.pi.stats()['95% HPD interval'] * 100. +
.5) / 100.
return m, pi.view(pl.recarray)
def find_re_initial_vals(vars, method, tol, verbose):
if 'hierarchy' not in vars:
return
col_map = dict([[key, i] for i,key in enumerate(vars['U'].columns)])
for reps in range(3):
for p in nx.traversal.bfs_tree(vars['hierarchy'], 'all'):
successors = vars['hierarchy'].successors(p)
if successors:
#print successors
vars_to_fit = [vars.get('p_obs'), vars.get('pi_sim'), vars.get('smooth_gamma'), vars.get('parent_similarity'),
vars.get('mu_sim'), vars.get('mu_age_derivative_potential'), vars.get('covariate_constraint')]
vars_to_fit += [vars.get('alpha_potentials')]
re_vars = [vars['alpha'][col_map[n]] for n in list(successors) + [p] if n in vars['U']]
vars_to_fit += re_vars
if len(re_vars) > 0:
mc.MAP(vars_to_fit).fit(method=method, tol=tol, verbose=verbose)
#print np.round_([re.value for re in re_vars if isinstance(re, mc.Node)], 2)
#print_mare(vars)
#print 'sigma_alpha'
vars_to_fit = [vars.get('p_obs'), vars.get('pi_sim'), vars.get('smooth_gamma'), vars.get('parent_similarity'),
vars.get('mu_sim'), vars.get('mu_age_derivative_potential'), vars.get('covariate_constraint')]
vars_to_fit += [vars.get('sigma_alpha')]
mc.MAP(vars_to_fit).fit(method=method, tol=tol, verbose=verbose)
def train(self, steps=20000, burn=10000, thin=10):
'''train the Markov Chain Monte Carlo to estimate the parameters (b, c) in
mean pt loss and (a,) in pt loss distribution.
Args:
steps (int): total number of Metropolis-Hastings random walk steps in the parameter space
default: 200000 steps
burn (int): number of steps that are not used for final statistics; the estimated number
of steps for the MCMC to converge, default: 100000 steps
thin (int): skipping number of steps to avoid auto-correlation, for final analysis.
The auto-correlation comes from Markov Chain (the next step in parameter space
is proposed using normal distribution whose mean is the current step).
Updated:
self.mdl_: MCMC model, which can be accessed by function self.get_mcmc_model()
self.a (1d np.array): the trace of 'a' in the parameter space,
self.b (1d np.array): the trace of 'b' in the parameter space,
self.c (1d np.array): the trace of 'c' in the parameter space,
'''
raa_map = pm.MAP(
self.__model__(self.RAA_x, self.RAA_y, self.RAA_xerr,
self.RAA_yerr))
raa_map.fit(iterlim=20000, tol=0.01)
self.mdl_ = pm.MCMC(raa_map.variables)
self.mdl_.sample(steps, burn, thin, verbose=0)
self.a = self.mdl_.trace('a')[...]
self.b = self.mdl_.trace('b')[...]
self.c = self.mdl_.trace('c')[...]
def plot(self):
mc_map = pm.MAP(self.mc)
mc_map.fit(tol=.01)
# iterlim = 250,
print("BIC score: {}".format(mc_map.BIC))
plot(self.mc)
# set years and months
years = mdates.YearLocator() # every year
months = mdates.MonthLocator() # every month
years_fmt = mdates.DateFormatter('%Y')
fig, ax = plt.subplots()
# plot the data
ax.plot(months_list,
confirmed_cases,
'o',
mec='black',
color='black',
label='confirmed cases')
ax.plot(months_list,
mortalitysim.stats()['mean'],
color='red',
linewidth=1,
label='MIH (mean)')
y_min = mortalitysim.stats()['quantiles'][2.5]
y_max = mortalitysim.stats()['quantiles'][97.5]
ax.fill_between(months_list,
y_min,
y_max,
color='r',
alpha=0.3,
label='BPL (95% CI)')
# format the ticks
ax.xaxis.set_major_locator(years)
ax.xaxis.set_major_formatter(years_fmt)
ax.xaxis.set_minor_locator(months)
# set the axis limit
datemin = min(months_list) - 1
datemax = max(months_list) + 1
ax.set_xlim(datemin, datemax)
# format the coords message box
def price(x):
return '$%1.2f' % x
ax.format_xdata = mdates.DateFormatter('%Y-%m-%d')
ax.format_ydata = price
ax.grid(True)
# rotates and right aligns the x labels, and moves the bottom of the
# axes up to make room for them
fig.autofmt_xdate()
# some extra plot formating
ax.legend(loc='best')
plt.style.use('ggplot')
plt.rc('font', size=12)
plt.rc('lines', linewidth=2)
plt.title("Plague model fit to laboratory confirmed cases")
plt.xlabel('Time in months')
plt.ylabel('Number of infecteds')
plt.legend()
plt.savefig(self.dir.split("\\")[-1] + '_fit.png')
def __init__(self, sim, params, database=None, overwrite=False):
self.sim = sim
self.params = params
self.model_dict = self.make_model_dict(self.sim, dict(self.params))
self.MAP = pymc.MAP(self.model_dict)
self.dbname = database
if self.dbname is None:
self.MCMC = pymc.MCMC(self.MAP.variables)
else:
base, ext = os.path.splitext(self.dbname)
self.dbtype = ext[1:]
if os.path.exists(self.dbname) and overwrite:
print("Overwriting %s" % self.dbname)
os.remove(self.dbname)
self.MCMC = pymc.MCMC(self.MAP.variables,
db=self.dbtype,
dbname=self.dbname)
if self.MCMC.db.chains > 0:
self.set_mu()
self.MCMCparams = {}
self.number_of_bins = 200
def MAP_run(outname=None):
'''Find Maximum a posteriori distribution'''
tic = time.time()
M = pm.MAP(Bayes_model, prior_eps)
print('Fitting....')
M.fit()
# Return statistics
print('Estimate complete. Time elapsed: {}'.format(time.time() - tic))
print('Free stochastic variables: {}'.format(M.len))
print('Joint log-probability of model: {}'.format(M.logp))
print('Max joint log-probability of model: {}'.format(M.logp_at_max))
print('Maximum log-likelihood: {}'.format(M.lnL))
print("Akaike's Information Criterion {}".format(M.AIC), flush=True)
print('---------------Variable estimates---------------')
for var in Bayes_model.stochastics:
print('{} = {}'.format(var, var.value))
# Save result to file
if outname is None:
outname = 'Max_aPosteriori_Estimate.txt'
with open(outname, 'w') as fobj:
fobj.write('Time elapsed: {}\n'.format(time.time() - tic))
fobj.write('Free stochastic variables: {}\n'.format(M.len))
fobj.write('Joint log-probability of model: {}\n'.format(M.logp))
fobj.write('Max joint log-probability of model: {}\n'.format(
M.logp_at_max))
fobj.write('Maximum log-likelihood: {}\n'.format(M.lnL))
fobj.write("Akaike's Information Criterion {}\n".format(M.AIC))
fobj.write('---------------Variable estimates---------------\n')
for var in Bayes_model.stochastics:
fobj.write('{} = {}\n'.format(var, var.value))
print('Result saved to {}.'.format(outname))
return M
def map(self, runs=2, warn_crit=5, method='fmin_powell', **kwargs):
"""
Find MAP and set optimized values to nodes.
:Arguments:
runs : int
How many runs to make with different starting values
warn_crit: float
How far must the two best fitting values be apart in order to print a warning message
:Returns:
pymc.MAP object of model.
:Note:
Forwards additional keyword arguments to pymc.MAP().
"""
from operator import attrgetter
# I.S: when using MAP with Hierarchical model the subjects nodes should be
# integrated out before the computation of the MAP (see Pinheiro JC, Bates DM., 1995, 2000).
# since we are not integrating we get a point estimation for each
# subject which is not what we want.
if self.is_group_model:
raise NotImplementedError(
"""Sorry, This method is not yet implemented for group models.
you might consider using the approximate_map method""")
maps = []
for i in range(runs):
# (re)create nodes to get new initival values.
#nodes are not created for the first iteration if they already exist
self.mc = pm.MAP(self.nodes_db.node)
if i != 0:
self.draw_from_prior()
self.mc.fit(method, **kwargs)
print self.mc.logp
maps.append(self.mc)
self.mc = None
# We want to use values of the best fitting model
sorted_maps = sorted(maps, key=attrgetter('logp'))
max_map = sorted_maps[-1]
# If maximum logp values are not in the same range, there
# could be a problem with the model.
if runs >= 2:
abs_err = np.abs(sorted_maps[-1].logp - sorted_maps[-2].logp)
if abs_err > warn_crit:
print "Warning! Two best fitting MAP estimates are %f apart. Consider using more runs to avoid local minima." % abs_err
# Set values of nodes
for max_node in max_map.stochastics:
self.nodes_db.node.ix[max_node.__name__].set_value(max_node.value)
return max_map
def fit(self, how='mcmc', iter=10000, burn=5000, thin=5):
""" Fit the model
:Parameters:
- `how` : str, 'mcmc' or 'map'
'mcmc' is slower but provides uncertainty estimates
- iter, burn, thin : int
mcmc options
:Notes:
This must come after a call to .setup_model.
"""
from . import fit
if 'rate_type' in self.model_settings:
rate_type=self.model_settings['rate_type']
if how=='mcmc':
self.map, self.mcmc = fit.asr(
self, rate_type,
iter=iter, burn=burn, thin=thin)
elif how=='map':
self.map = mc.MAP(self.vars[rate_type])
fit.find_asr_initial_vals(
self.vars[rate_type], 'fmin_powell', tol=1e-3, verbose=0)
self.map.fit(method='fmin_powell')
elif 'consistent' in self.model_settings:
if how=='mcmc':
self.map, self.mcmc = fit.consistent(
self,
iter=iter, burn=burn, thin=thin)
elif how=='map':
raise NotImplementedError('not yet implemented')
else:
raise NotImplementedError('Need to call .setup_model before calling fit.')
def map_fit(pymc_model):
"""
Find the maximum a posteriori (MAP) fit.
Parameters
----------
pymc_model : pymc model
The pymc model to sample.
Returns
-------
map : pymc.MAP
The MAP fit.
"""
map = pymc.MAP(pymc_model)
ncycles = 50
# DEBUG
ncycles = 5
for cycle in range(ncycles):
if (cycle + 1) % 5 == 0:
print('MAP fitting cycle %d/%d' % (cycle + 1, ncycles))
map.fit()
return map
def map_estimate(self, iterations=2000):
"""
Compute the Maximum A Posteriori estimates for the initialised model
"""
self.map = mc.MAP(self.model)
self.map.fit(iterlim=iterations, tol=1e-3)
def mcmcSimulations(temperature, failures):
'''Perform the MCMC-simulations'''
# Define the prior distributions for alpha and beta
# 'value' sets the start parameter for the simulation
# The second parameter for the normal distributions is the "precision",
# i.e. the inverse of the standard deviation
np.random.seed(1234)
beta = pm.Normal("beta", 0, 0.001, value=0)
alpha = pm.Normal("alpha", 0, 0.001, value=0)
# Define the model-function for the temperature
@pm.deterministic
def p(t=temperature, alpha=alpha, beta=beta):
return 1.0 / (1. + np.exp(beta * t + alpha))
# connect the probabilities in `p` with our observations through a
# Bernoulli random variable.
observed = pm.Bernoulli("bernoulli_obs", p, value=failures, observed=True)
# Combine the values to a model
model = pm.Model([observed, beta, alpha])
# Perform the simulations
map_ = pm.MAP(model)
map_.fit()
mcmc = pm.MCMC(model)
mcmc.sample(120000, 100000, 2)
# --- Show the resulting posterior distributions ---
alpha_samples = mcmc.trace('alpha')[:, None] # best to make them 1d
beta_samples = mcmc.trace('beta')[:, None]
return (alpha_samples, beta_samples)
def Main():
# Plot Raw Data
plot_raw(challenger_data)
# Calculate observed values
observed = pm.Bernoulli("bernoulli_obs", p, value=D, observed=True)
# Create and sample from model
model = pm.Model([observed, beta, alpha])
# Once again, this code will be explored next chapter
map_ = pm.MAP(model)
map_.fit()
mcmc = pm.MCMC(model)
mcmc.sample(120000, 100000, 2)
alpha_samples = mcmc.trace('alpha')[:, None] # best to make them 1d
beta_samples = mcmc.trace('beta')[:, None]
# Do some plotting
plot_posterior(alpha_samples, beta_samples)
t = np.linspace(temperature.min() - 5, temperature.max() + 5, 50)[:, None]
p_t = logistic(t.T, beta_samples, alpha_samples)
mean_prob_t = p_t.mean(axis=0)
# vectorized bottom and top 2.5% quantiles for credible interval
qs = mquantiles(p_t, [0.025, 0.975], axis=0)
plot_against_data(t, mean_prob_t, qs)
plot_t_31(alpha_samples, beta_samples)
def record_parameters_and_probabilities(df, model):
# set up empty slots for our upcoming values
# but only we havent already
try:
df.alpha_param[0]
except AttributeError:
df['alpha_param'] = np.nan
df['beta_param'] = np.nan
df['cdf'] = np.nan
df['one_minus_cdf'] = np.nan
df['one_minus_cdf_BH'] = np.nan
df['MAP_succeeded'] = False
# set up a mask for this distance_bin
bin_mask = df.distance_bin == model.bin_id_tag
# perform Max A Posteriori
model_runner = mc.MAP(model)
# Parameter names for access through the model
a_name = "{bin_id}_alpha".format(bin_id=model.bin_id_tag)
b_name = "{bin_id}_beta".format(bin_id=model.bin_id_tag)
try:
# if we can take the short cut, great!
model_runner.fit()
model.MCMC_run = False
except RuntimeError as exc:
if "Posterior probability optimization converged to value with zero probability." in exc.message:
# Otherwise lets run the MCMC experiment
model_runner = mc.MCMC(model)
model.MCMC_run = model_runner
# re-initialize the alpha and beta starting values randomly
# to avoid non-allowed values that seem to slip in from the MAP.fit()
current_alpha, current_beta = model.get_node(
a_name), model.get_node(b_name)
current_alpha.random()
current_beta.random()
# do the learning
model_runner.sample(iter=40000, burn=20000, thin=1)
# get and store parameters
alpha, beta = model.get_node(a_name), model.get_node(b_name)
df[bin_mask].alpha_param = alpha.value.item()
df[bin_mask].beta_param = beta.value.item()
# get and store probabilities
# Record the probabilities of obtaining each R2 value (or smaller) in the bin afer scaling
df.loc[bin_mask,
'cdf'] = scipy.stats.beta.cdf(df[bin_mask].R2_scaled_for_B,
alpha.value.item(), beta.value.item())
df.loc[bin_mask, 'one_minus_cdf'] = 1 - df[bin_mask]['cdf']
df.loc[bin_mask,
'one_minus_cdf_BH'] = smm.multipletests(df[bin_mask].one_minus_cdf,
method='fdr_bh')[1]
def fit_linear():
vars = linear()
mc.MAP(vars).fit(method='fmin_powell')
m = mc.MCMC(vars)
m.sample(iter=10000, burn=5000, thin=5)
return m
def get_logp(S, model):
"""compute log(p) given a pyMC model"""
M = pymc.MAP(model)
traces = np.array([S.trace(s)[:] for s in S.stochastics])
logp = np.zeros(traces.shape[1])
for i in range(len(logp)):
logp[i] = -M.func(traces[:, i])
return logp
def ICs(self):
self.MAP = pymc.MAP(self.M)
self.MAP.fit()
self.BIC = self.MAP.BIC
self.AIC = self.MAP.AIC
self.logp = self.MAP.logp
self.logp_at_max = self.MAP.logp_at_max
return self.AIC, self.BIC
def test_binom():
""" Fit a binomial model to a single row of data, confirm the mean
and std dev are as expected"""
pi = mc.Uniform('pi', lower=0, upper=1)
obs = dismod_mr.model.likelihood.binom('prevalence', pi, [.5], [10])
mc.MAP([pi, obs]).fit()
assert np.allclose(pi.value, .5, rtol=.01)
def compute_logp(S, model):
#From astroml, computes the log(p)s for a MCMC model:
M = pymc.MAP(model)
traces = np.array([S.trace(s)[:] for s in S.stochastics])
logp = np.zeros(traces.shape[1])
#Compute the log(p) at every coordinate of the traces:
for i in range(len(logp)):
logp[i] = -M.func(traces[:, i])
return logp
def pubBModeResidual(data = None):
if data is None:
data = {}
if 'bmodes' not in data:
data['bmodes'] = cPickle.load(open('bmodes.pkl', 'rb'))
bmodes = data['bmodes']
xdelta = np.arange(-1.5, 1.5, 0.001)
if 'vsigma' not in data:
gsigma = np.std(bmodes)
vmodel = sd.VoigtModel(None, None, bmodes, np.zeros_like(bmodes))
map = pymc.MAP(vmodel)
map.fit()
vsigma = map.sigma.value
vgamma = map.gamma.value
data['vsigma'] = vsigma
data['vgamma'] = vgamma
data['gsigma'] = gsigma
else:
vsigma = data['vsigma']
vgamma = data['vgamma']
gsigma = data['gsigma']
fig = pylab.figure()
ax = fig.add_axes([0.12, 0.12, 0.95 - 0.12, 0.95 - 0.12])
hist, edges, patches = ax.hist(bmodes, bins = 151, range=(-1.5, 1.5), log=True, normed=True, label='B-Modes from 27 Cluster Fields', histtype='step', color='k')
ax.plot(xdelta, vtools.voigtProfile(xdelta, vsigma, vgamma), 'r-', label='Voigt Model', linewidth=1.5)
ax.plot(xdelta, gaussprofile(xdelta, gsigma), 'b-.', label='Gaussian Model', linewidth=1.5)
ax.set_ylim(5e-5, 1e1)
ax.set_ylabel(r'$P(g_X)$')
ax.set_xlabel(r'Shear B-mode $g_X$')
ax.legend(loc='lower center', numpoints=1)
fig.savefig('publication/data_bmode_scatter.eps')
return fig, data
def fe(data):
""" Fixed Effect model::
Y_r,c,t = beta * X_r,c,t + e_r,c,t
e_r,c,t ~ N(0, sigma^2)
"""
# covariates
K1 = count_covariates(data, 'x')
X = pl.array([data['x%d' % i] for i in range(K1)])
K2 = count_covariates(data, 'w')
W = pl.array([data['w%d' % i] for i in range(K1)])
# priors
beta = mc.Uninformative('beta', value=pl.zeros(K1))
gamma = mc.Uninformative('gamma', value=pl.zeros(K2))
sigma_e = mc.Uniform('sigma_e', lower=0, upper=1000, value=1)
# predictions
@mc.deterministic
def mu(X=X, beta=beta):
return pl.dot(beta, X)
param_predicted = mu
@mc.deterministic
def sigma_explained(W=W, gamma=gamma):
""" sigma_explained_i,r,c,t,a = gamma * W_i,r,c,t,a"""
return pl.dot(gamma, W)
@mc.deterministic
def predicted(mu=mu, sigma_explained=sigma_explained, sigma_e=sigma_e):
return mc.rnormal(mu, 1 / (sigma_explained**2. + sigma_e**2.))
# likelihood
i_obs = pl.find(1 - pl.isnan(data.y))
@mc.observed
def obs(value=data.y,
i_obs=i_obs,
mu=mu,
sigma_explained=sigma_explained,
sigma_e=sigma_e):
return mc.normal_like(value[i_obs], mu[i_obs],
1. / (sigma_explained[i_obs]**2. + sigma_e**-2.))
# set up MCMC step methods
mod_mc = mc.MCMC(vars())
mod_mc.use_step_method(mc.AdaptiveMetropolis, mod_mc.beta)
# find good initial conditions with MAP approx
print 'attempting to maximize likelihood'
var_list = [mod_mc.beta, mod_mc.obs, mod_mc.sigma_e]
mc.MAP(var_list).fit(method='fmin_powell', verbose=1)
return mod_mc
def compute_MCMC_results(niter=20000, burn=2000):
S = pymc.MCMC(model)
S.sample(iter=niter, burn=burn)
traces = [S.trace(s)[:] for s in ['b0', 'A', 'omega', 'beta']]
M = pymc.MAP(model)
M.fit()
fit_vals = (M.b0.value, M.beta.value, M.A.value, M.omega.value)
return traces, fit_vals
def map_fit(stoch_names):
print '\nfitting', ' '.join(stoch_names)
map = mc.MAP([dm.vars[key] for key in stoch_names] + [dm.vars['observed_counts'], dm.vars['rate_potential'], dm.vars['priors']])
try:
map.fit(method='fmin_powell', verbose=verbose)
except KeyboardInterrupt:
debug('User halted optimization routine before optimal value found')
for key in stoch_names:
print key, dm.vars[key].value.round(2)
sys.stdout.flush()
def compute_MCMC_results(niter=25000, burn=4000):
S = pymc.MCMC(model)
S.sample(iter=niter, burn=burn)
traces = [S.trace(s)[:] for s in ['b0', 'A', 'T', 'alpha']]
M = pymc.MAP(model)
M.fit()
fit_vals = (M.b0.value, M.A.value, M.alpha.value, M.T.value)
return traces, fit_vals
def reset(self, params):
# this doesn't work
self.sim = deepcopy(self.original_sim)
self.model_dict = self.make_model_dict(self.sim, params)
self.params = params
self.MAP = pymc.MAP(self.model_dict)
self.MCMC = pymc.MCMC(self.MAP.variables)
return self.sim
def sample_emcee(model=None, nwalkers=500, samples=1000, burn=500, thin=10):
import pymc.progressbar as pbar
# This is the likelihood function for emcee
def lnprob(vals):
try:
for val, var in zip(vals, model.stochastics):
var.value = val
return model.logp
except mc.ZeroProbability:
return -1 * inf
# emcee parameters
ndim = len(model.stochastics)
# Find MAP
mc.MAP(model).fit()
start = empty(ndim)
for i, var in enumerate(model.stochastics):
start[i] = var.value
# sample starting points for walkers around the MAP
p0 = random.randn(ndim * nwalkers).reshape((nwalkers, ndim)) + start
# instantiate sampler passing in the pymc likelihood function
sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob)
bar = pbar.progress_bar(burn + samples)
i = 0
# burn-in
for pos, prob, state in sampler.sample(p0, iterations=burn):
i += 1
bar.update(i)
sampler.reset()
# sample
try:
for p, lnprob, lnlike in sampler.sample(pos,
iterations=samples,
thin=thin):
i += 1
bar.update(i)
# except KeyboardInterrupt:
# pass
finally:
print("\nMean acceptance fraction during sampling: {}".format(
mean(sampler.acceptance_fraction)))
mcmc = mc.MCMC(model) # MCMC instance for model
mcmc.sample(1, progress_bar=False) # This call is to set up the chains
for i, var in enumerate(model.stochastics):
var.trace._trace[0] = sampler.flatchain[:, i]
return mcmc
def reset(self, params):
raise ValueError('not implemented yet')
# this doesn't work
self.sim = deepcopy(self.original_sim)
self.model_dict = self.make_model_dict(self.sim, params)
self.params = params
self.MAP = pymc.MAP(self.model_dict)
self.MCMC = pymc.MCMC(self.MAP.variables)
return self.sim
def _get_samples(self):
'''set the Markov chain Monte Carlo with specified
No. of iterations, burn-in length and thinning'''
iterations = self.mcmc_iterations
burn_in = self.mcmc_burn_in
thinning = self.mcmc_thinning
map_ = pymc.MAP(self.model)
map_.fit()
sampling_engine = pymc.MCMC(self.model)
sampling_engine.sample(iter=iterations, burn=burn_in, thin=thinning)
return sampling_engine
def find_spline_initial_vals(vars, method, tol, verbose):
## generate initial value by fitting knots sequentially
vars_to_fit = [vars.get('p_obs'), vars.get('pi_sim'), vars.get('smooth_gamma'), vars.get('parent_similarity'),
vars.get('mu_sim'), vars.get('mu_age_derivative_potential'), vars.get('covariate_constraint')]
for i, n in enumerate(vars['gamma']):
if verbose:
print('fitting first %d knots of %d' % (i+1, len(vars['gamma'])))
vars_to_fit.append(n)
mc.MAP(vars_to_fit).fit(method=method, tol=tol, verbose=verbose)
if verbose:
print_mare(vars)
def test_beta_binom_2():
""" Fit a fast beta binomial model to a single row of data, confirm the mean
and std dev are as expected"""
pi = mc.Uniform('pi', lower=0, upper=1, size=2)
obs = dismod_mr.model.likelihood.beta_binom_2('prevalence', pi,
np.array([1, 1]),
np.array([.5, .5]),
np.array([10, 10]))
mc.MAP([pi, obs]).fit()
assert np.allclose(pi.value, .5, rtol=.01)
def find_dispersion_initial_vals(vars, method, tol, verbose):
vars_to_fit = [
vars.get('p_obs'),
vars.get('pi_sim'),
vars.get('smooth_gamma'),
vars.get('parent_similarity'),
vars.get('mu_sim'),
vars.get('mu_age_derivative_potential'),
vars.get('covariate_constraint')
]
vars_to_fit += [vars.get('eta'), vars.get('zeta')]
mc.MAP(vars_to_fit).fit(method=method, tol=tol, verbose=verbose)
