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_normal(self,
name,
value=0,
g_mu=None,
g_tau=15**-2,
std_lower=1e-10,
std_upper=100,
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.Uniform,
'%s_std' % name,
lower=std_lower,
upper=std_upper,
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_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])
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,
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_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_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_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_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_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_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_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_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
def _create_wfpt_knode(self, knodes):
wfpt_parents = self._create_wfpt_parents_dict(knodes)
return Knode(self.wfpt_nn_collapsing_class, 'wfpt', observed=True, col_name=['nn_response', 'rt'], **wfpt_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'],
hidden=True)
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)
mu_subj = Knode(pm.Normal,
'mu_subj',
mu=mu_g,
tau=mu_tau,
subj=True,
plot=False,
hidden=True)
mu_subj_trans = Knode(pm.Deterministic,
'mu_subj_trans',
eval=lambda x: x,
x=mu_subj,
plot=True,
trace=True)
like = Knode(pm.Normal,
'like',
mu=mu_subj_trans,
tau=1,
col_name='data',
observed=True)
return [mu_g, mu_std, mu_tau, mu_subj, mu_subj_trans, like]
else:
mu_subj = Knode(pm.Uniform,
'mu_subj',
lower=-5,
upper=5,
depends=self.depends['mu'])
mu_subj_trans = Knode(pm.Deterministic,
'mu_subj_trans',
eval=lambda x: x,
x=mu_subj,
plot=True,
trace=True)
like = Knode(pm.Normal,
'like',
mu=mu_subj_trans,
tau=1,
col_name='data',
observed=True)
return [mu_subj, mu_subj_trans, like]
