def getMotifProbs(self, edge=None, bin=None, locus=None):
motif_probs_array = self.getParamValue('mprobs',
edge=edge,
bin=bin,
locus=locus)
mprob_name = [p for p in self.getParamNames() if 'mprobs' in p][0]
if 'position' in self.getUsedDimensions(mprob_name):
positions = self._valuesForDimension('position')
motifs = self._mprob_motifs
return DictArrayTemplate(positions, motifs).wrap(motif_probs_array)
return DictArrayTemplate(self._mprob_motifs).wrap(motif_probs_array)
def getMotifProbsByNode(self, edges=None, bin=None, locus=None):
kw = dict(bin=bin, locus=locus)
mprobs = self.getParamValue('mprobs', **kw)
mprobs = self._model.calcWordProbs(mprobs)
result = self._nodeMotifProbs(self._tree, mprobs, kw)
if edges is None:
edges = [name for (name, m) in result]
result = dict(result)
values = [result[name] for name in edges]
if len(values[0]) == len(self._mprob_motifs):
return DictArrayTemplate(edges, self._mprob_motifs).wrap(values)
return DictArrayTemplate(edges, self._motifs).wrap(values)
def reconstructAncestralSeqs(self, locus=None):
"""returns a dict of DictArray objects containing probabilities
of each alphabet state for each node in the tree.
Arguments:
- locus: a named locus"""
result = {}
array_template = None
for restricted_edge in self._tree.getEdgeVector():
if restricted_edge.istip():
continue
try:
r = []
for motif in range(len(self._motifs)):
self.setParamRule('fixed_motif',
value=motif,
edge=restricted_edge.Name,
locus=locus,
is_constant=True)
likelihoods = self.getFullLengthLikelihoods(locus=locus)
r.append(likelihoods)
if array_template is None:
array_template = DictArrayTemplate(
likelihoods.shape[0], self._motifs)
finally:
self.setParamRule('fixed_motif',
value=-1,
edge=restricted_edge.Name,
locus=locus,
is_constant=True)
# dict of site x motif arrays
result[restricted_edge.Name] = array_template.wrap(
numpy.transpose(numpy.asarray(r)))
return result
def __init__(self,
default=None,
name=None,
dimensions=None,
dimension=None,
size=None,
**kw):
assert name
if size is not None:
pass
elif default is not None:
size = len(default)
elif dimension is not None:
size = len(dimension[1])
self.size = size
if dimension is not None:
self.internal_dimension = dimension
(dim_name, dim_cats) = dimension
self.bin_names = dim_cats
self.array_template = DictArrayTemplate(dim_cats)
self.internal_dimensions = (dim_name, )
if default is None:
default = self._makeDefaultValue()
elif self.array_template is not None:
default = self.array_template.unwrap(default)
else:
default = numpy.asarray(default)
_InputDefn.__init__(self,
name=name,
default=default,
dimensions=dimensions,
**kw)
self.checkValueIsValid(default, True)
def getPsubForEdge(self, name, **kw):
"""returns the substitution probability matrix for the named edge"""
try:
# For PartialyDiscretePsubsDefn
array = self.getParamValue('dpsubs', edge=name, **kw)
except KeyError:
array = self.getParamValue('psubs', edge=name, **kw)
return DictArrayTemplate(self._motifs, self._motifs).wrap(array)
def getBinProbs(self, locus=None):
hmm = self.getParamValue('bindex', locus=locus)
lhs = [
self.getParamValue('lh', locus=locus, bin=bin)
for bin in self.bin_names
]
array = hmm.getPosteriorProbs(*lhs)
return DictArrayTemplate(self.bin_names, array.shape[1]).wrap(array)
def getRateMatrixForEdge(self, name, **kw):
"""returns the rate matrix (Q) for the named edge
Note: expm(Q) will give the same result as getPsubForEdge(name)"""
try:
array = self.getParamValue('Q', edge=name, **kw)
except KeyError as err:
if err[0] == 'Q' and name != 'Q':
raise RuntimeError('rate matrix not known by this model')
else:
raise
return DictArrayTemplate(self._motifs, self._motifs).wrap(array)
def getBinPriorProbs(self, locus=None):
bin_probs_array = self.getParamValue('bprobs', locus=locus)
return DictArrayTemplate(self.bin_names).wrap(bin_probs_array)
def getMotifProbs(self, edge=None, bin=None, locus=None):
motif_probs_array = self.getParamValue('mprobs',
edge=edge,
bin=bin,
locus=locus)
return DictArrayTemplate(self._mprob_motifs).wrap(motif_probs_array)
