def oneway_banova(y,X):
# X is a design matrix with a 1 one where factor is present
with Model() as banova:
sigma = Uniform('SD lowest', lower=0,upper=10)
sd_prior = pm.Gamma('SD Prior', 1.01005, 0.1005)
offset = Normal('offset', mu=0, tau=0.001)
alphas = Normal('alphas', mu=0.0, sd=sd_prior, shape=X.shape[0])
betas = alphas - alphas.mean()
betas = Deterministic('betas', betas)
data = Normal('data', mu= offset + Tns.dot(X.T, betas),
sd=sigma, observed=y)
return banova
def appc_gamma_model(
y,
observer,
ambiguity_regressor,
context,
observed=True):
'''
Hierarchical Gamma model to predict APPC data.
'''
num_obs_ctxt = len(np.unique(observer[context == 1]))
num_obs_noctxt = len(np.unique(observer[context == 0]))
obs = [num_obs_noctxt, num_obs_ctxt]
with Model() as pl:
# Population level:
obs_ambiguity = Normal(
'DNP Mean_Ambiguity', mu=0, sd=500.0, shape=2)
# Define variable for sd of data distribution:
data_sd = pm.Gamma('Data_SD', *gamma_params(mode=y.std(), sd=y.std()))
for ctxt, label in zip([1, 0], ['context', 'nocontext']):
obs_offset = Normal('DNP Mean_Offset_' + label, mu=y.mean(),
sd=y.std() * 1.0)
obs_sd_offset = Gamma('Mean_Offset_SD' + label, *gamma_params(mode=y.std(), sd=y.std()))
# Observer level:
offset = Normal(
'DNP Offset_' + label, mu=obs_offset, sd=obs_sd_offset,
shape=(obs[ctxt],))
# Compute predicted mode for each fixation:
data = y[context == ctxt]
obs_c = observer[context == ctxt]
ambig_reg_c = ambiguity_regressor[context == ctxt]
b0 = obs_ambiguity.mean()
obs_ambiguity_transformed = Deterministic("DNS Population Ambiguity" +label , obs_ambiguity-b0 )
offset_transformed = Deterministic('DNS Subject Offsets ' + label, offset+b0)
obs_offset_transformed = Deterministic('DNS Population Offsets ' + label, obs_offset+b0)
oat = obs_ambiguity - b0
# Dummy coding
mode = (
offset_transformed[obs_c] +
obs_ambiguity_transformed[ambig_reg_c == 1])
# Convert to shape rate parameterization
shape, rate = gamma_params(mode, data_sd)
data_dist = Gamma('Data_' + label, shape, rate, observed=data)
return pl
def gamma_model_2conditions(y, x, observer, condition, observed=True):
'''
Hierarchical Gamma model to predict fixation durations.
'''
# Different slopes for different observers.
num_observer = len(np.unique(observer))
print '\n Num Observers: %d \n' % num_observer
with Model() as pl:
obs_splits = TruncatedNormal(
'Mean_Split', mu=90,
sd=500, lower=5, upper=175)
obs_offset = Normal('Mean_Offset', mu=y.mean(), sd=y.std()*10.0)
obs_slopes1 = Normal('Mean_Slope1', mu=0.0, sd=1.0)
obs_slopes2 = Normal('Mean_Slope2', mu=0, sd=1.0)
obs_sd_split = pm.Gamma(
'Obs_SD_Split', *gamma_params(mode=1.0, sd=100.0))
obs_sd_intercept = pm.Gamma(
'Obs_SD_Offset', *gamma_params(mode=1, sd=100.))
obs_sd_slopes1 = pm.Gamma(
'Obs_SD_slope1', *gamma_params(mode=.01, sd=2.01))
obs_sd_slopes2 = pm.Gamma(
'Obs_SD_slope2', *gamma_params(mode=.01, sd=2.01))
data_sd = pm.Gamma('Data_SD', *gamma_params(mode=y.std(), sd=y.std()))
split = TruncatedNormal(
'Split', mu=obs_splits, sd=obs_sd_split,
lower=5, upper=175, shape=(num_observer,))
intercept = Normal(
'Offset', mu=obs_offset, sd=obs_sd_intercept,
shape=(num_observer,))
slopes1 = Normal(
'Slope1', mu=obs_slopes1, sd=obs_sd_slopes1,
shape=(num_observer,))
slopes2 = Normal(
'Slope2', mu=obs_slopes2, sd=obs_sd_slopes2,
shape=(num_observer,))
# Now add the condition part
#
split_cond = Normal(
'Cond_Split', mu=0, sd=10, shape=(2,))
intercept_cond = Normal(
'Cond_Offset', mu=0, sd=20,
shape=(2,))
slopes1_cond = Normal(
'Cond_Slope1', mu=0, sd=1,
shape=(2,))
slopes2_cond = Normal(
'Cond_Slope2', mu=0, sd=1,
shape=(2,))
intercept_cond = intercept_cond - intercept_cond.mean()
split_cond = split_cond - split_cond.mean()
slopes1_cond = slopes1_cond - slopes1_cond.mean()
slopes2_cond = slopes2_cond - slopes2_cond.mean()
mu_sub = piecewise_predictor(
x,
split[observer] + split_cond[condition],
intercept[observer] + intercept_cond[condition],
slopes1[observer] + slopes1_cond[condition],
slopes2[observer] + slopes2_cond[condition]
)
shape, rate = gamma_params(mu_sub, data_sd)
data = Gamma('Data', shape, rate, observed=y)
return pl
