def test_adjusted_gt_minprob(self):
"""correctly adjust a prob vector so all values > minval"""
vector = [0.8, 0.2, 0.0, 0.0]
minprob = 1e-3
got = adjusted_gt_minprob(vector, minprob=minprob)
self.assertTrue(got.min() > minprob)
minprob = 1e-6
got = adjusted_gt_minprob(vector, minprob=minprob)
self.assertTrue(got.min() > minprob)
minprob = 0
got = adjusted_gt_minprob(vector, minprob=minprob)
self.assertTrue(got.min() > minprob)
def set_motif_probs(
self,
motif_probs,
locus=None,
bin=None,
is_constant=None,
is_independent=None,
auto=False,
**kwargs,
):
motif_probs = self.model.adapt_motif_probs(motif_probs, auto=auto)
motif_probs = adjusted_gt_minprob(motif_probs, minprob=1e-6)
if is_constant is None:
is_constant = not self.optimise_motif_probs
self.model.set_param_controller_motif_probs(
self,
motif_probs,
is_constant=is_constant,
bin=bin,
locus=locus,
is_independent=is_independent,
**kwargs,
)
if not auto:
self.mprobs_from_alignment = False # should be done per-locus
def test_adjusted_probs_2D(self):
"""correctly adjust a 2D array"""
data = [
[1.0000, 0.0000, 0.0000, 0.0000],
[0.0000, 1.0000, 0.0000, 0.0000],
[0.1250, 0.1250, 0.6250, 0.1250],
[0.1250, 0.1250, 0.1250, 0.6250],
]
got = adjusted_gt_minprob(data)
assert_allclose(got, data, atol=1e-5)
def get_param_rule_dict(self, names=None, is_probs=False):
"""returns component for a param rule dict"""
value = self.value
if names is not None:
assert len(self.value) == len(names)
if is_probs:
value = adjusted_gt_minprob(
adjusted_gt_minprob(self.value, minprob=1e-6))
if value.ndim == 1:
value = {n: v for n, v in zip(names, value)}
else:
result = {}
for i, n1 in enumerate(names):
result[n1] = {}
for j, n2 in enumerate(names):
result[n1][n2] = value[i, j]
value = result
if self.is_constant:
result = dict(value=value, is_constant=True)
else:
result = dict(init=value, lower=self.lower, upper=self.upper)
return result
def get_motif_probs(self, edge=None, bin=None, locus=None, position=None):
"""
Parameters
----------
edge : str
name of edge
bin : int or str
name of bin
locus : str
name of locus
position : int or str
name of position
Returns
-------
If 1D, returns DictArray, else a dict of DictArray
"""
param_names = self.get_param_names()
mprob_name = [n for n in param_names if "mprob" in n][0]
dims = tuple(self.get_used_dimensions(mprob_name))
mprobs = self.get_param_value_dict(dimensions=dims,
params=[mprob_name])
if len(dims) == 2:
var = [c for c in dims if c != mprob_name][0]
key = locals().get(var, None)
mprobs = mprobs[mprob_name]
if key is not None:
mprobs = mprobs.get(str(key), mprobs.get(key))
mprobs = {mprob_name: mprobs}
# these can fall below the minimum allowed value due to
# rounding errors, so I adjust these
for k, value in mprobs.items():
value.array = adjusted_gt_minprob(value.array, minprob=1e-6)
if len(mprobs) == 1:
mprobs = mprobs[mprob_name]
return mprobs
