def _create_stochastic_knodes_info(self, include):
knodes = OrderedDict()
if 'a' in include:
knodes.update(
self._create_family_gamma_gamma_hnormal('a',
g_mean=1.5,
g_std=0.75,
std_std=2,
std_value=0.1,
value=1))
if 'v' in include:
knodes.update(
self._create_family_normal_normal_hnormal('v',
value=2,
g_mu=2,
g_tau=3**-2,
std_std=2))
if 't' in include:
knodes.update(
self._create_family_gamma_gamma_hnormal('t',
g_mean=.4,
g_std=0.2,
value=0.001,
std_std=1,
std_value=0.2))
if 'sv' in include:
knodes['sv_bottom'] = Knode(pm.HalfNormal,
'sv',
tau=2**-2,
value=1,
depends=self.depends['sv'])
if 'sz' in include:
knodes['sz_bottom'] = Knode(pm.Beta,
'sz',
alpha=1,
beta=3,
value=0.01,
depends=self.depends['sz'])
if 'st' in include:
knodes['st_bottom'] = Knode(pm.HalfNormal,
'st',
tau=0.3**-2,
value=0.001,
depends=self.depends['st'])
if 'z' in include:
knodes.update(
self._create_family_invlogit('z',
value=.5,
g_tau=0.5**-2,
std_std=0.05))
if 'p_outlier' in include:
knodes['p_outlier_bottom'] = Knode(
pm.Beta,
'p_outlier',
alpha=1,
beta=15,
value=0.01,
depends=self.depends['p_outlier'])
return knodes
def _create_family_trunc_normal(self, name, value=0, lower=None,
upper=None, std_lower=1e-10,
std_upper=100, std_value=.1):
"""Similar to _create_family_normal() but creates a Uniform
group distribution and a truncated subject distribution.
See _create_family_normal() help for more information.
"""
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g = Knode(pm.Uniform, '%s' % name, lower=lower,
upper=upper, value=value, depends=self.depends[name])
std = Knode(pm.Uniform, '%s_std' % name, lower=std_lower,
upper=std_upper, value=std_value)
tau = Knode(pm.Deterministic, '%s_tau' % name,
doc='%s_tau' % name, eval=lambda x: x**-2, x=std,
plot=False, trace=False, hidden=True)
subj = Knode(pm.TruncatedNormal, '%s_subj' % name, mu=g,
tau=tau, a=lower, b=upper, value=value,
depends=('subj_idx',), subj=True, plot=self.plot_subjs)
knodes['%s'%name] = g
knodes['%s_std'%name] = std
knodes['%s_tau'%name] = tau
knodes['%s_bottom'%name] = subj
else:
subj = Knode(pm.Uniform, name, lower=lower,
upper=upper, value=value,
depends=self.depends[name])
knodes['%s_bottom'%name] = subj
return knodes
def _create_family_normal_normal_hnormal(self, name, value=0, g_mu=None,
g_tau=15**-2, std_std=2,
std_value=.1):
"""Create a family of knodes. A family is a group of knodes
that belong together.
For example, a family could consist of the following distributions:
* group mean g_mean (Normal(g_mu, g_tau))
* group standard deviation g_std (Uniform(std_lower, std_upper))
* transform node g_std_trans for g_std (x -> x**-2)
* subject (Normal(g_mean, g_std_trans))
In fact, if is_group_model is True and the name does not appear in
group_only nodes, this is the family that will be created.
Otherwise, only a Normal knode will be returned.
:Arguments:
name : str
Name of the family. Each family member will have this name prefixed.
:Optional:
value : float
Starting value.
g_mu, g_tau, std_lower, std_upper, std_value : float
The hyper parameters for the different family members (see above).
:Returns:
OrderedDict: member name -> member Knode
"""
if g_mu is None:
g_mu = value
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g = Knode(pm.Normal, '%s' % name, mu=g_mu, tau=g_tau,
value=value, depends=self.depends[name])
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(pm.HalfNormal, '%s_std' % name, tau=std_std**-2,
value=std_value, depends=depends_std)
tau = Knode(pm.Deterministic, '%s_tau' % name,
doc='%s_tau' % name, eval=lambda x: x**-2, x=std,
plot=False, trace=False, hidden=True)
subj = Knode(pm.Normal, '%s_subj' % name, mu=g, tau=tau,
value=value, depends=('subj_idx',),
subj=True, plot=self.plot_subjs)
knodes['%s'%name] = g
knodes['%s_std'%name] = std
knodes['%s_tau'%name] = tau
knodes['%s_bottom'%name] = subj
else:
subj = Knode(pm.Normal, name, mu=g_mu, tau=g_tau,
value=value, depends=self.depends[name])
knodes['%s_bottom'%name] = subj
return knodes
def _create_stochastic_knodes_noninfo(self, include):
knodes = OrderedDict()
if 'a' in include:
knodes.update(
self._create_family_trunc_normal('a',
lower=1e-3,
upper=1e3,
value=1))
if 'v' in include:
knodes.update(
self._create_family_normal_normal_hnormal('v',
value=0,
g_tau=50**-2,
std_std=10))
if 't' in include:
knodes.update(
self._create_family_trunc_normal('t',
lower=1e-3,
upper=1e3,
value=.01))
if 'sv' in include:
knodes['sv_bottom'] = Knode(pm.Uniform,
'sv',
lower=1e-6,
upper=1e3,
value=1,
depends=self.depends['sv'])
if 'sz' in include:
knodes['sz_bottom'] = Knode(pm.Beta,
'sz',
alpha=1,
beta=1,
value=0.01,
depends=self.depends['sz'])
if 'st' in include:
knodes['st_bottom'] = Knode(pm.Uniform,
'st',
lower=1e-6,
upper=1e3,
value=0.01,
depends=self.depends['st'])
if 'z' in include:
knodes.update(
self._create_family_invlogit('z',
value=.5,
g_tau=10**-2,
std_std=0.5))
if 'p_outlier' in include:
knodes['p_outlier_bottom'] = Knode(
pm.Beta,
'p_outlier',
alpha=1,
beta=1,
value=0.01,
depends=self.depends['p_outlier'])
return knodes
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(self.wfpt_nn_class,
'wfpt',
observed=True,
col_name=['nn_response', 'rt'],
**wfpt_parents)
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(self.rl_class,
'wfpt',
observed=True,
col_name=['split_by', 'feedback', 'response', 'q_init'],
**wfpt_parents)
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(self.rl_class,
"wfpt",
observed=True,
col_name=["split_by", "feedback", "response", "q_init"],
**wfpt_parents)
def _create_family_exp(self, name, value=0, g_mu=None,
g_tau=15**-2, std_lower=1e-10, std_upper=100, std_value=.1):
"""Similar to create_family_normal() but adds an exponential
transform knode to the subject and group mean nodes. This is useful
when the parameter space is restricted from [0, +oo).
See create_family_normal() help for more information.
"""
if g_mu is None:
g_mu = value
value_trans = np.log(value)
g_mu_trans = np.log(g_mu)
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g_trans = Knode(pm.Normal, '%s_trans' % name, mu=g_mu_trans,
tau=g_tau, value=value_trans,
depends=self.depends[name], plot=False, hidden=True)
g = Knode(pm.Deterministic, '%s'%name, eval=lambda x: np.exp(x),
x=g_trans, plot=True)
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(pm.Uniform, '%s_std' % name, lower=std_lower, upper=std_upper,
value=std_value, depends=depends_std)
tau = Knode(pm.Deterministic, '%s_tau' % name, eval=lambda x: x**-2,
x=std, plot=False, trace=False, hidden=True)
subj_trans = Knode(pm.Normal, '%s_subj_trans'%name, mu=g_trans,
tau=tau, value=value_trans, depends=('subj_idx',),
subj=True, plot=False, hidden=True)
subj = Knode(pm.Deterministic, '%s_subj'%name, eval=lambda x: np.exp(x),
x=subj_trans,
depends=('subj_idx',), plot=self.plot_subjs,
trace=True, subj=True)
knodes['%s_trans'%name] = g_trans
knodes['%s'%name] = g
knodes['%s_std'%name] = std
knodes['%s_tau'%name] = tau
knodes['%s_subj_trans'%name] = subj_trans
knodes['%s_bottom'%name] = subj
else:
g_trans = Knode(pm.Normal, '%s_trans' % name, mu=g_mu_trans,
tau=g_tau, value=value_trans,
depends=self.depends[name], plot=False, hidden=True)
g = Knode(pm.Deterministic, '%s'%name, doc='%s'%name, eval=lambda x: np.exp(x), x=g_trans, plot=True)
knodes['%s_trans'%name] = g_trans
knodes['%s_bottom'%name] = g
return knodes
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(self.wfpt_class,
'wfpt',
observed=True,
col_name='rt',
**wfpt_parents)
def create_lba_knode(self, knodes):
lba_parents = OrderedDict()
lba_parents['t'] = knodes['t_bottom']
lba_parents['A'] = knodes['A_bottom']
lba_parents['b'] = knodes['b_bottom']
lba_parents['s'] = knodes['s_bottom']
lba_parents['v'] = knodes['v_bottom']
return Knode(lba_like, 'lba', observed=True, col_name='rt', **lba_parents)
def _create_pro_knode(self, knodes):
parents = OrderedDict()
parents['t'] = knodes['t_bottom']
parents['a'] = knodes['a_bottom']
parents['v_pro'] = knodes['v_pro_bottom']
return Knode(likelihoods.wald_pro_like,
'pro',
observed=True,
col_name=['rt', 'cond'],
**parents)
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(
self.wfpt_nn,
"wfpt",
observed=True,
col_name=[
"response",
"rt",
], # TODO: One could preprocess at initialization
**wfpt_parents)
def _create_anti_knode(self, knodes):
parents = OrderedDict()
for name, knode in knodes.iteritems():
if name.endswith('_bottom'):
parents[name[:-7]] = knode
anti_like = likelihoods.gen_pda_stochastic(gen_func=self.gen_data_anti)
return Knode(anti_like,
'anti',
observed=True,
col_name=['rt', 'cond'],
**parents)
def create_knodes(self):
if self.is_group_model:
mu_g = Knode(pm.Uniform,
'mu_g',
lower=-5,
upper=5,
depends=self.depends['mu'])
mu_subj = Knode(pm.Normal,
'mu_subj',
mu=mu_g,
tau=1,
depends=('subj_idx', ),
subj=True)
like = Knode(pm.Normal,
'like',
mu=mu_subj,
tau=1,
col_name='data',
observed=True)
return [mu_g, mu_subj, like]
else:
mu_subj = Knode(pm.Uniform,
'mu_subj',
lower=-5,
upper=5,
depends=self.depends['mu'])
like = Knode(pm.Normal,
'like',
mu=mu_subj,
tau=1,
col_name='data',
observed=True)
return [mu_subj, like]
def create_knodes(self):
if self.is_group_model:
mu_g = Knode(pm.Uniform,
'mu_g',
lower=-5,
upper=5,
depends=self.depends['mu'])
mu_std = Knode(pm.Uniform,
'mu_std',
lower=1e-8,
upper=100,
depends=self.depends['mu_std'])
mu_tau = Knode(pm.Deterministic,
'mu_tau',
doc='mu_tau',
eval=lambda x: x**-2,
x=mu_std,
plot=False,
trace=False)
#v_tau = Knode(pm.Lambda, 'v_tau', lam_fun=lambda x=v_std: x**-2, plot=False, trace=False)
mu_subj = Knode(pm.Normal,
'mu_subj',
mu=mu_g,
tau=mu_tau,
subj=True)
like = Knode(pm.Normal,
'like',
mu=mu_subj,
tau=1,
col_name='data',
observed=True)
return [mu_g, mu_std, mu_tau, mu_subj, like]
else:
mu_subj = Knode(pm.Uniform,
'mu_subj',
lower=-5,
upper=5,
depends=self.depends['mu'])
like = Knode(pm.Normal,
'like',
mu=mu_subj,
tau=1,
col_name='data',
observed=True)
return [mu_subj, like]
def _create_family_gamma_gamma_hnormal(self, name, value=1, g_mean=1, g_std=1, std_std=2, std_value=.1):
"""Similar to _create_family_normal_normal_hnormal() but adds an exponential
transform knode to the subject and group mean nodes. This is useful
when the parameter space is restricted from [0, +oo).
See _create_family_normal_normal_hnormal() help for more information.
"""
knodes = OrderedDict()
g_shape = (g_mean**2) / (g_std**2)
g_rate = g_mean / (g_std**2)
if self.is_group_model and name not in self.group_only_nodes:
g = Knode(pm.Gamma, name, alpha=g_shape, beta=g_rate,
value=g_mean, depends=self.depends[name])
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(pm.HalfNormal, '%s_std' % name, tau=std_std**-2,
value=std_value, depends=depends_std)
shape = Knode(pm.Deterministic, '%s_shape' % name, eval=lambda x,y: (x**2)/(y**2),
x=g, y=std, plot=False, trace=False, hidden=True)
rate = Knode(pm.Deterministic, '%s_rate' % name, eval=lambda x,y: x/(y**2),
x=g, y=std, plot=False, trace=False, hidden=True)
subj = Knode(pm.Gamma, '%s_subj'%name, alpha=shape, beta=rate,
value=value, depends=('subj_idx',),
subj=True, plot=False)
knodes['%s'%name] = g
knodes['%s_std'%name] = std
knodes['%s_rate'%name] = rate
knodes['%s_shape'%name] = shape
knodes['%s_bottom'%name] = subj
else:
g = Knode(pm.Gamma, name, alpha=g_shape, beta=g_rate, value=value,
depends=self.depends[name])
knodes['%s_bottom'%name] = g
return knodes
def _create_family_beta(self, name, value=.5, g_value=.5, g_mean=.5, g_certainty=2,
var_alpha=1, var_beta=1, var_value=.1):
"""Similar to create_family_normal() but beta for the subject
and group mean nodes. This is useful when the parameter space
is restricted from [0, 1].
See create_family_normal() help for more information.
"""
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g_mean = Knode(pm.Beta, name, alpha=g_mean*g_certainty, beta=(1-g_mean)*g_certainty,
value=g_value, depends=self.depends[name])
g_certainty = Knode(pm.Gamma, '%s_certainty' % name,
alpha=var_alpha, beta=var_beta, value=var_value)
alpha = Knode(pm.Deterministic, '%s_alpha' % name, eval=lambda mean, certainty: mean*certainty,
mean=g_mean, certainty=g_certainty, plot=False, trace=False, hidden=True)
beta = Knode(pm.Deterministic, '%s_beta' % name, eval=lambda mean, certainty: (1-mean)*certainty,
mean=g_mean, certainty=g_certainty, plot=False, trace=False, hidden=True)
subj = Knode(pm.Beta, '%s_subj'%name, alpha=alpha, beta=beta,
value=value, depends=('subj_idx',),
subj=True, plot=False)
knodes['%s'%name] = g_mean
knodes['%s_certainty'%name] = g_certainty
knodes['%s_alpha'%name] = alpha
knodes['%s_beta'%name] = beta
knodes['%s_bottom'%name] = subj
else:
g = Knode(pm.Beta, name, alpha=g_mean*g_certainty, beta=(1-g_mean)*g_certainty, value=value,
depends=self.depends[name])
knodes['%s_bottom'%name] = g
return knodes
def _create_stochastic_knodes_noninfo(self, include):
knodes = OrderedDict()
if "a" in include:
knodes.update(
self._create_family_trunc_normal("a",
lower=1e-3,
upper=1e3,
value=1))
if "v" in include:
knodes.update(
self._create_family_normal_normal_hnormal("v",
value=0,
g_tau=50**-2,
std_std=10))
if "t" in include:
knodes.update(
self._create_family_trunc_normal("t",
lower=1e-3,
upper=1e3,
value=0.01))
if "sv" in include:
knodes["sv_bottom"] = Knode(
pm.Uniform,
"sv",
lower=1e-6,
upper=1e3,
value=1,
depends=self.depends["sv"],
)
if "sz" in include:
knodes["sz_bottom"] = Knode(pm.Beta,
"sz",
alpha=1,
beta=1,
value=0.01,
depends=self.depends["sz"])
if "st" in include:
knodes["st_bottom"] = Knode(
pm.Uniform,
"st",
lower=1e-6,
upper=1e3,
value=0.01,
depends=self.depends["st"],
)
if "z" in include:
knodes.update(
self._create_family_invlogit("z",
value=0.5,
g_tau=10**-2,
std_std=0.5))
if "p_outlier" in include:
knodes["p_outlier_bottom"] = Knode(
pm.Beta,
"p_outlier",
alpha=1,
beta=1,
value=0.01,
depends=self.depends["p_outlier"],
)
return knodes
def _create_stochastic_knodes_noninfo(self, include):
knodes = OrderedDict()
if 'a' in include:
knodes.update(
self._create_family_gamma_gamma_hnormal('a',
g_mean=1.5,
g_std=0.75,
std_std=2,
std_value=0.1,
value=1))
if 'v' in include:
knodes.update(
self._create_family_normal_normal_hnormal('v',
value=2,
g_mu=2,
g_tau=3**-2,
std_std=2))
if 't' in include:
knodes.update(
self._create_family_gamma_gamma_hnormal('t',
g_mean=.4,
g_std=0.2,
value=0.001,
std_std=1,
std_value=0.2))
if 'sv' in include:
knodes['sv_bottom'] = Knode(pm.Uniform,
'sv',
lower=1e-6,
upper=1e3,
value=1,
depends=self.depends['sv'])
if 'sz' in include:
knodes['sz_bottom'] = Knode(pm.Beta,
'sz',
alpha=1,
beta=1,
value=0.01,
depends=self.depends['sz'])
if 'st' in include:
knodes['st_bottom'] = Knode(pm.Uniform,
'st',
lower=1e-6,
upper=1e3,
value=0.01,
depends=self.depends['st'])
if 'z' in include:
#knodes.update(self._create_family_invlogit('z', value=.5, g_tau=10**-2, std_std=0.5))
knodes.update(
self._create_family_invlogit('z',
value=.6,
g_tau=2**-2,
std_std=0.5))
#knodes.update(self._create_family_trunc_normal('z', lower=-2, upper=2, value=0.4,std_lower=1e-4,std_upper=1,std_value=.1))
if 'p_outlier' in include:
knodes['p_outlier_bottom'] = Knode(
pm.Beta,
'p_outlier',
alpha=1,
beta=1,
value=0.01,
depends=self.depends['p_outlier'])
return knodes
def _create_stochastic_knodes_info(self, include):
knodes = OrderedDict()
if "a" in include:
knodes.update(
self._create_family_gamma_gamma_hnormal("a",
g_mean=1.5,
g_std=0.75,
std_std=2,
std_value=0.1,
value=1))
if "v" in include:
knodes.update(
self._create_family_normal_normal_hnormal("v",
value=2,
g_mu=2,
g_tau=3**-2,
std_std=2))
if "t" in include:
knodes.update(
self._create_family_gamma_gamma_hnormal("t",
g_mean=0.4,
g_std=0.2,
value=0.001,
std_std=1,
std_value=0.2))
if "sv" in include:
knodes["sv_bottom"] = Knode(pm.HalfNormal,
"sv",
tau=2**-2,
value=1,
depends=self.depends["sv"])
if "sz" in include:
knodes["sz_bottom"] = Knode(pm.Beta,
"sz",
alpha=1,
beta=3,
value=0.01,
depends=self.depends["sz"])
if "st" in include:
knodes["st_bottom"] = Knode(
pm.HalfNormal,
"st",
tau=0.3**-2,
value=0.001,
depends=self.depends["st"],
)
if "z" in include:
knodes.update(
self._create_family_invlogit("z",
value=0.5,
g_tau=0.5**-2,
std_std=0.05))
if "p_outlier" in include:
knodes["p_outlier_bottom"] = Knode(
pm.Beta,
"p_outlier",
alpha=1,
beta=15,
value=0.01,
depends=self.depends["p_outlier"],
)
return knodes
def _create_family_normal_non_centered(self,
name,
value=0,
g_mu=None,
g_tau=15**-2,
std_lower=1e-10,
std_upper=100,
std_value=.1):
"""Similar to _create_family_normal() but using a non-centered
approach to estimating individual differences.
See _create_family_normal() help for more information.
"""
if g_mu is None:
g_mu = value
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g = Knode(pm.Normal,
'%s' % name,
mu=g_mu,
tau=g_tau,
value=value,
depends=self.depends[name])
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(pm.Uniform,
'%s_std' % name,
lower=std_lower,
upper=std_upper,
value=std_value,
depends=depends_std)
offset_subj = Knode(pm.Normal,
'%s_offset_subj' % name,
mu=0,
tau=5**-2,
value=0,
depends=('subj_idx', ),
subj=True,
hidden=True,
plot=False)
subj = Knode(pm.Deterministic,
'%s_subj' % name,
eval=lambda x, y, z: x + y * z,
x=g,
y=offset_subj,
z=std,
depends=('subj_idx', ),
plot=self.plot_subjs,
trace=True,
hidden=False,
subj=True)
knodes['%s' % name] = g
knodes['%s_std' % name] = std
knodes['%s_offset_subj' % name] = offset_subj
knodes['%s_bottom' % name] = subj
else:
subj = Knode(pm.Normal,
name,
mu=g_mu,
tau=g_tau,
value=value,
depends=self.depends[name])
knodes['%s_bottom' % name] = subj
return knodes
def _create_family_trunc_normal_trunc_normal_hnormal(
self,
name,
value=0,
lower=None,
upper=None,
std_std=None,
g_mu=None,
g_std=10,
std_value=0.1,
):
"""Similar to _create_family_normal() but creates a Uniform
group distribution and a truncated subject distribution.
See _create_family_normal() help for more information.
"""
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g = Knode(
pm.TruncatedNormal,
"%s" % name,
mu=g_mu,
tau=1 / (g_std**2),
lower=lower,
upper=upper,
value=value,
depends=self.depends[name],
)
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(
pm.HalfNormal,
"%s_std" % name,
tau=std_std**-2,
value=std_value,
depends=depends_std,
)
tau = Knode(
pm.Deterministic,
"%s_tau" % name,
doc="%s_tau" % name,
eval=lambda x: x**-2,
x=std,
plot=False,
trace=False,
hidden=True,
)
subj = Knode(
pm.TruncatedNormal,
"%s_subj" % name,
mu=g,
tau=tau,
a=lower,
b=upper,
value=value,
depends=("subj_idx", ),
subj=True,
plot=self.plot_subjs,
)
knodes["%s" % name] = g
knodes["%s_std" % name] = std
knodes["%s_tau" % name] = tau
knodes["%s_bottom" % name] = subj
else:
# If not group model or current node is group only --> Uniform Prior
subj = Knode(
pm.TruncatedNormal,
name,
mu=g_mu,
tau=1 / (g_std**2),
lower=lower,
upper=upper,
value=value,
depends=self.depends[name],
)
knodes["%s_bottom" % name] = subj
return knodes
def _create_family_invlogit(
self,
name,
value,
g_mu=None,
g_tau=15**-2,
std_std=0.2,
std_value=0.1,
lower=0.0, # previously the lower and upper arguments were not there !
upper=1.0,
):
"""Similar to _create_family_normal_normal_hnormal() but adds a invlogit
transform knode to the subject and group mean nodes. This is useful
when the parameter space is restricted from [0, 1].
See _create_family_normal_normal_hnormal() help for more information.
"""
if g_mu is None:
g_mu = value
# logit transform values
tmp_val = (value - lower) / (upper - lower)
tmp_g_mu = (g_mu - lower) / (upper - lower)
# logit transform values
value_trans = np.log(tmp_val) - np.log(1 - tmp_val)
g_mu_trans = np.log(tmp_g_mu) - np.log(1 - tmp_g_mu)
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g_trans = Knode(
pm.Normal,
"%s_trans" % name,
mu=g_mu_trans,
tau=g_tau,
value=value_trans,
depends=self.depends[name],
plot=False,
hidden=True,
)
# This needs some care, InvLogit should be applied on a transformed value here
# to properly accomodate the generalized invlogit
# g = Knode(pm.InvLogit,
# name,
# ltheta = g_trans,
# plot = True,
# trace = True
# )
# Using pm.deterministic here, better would be something like pm.InvLogitGeneral
g = Knode(
pm.Deterministic,
name,
eval=lambda x: lower + ((upper - lower) * (np.exp(x)) /
(1 + np.exp(x))),
x=g_trans,
plot=True,
trace=True,
)
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(
pm.HalfNormal,
"%s_std" % name,
tau=std_std**-2,
value=std_value,
depends=depends_std,
)
tau = Knode(
pm.Deterministic,
"%s_tau" % name,
doc="%s_tau" % name,
eval=lambda x: x**-2,
x=std,
plot=False,
trace=False,
hidden=True,
)
subj_trans = Knode(
pm.Normal,
"%s_subj_trans" % name,
mu=g_trans,
tau=tau,
value=value_trans,
depends=("subj_idx", ),
subj=True,
plot=False,
hidden=True,
)
# This needs some care, InvLogit should be applied on a transformed value here
# to properly accomodate the generalized invlogit
# subj = Knode(pm.InvLogit,
# '%s_subj'%name,
# ltheta=subj_trans,
# depends=('subj_idx',),
# plot=self.plot_subjs,
# trace=True,
# subj=True)
subj = Knode(
pm.Deterministic,
"%s_subj" % name,
eval=lambda x: lower + ((upper - lower) * (np.exp(x)) /
(1 + np.exp(x))),
x=subj_trans,
plot=self.plot_subjs,
trace=True,
subj=True,
)
knodes["%s_trans" % name] = g_trans
knodes["%s" % name] = g
knodes["%s_std" % name] = std
knodes["%s_tau" % name] = tau
knodes["%s_subj_trans" % name] = subj_trans
knodes["%s_bottom" % name] = subj
else:
g_trans = Knode(
pm.Normal,
"%s_trans" % name,
mu=g_mu_trans,
tau=g_tau,
value=value_trans,
depends=self.depends[name],
plot=False,
hidden=True,
)
# This needs some care, InvLogit should be applied on a transformed value here
# to properly accomodate the generalized invlogit
# Here my manual version
g = Knode(
pm.Deterministic,
"%s" % name,
eval=lambda x: lower + ((upper - lower) * (np.exp(x)) /
(1 + np.exp(x))),
x=g_trans,
plot=True,
trace=True,
)
# Original version
# g = Knode(pm.InvLogit, '%s'%name, ltheta=g_trans, plot=True,
# trace=True )
knodes["%s_trans" % name] = g_trans
knodes["%s_bottom" % name] = g
return knodes
def _create_family_invlogit(self,
name,
value,
g_mu=None,
g_tau=15**-2,
std_std=0.2,
std_value=.1):
"""Similar to _create_family_normal_normal_hnormal() but adds a invlogit
transform knode to the subject and group mean nodes. This is useful
when the parameter space is restricted from [0, 1].
See _create_family_normal_normal_hnormal() help for more information.
"""
if g_mu is None:
g_mu = value
# logit transform values
value_trans = np.log(value) - np.log(1 - value)
g_mu_trans = np.log(g_mu) - np.log(1 - g_mu)
knodes = OrderedDict()
if self.is_group_model and name not in self.group_only_nodes:
g_trans = Knode(pm.Normal,
'%s_trans' % name,
mu=g_mu_trans,
tau=g_tau,
value=value_trans,
depends=self.depends[name],
plot=False,
hidden=True)
g = Knode(pm.InvLogit, name, ltheta=g_trans, plot=True, trace=True)
depends_std = self.depends[name] if self.std_depends else ()
std = Knode(pm.HalfNormal,
'%s_std' % name,
tau=std_std**-2,
value=std_value,
depends=depends_std)
tau = Knode(pm.Deterministic,
'%s_tau' % name,
doc='%s_tau' % name,
eval=lambda x: x**-2,
x=std,
plot=False,
trace=False,
hidden=True)
subj_trans = Knode(pm.Normal,
'%s_subj_trans' % name,
mu=g_trans,
tau=tau,
value=value_trans,
depends=('subj_idx', ),
subj=True,
plot=False,
hidden=True)
subj = Knode(pm.InvLogit,
'%s_subj' % name,
ltheta=subj_trans,
depends=('subj_idx', ),
plot=self.plot_subjs,
trace=True,
subj=True)
knodes['%s_trans' % name] = g_trans
knodes['%s' % name] = g
knodes['%s_std' % name] = std
knodes['%s_tau' % name] = tau
knodes['%s_subj_trans' % name] = subj_trans
knodes['%s_bottom' % name] = subj
else:
g_trans = Knode(pm.Normal,
'%s_trans' % name,
mu=g_mu_trans,
tau=g_tau,
value=value_trans,
depends=self.depends[name],
plot=False,
hidden=True)
g = Knode(pm.InvLogit,
'%s' % name,
ltheta=g_trans,
plot=True,
trace=True)
knodes['%s_trans' % name] = g_trans
knodes['%s_bottom' % name] = g
return knodes
def _create_stochastic_knodes_nn_info(self, include):
print(
"Note: Currently for HDDMnn, HDDMnnRegressor, HDDMnnStimCoding setting informative priors has no effect!"
)
knodes = OrderedDict()
# PARAMETERS COMMON TO ALL MODELS
if "p_outlier" in include:
knodes["p_outlier_bottom"] = Knode(
pm.Beta,
"p_outlier",
alpha=1,
beta=1,
value=0.01,
depends=self.depends["p_outlier"],
)
for tmp_param in self.model_config["params"]:
if tmp_param in include:
param_id = self.model_config["params"].index(tmp_param)
# Perform some checks on the self.model_config to see if all expected keys are included
# If not, choose reasonable defaults for some of them.
if not "params_trans" in self.model_config.keys():
trans = 0
else:
trans = self.model_config["params_trans"][param_id]
if not "params_std_upper" in self.model_config.keys():
print(
'Supplied model_config does not have a params_std_upper argument.'
)
print('Set to a default of 10')
param_std_upper = 10
elif self.model_config["params_std_upper"][param_id] == None:
print(
'Supplied model_config specifies params_std_upper for ',
tmp_param, 'as ', 'None.')
print('Changed to 10')
param_std_upper = 10
else:
param_std_upper = self.model_config["params_std_upper"][
param_id]
if not "params_default" in self.model_config.keys():
param_default = (
self.model_config["param_bounds"][1][param_id] -
self.model_config["param_bounds"][0][param_id]) / 2
else:
param_default = self.model_config["params_default"][
param_id]
if trans:
knodes.update(
self._create_family_invlogit(
tmp_param,
g_tau=10**-2,
std_std=0.5,
lower=self.model_config["param_bounds"][0]
[param_id],
upper=self.model_config["param_bounds"][1]
[param_id],
value=param_default,
))
else:
knodes.update(
self._create_family_trunc_normal(
tmp_param,
lower=self.model_config["param_bounds"][0]
[param_id],
upper=self.model_config["param_bounds"][1]
[param_id],
value=param_default,
std_upper=param_std_upper, # added AF
))
return knodes