def nonempty_obs(self, dtrajs) -> np.ndarray:
r"""
Computes the set of visited observable states given a set of discrete trajectories.
Parameters
----------
dtrajs : array_like
observable trajectory
Returns
-------
symbols : np.ndarray
The observation symbols which are visited.
"""
from deeptime.markov.util import compute_dtrajs_effective, count_states
if dtrajs is None:
raise ValueError("Needs nonempty dtrajs to evaluate nonempty obs.")
dtrajs = ensure_dtraj_list(dtrajs)
dtrajs_lagged_strided = compute_dtrajs_effective(
dtrajs, self.transition_model.lagtime,
self.transition_model.count_model.n_states_full, self.stride)
obs = np.where(count_states(dtrajs_lagged_strided) > 0)[0]
return obs
def fit(self, data, n_burn_in: int = 0, n_thin: int = 1, **kwargs):
r""" Sample from the posterior.
Parameters
----------
data : array_like or list of array_like
Input time series data.
n_burn_in : int, optional, default=0
The number of samples to discard to burn-in, following which :attr:`n_samples` samples will be generated.
n_thin : int, optional, default=1
The number of Gibbs sampling updates used to generate each returned sample.
**kwargs
Ignored kwargs for scikit-learn compatibility.
Returns
-------
self : BayesianHMM
Reference to self.
"""
dtrajs = ensure_dtraj_list(data)
# fetch priors
tmat = self.initial_hmm.transition_model.transition_matrix
transition_matrix_prior = self._transition_matrix_prior_np
initial_distribution_prior = self._initial_distribution_prior_np
model = BayesianHMMPosterior()
# update HMM Model
model.prior = self.initial_hmm.copy()
prior = model.prior
# check if we are strongly connected in the reversible case (plus prior)
if self.reversible and not is_connected(tmat + transition_matrix_prior,
directed=True):
raise NotImplementedError(
'Trying to sample disconnected HMM with option reversible:\n '
f'{tmat}\n Use prior to connect, select connected subset, '
f'or use reversible=False.')
# EVALUATE STRIDE
dtrajs_lagged_strided = compute_dtrajs_effective(
dtrajs,
lagtime=prior.lagtime,
n_states=prior.n_hidden_states,
stride=self.stride)
# if stride is different to init_hmm, check if microstates in lagged-strided trajs are compatible
if self.stride != self.initial_hmm.stride:
symbols = np.unique(np.concatenate(dtrajs_lagged_strided))
if not len(
np.intersect1d(self.initial_hmm.observation_symbols,
symbols)) == len(symbols):
raise ValueError(
'Choice of stride has excluded a different set of microstates than in '
'init_hmm. Set of observed microstates in time-lagged strided trajectories '
'must match to the one used for init_hmm estimation.')
# here we blow up the output matrix (if needed) to the FULL state space because we want to use dtrajs in the
# Bayesian HMM sampler. This is just an initialization.
n_states_full = number_of_states(dtrajs_lagged_strided)
if prior.n_observation_states < n_states_full:
eps = 0.01 / n_states_full # default output probability, in order to avoid zero columns
# full state space output matrix. make sure there are no zero columns
full_obs_probabilities = eps * np.ones(
(prior.n_hidden_states, n_states_full), dtype=np.float64)
# fill active states
full_obs_probabilities[:, prior.observation_symbols] = np.maximum(
eps, prior.output_probabilities)
# renormalize B to make it row-stochastic
full_obs_probabilities /= full_obs_probabilities.sum(axis=1)[:,
None]
else:
full_obs_probabilities = prior.output_probabilities
maxT = max(len(o) for o in dtrajs_lagged_strided)
# pre-construct hidden variables
temp_alpha = np.zeros((maxT, prior.n_hidden_states))
has_all_obs_symbols = model.prior.n_observation_states == len(
model.prior.observation_symbols_full)
try:
# sample model is basically copy of prior
sample_model = BayesianHMM._SampleStorage(
transition_matrix=prior.transition_model.transition_matrix.
copy(),
output_model=DiscreteOutputModel(
full_obs_probabilities.copy()),
initial_distribution=prior.initial_distribution.copy(),
stationary_distribution=prior.transition_model.
stationary_distribution.copy(),
counts=prior.count_model.count_matrix.copy(),
hidden_trajs=[])
# Run burn-in.
for _ in range(n_burn_in):
self._update(sample_model, dtrajs_lagged_strided, temp_alpha,
transition_matrix_prior,
initial_distribution_prior)
# Collect data.
models = []
for _ in range(self.n_samples):
# Run a number of Gibbs sampling updates to generate each sample.
for _ in range(n_thin):
self._update(sample_model, dtrajs_lagged_strided,
temp_alpha, transition_matrix_prior,
initial_distribution_prior)
sample_model.output_model.normalize()
self._append_sample(models, prior, sample_model)
if not has_all_obs_symbols:
models = [
m.submodel(states=None,
obs=model.prior.observation_symbols)
for m in models
]
model.samples = models
finally:
del temp_alpha
# set new model
self._model = model
return self
def fit(self, dtrajs, initial_model=None, **kwargs):
r""" Fits a new :class:`HMM <HiddenMarkovModel>` to data.
Parameters
----------
dtrajs : array_like or list of array_like
Timeseries data.
initial_model : HiddenMarkovModel, optional, default=None
Override for :attr:`initial_transition_model`.
**kwargs
Ignored kwargs for scikit-learn compatibility.
Returns
-------
self : MaximumLikelihoodHMM
Reference to self.
"""
if initial_model is None:
initial_model = self.initial_transition_model
if initial_model is None or not isinstance(initial_model, HiddenMarkovModel):
raise ValueError("For estimation, an initial model of type "
"`deeptime.markov.hmm.HiddenMarkovModel` is required.")
# copy initial model
transition_matrix = initial_model.transition_model.transition_matrix
if issparse(transition_matrix):
# want dense matrix, toarray makes a copy
transition_matrix = transition_matrix.toarray()
else:
# new instance
transition_matrix = np.copy(transition_matrix)
hmm_data = MaximumLikelihoodHMM._HMMModelStorage(transition_matrix=transition_matrix,
output_model=initial_model.output_model.copy(),
initial_distribution=initial_model.initial_distribution.copy())
dtrajs = ensure_timeseries_data(dtrajs)
dtrajs = compute_dtrajs_effective(dtrajs, lagtime=self.lagtime, n_states=initial_model.n_hidden_states,
stride=self.stride)
max_n_frames = max(len(obs) for obs in dtrajs)
# pre-construct hidden variables
N = initial_model.n_hidden_states
alpha = np.zeros((max_n_frames, N))
beta = np.zeros((max_n_frames, N))
gammas = [np.zeros((len(obs), N)) for obs in dtrajs]
count_matrices = [np.zeros((N, N)) for _ in dtrajs]
it = 0
likelihoods = np.empty(self.maxit)
# flag if connectivity has changed (e.g. state lost) - in that case the likelihood
# is discontinuous and can't be used as a convergence criterion in that iteration.
tmatrix_nonzeros = hmm_data.transition_matrix.nonzero()
converged = False
while not converged and it < self.maxit:
loglik = 0.0
for obs, gamma, counts in zip(dtrajs, gammas, count_matrices):
loglik_update, _ = self._forward_backward(hmm_data, obs, alpha, beta, gamma, counts)
loglik += loglik_update
assert np.isfinite(loglik), it
# convergence check
if it > 0:
dL = loglik - likelihoods[it - 1]
if dL < self.accuracy:
converged = True
# update model
self._update_model(hmm_data, dtrajs, gammas, count_matrices, maxiter=self.maxit_reversible)
# connectivity change check
tmatrix_nonzeros_new = hmm_data.transition_matrix.nonzero()
if not np.array_equal(tmatrix_nonzeros, tmatrix_nonzeros_new):
converged = False # unset converged
tmatrix_nonzeros = tmatrix_nonzeros_new
# end of iteration
likelihoods[it] = loglik
it += 1
likelihoods = np.resize(likelihoods, it)
transition_counts = self._reduce_transition_counts(count_matrices)
count_model = TransitionCountModel(count_matrix=transition_counts, lagtime=self.lagtime)
transition_model = MarkovStateModel(hmm_data.transition_matrix, reversible=self.reversible,
count_model=count_model)
hidden_state_trajs = [
viterbi(hmm_data.transition_matrix, hmm_data.output_model.to_state_probability_trajectory(obs),
hmm_data.initial_distribution) for obs in dtrajs
]
model = HiddenMarkovModel(
transition_model=transition_model,
output_model=hmm_data.output_model,
initial_distribution=hmm_data.initial_distribution,
likelihoods=likelihoods,
state_probabilities=gammas,
initial_count=self._init_counts(gammas),
hidden_state_trajectories=hidden_state_trajs,
stride=self.stride
)
self._model = model
return self
def metastable_from_data(dtrajs,
n_hidden_states,
lagtime,
stride=1,
mode='largest-regularized',
reversible: bool = True,
stationary: bool = False,
separate_symbols=None,
states: Optional[np.ndarray] = None,
regularize: bool = True,
connectivity_threshold: Union[str, float] = 0.):
r"""Estimates an initial guess :class:`HMM <deeptime.markov.hmm.HiddenMarkovModel>` from given
discrete trajectories.
Following the procedure described in :cite:`hmm-init-data-noe2013projected`: First
a :class:`MSM <deeptime.markov.msm.MarkovStateModel>` is estimated, which is then subsequently
coarse-grained with PCCA+ :cite:`hmm-init-data-roblitz2013fuzzy`. After estimation of the MSM, this
method calls :meth:`metastable_from_msm`.
Parameters
----------
dtrajs : array_like or list of array_like
A discrete trajectory or a list of discrete trajectories.
n_hidden_states : int
Number of hidden states.
lagtime : int
The lagtime at which transitions are counted.
stride : int or str, optional, default=1
stride between two lagged trajectories extracted from the input trajectories. Given trajectory :code:`s[t]`,
stride and lag will result in trajectories
:code:`s[0], s[lag], s[2 lag], ...`
:code:`s[stride], s[stride + lag], s[stride + 2 lag], ...`
Setting stride = 1 will result in using all data (useful for maximum likelihood estimator), while a Bayesian
estimator requires a longer stride in order to have statistically uncorrelated trajectories. Setting
:code:`stride='effective'` uses the largest neglected timescale as an estimate for the correlation time
and sets the stride accordingly.
mode : str, optional, default='largest-regularized'
The mode at which the markov state model is estimated. Since the process is assumed to be reversible and
finite statistics might lead to unconnected regions in state space, a subselection can automatically be made
and the count matrix can be regularized. The following options are available:
* 'all': all available states are taken into account
* 'largest': the largest connected state set is selected, see
:meth:`TransitionCountModel.submodel_largest <deeptime.markov.TransitionCountModel.submodel_largest>`.
* populus: the connected set with the largest population in the data, see
:meth:`TransitionCountModel.submodel_largest <deeptime.markov.TransitionCountModel.submodel_largest>`.
For regularization, each of the options can be suffixed by a '-regularized', e.g., 'largest-regularized'.
This means that the count matrix has no zero entries and everything is reversibly connected. In particular,
a prior of the form
.. math:: b_{ij}=\left \{ \begin{array}{rl}
\alpha & \text{, if }c_{ij}+c_{ji}>0, \\
0 & \text{, otherwise,}
\end{array} \right .
with :math:`\alpha=10^{-3}` is added and all non-reversibly connected components are artifically connected
by adding backward paths.
reversible : bool, optional, default=True
Whether the HMM transition matrix is estimated so that it is reversibe.
stationary : bool, optional, default=False
If True, the initial distribution of hidden states is self-consistently computed as the stationary
distribution of the transition matrix. If False, it will be estimated from the starting states.
Only set this to true if you're sure that the observation trajectories are initiated from a global
equilibrium distribution.
separate_symbols : array_like, optional, default=None
Force the given set of observed states to stay in a separate hidden state.
The remaining nstates-1 states will be assigned by a metastable decomposition.
states : (dtype=int) ndarray, optional, default=None
Artifically restrict count model to selection of states, even before regularization.
regularize : bool, optional, default=True
If set to True, makes sure that the hidden initial distribution and transition matrix have nonzero probabilities
by setting them to eps and then renormalizing. Avoids zeros that would cause estimation algorithms to crash or
get stuck in suboptimal states.
connectivity_threshold : float or '1/n', optional, default=0.
Connectivity threshold. counts that are below the specified value are disregarded when finding connected
sets. In case of '1/n', the threshold gets resolved to :math:`1 / \mathrm{n\_states\_full}`.
Returns
-------
hmm_init : HiddenMarkovModel
An initial guess for the HMM
See Also
--------
DiscreteOutputModel
The type of output model this heuristic uses.
:func:`metastable_from_msm`
Initial guess from an already existing :class:`MSM <deeptime.markov.msm.MarkovStateModel>`.
:func:`deeptime.markov.hmm.init.gaussian.from_data`
Initial guess with :class:`Gaussian output model <deeptime.markov.hmm.GaussianOutputModel>`.
References
----------
.. bibliography:: /references.bib
:style: unsrt
:filter: docname in docnames
:keyprefix: hmm-init-data-
"""
if mode not in metastable_from_data.VALID_MODES \
+ [m + "-regularized" for m in metastable_from_data.VALID_MODES]:
raise ValueError("mode can only be one of [{}]".format(", ".join(
metastable_from_data.VALID_MODES)))
from deeptime.markov.util import compute_dtrajs_effective
from deeptime.markov import TransitionCountEstimator
dtrajs = ensure_dtraj_list(dtrajs)
dtrajs = compute_dtrajs_effective(dtrajs,
lagtime=lagtime,
n_states=n_hidden_states,
stride=stride)
counts = TransitionCountEstimator(1, 'sliding',
sparse=False).fit(dtrajs).fetch_model()
if states is not None:
counts = counts.submodel(states)
if '-regularized' in mode:
import deeptime.markov.tools.estimation as memest
counts.count_matrix[...] += memest.prior_neighbor(
counts.count_matrix, 0.001)
nonempty = np.where(
counts.count_matrix.sum(axis=0) +
counts.count_matrix.sum(axis=1) > 0)[0]
counts.count_matrix[nonempty, nonempty] = np.maximum(
counts.count_matrix[nonempty, nonempty], 0.001)
if 'all' in mode:
pass # no-op
if 'largest' in mode:
counts = counts.submodel_largest(
directed=True,
connectivity_threshold=connectivity_threshold,
sort_by_population=False)
if 'populous' in mode:
counts = counts.submodel_largest(
directed=True,
connectivity_threshold=connectivity_threshold,
sort_by_population=True)
from deeptime.markov.msm import MaximumLikelihoodMSM
msm = MaximumLikelihoodMSM(reversible=True,
allow_disconnected=True,
maxerr=1e-3,
maxiter=10000).fit(counts).fetch_model()
return metastable_from_msm(msm, n_hidden_states, reversible, stationary,
separate_symbols, regularize)