def testInputArrays(self):
""" this is not supported, has to be list of ndarrays """
dtrajs = np.array([[0, 1, 2, 0, 0, 1, 2, 1, 0],
[0, 1, 2, 0, 0, 1., 2, 1, 1]])
with self.assertRaises(ValueError):
count_matrix(dtrajs, 1)
def count(count_mode: str,
dtrajs: List[np.ndarray],
lagtime: int,
sparse: bool = False):
r""" Computes a count matrix based on a counting mode, some discrete trajectories, a lagtime, and
whether to use sparse matrices.
Parameters
----------
count_mode : str
The counting mode to use. One of "sample", "sliding", "sliding-effective", and "effective".
See :meth:`__init__` for a more detailed description.
dtrajs : array_like or list of array_like
Discrete trajectories, i.e., a list of arrays which contain non-negative integer values. A single ndarray
can also be passed, which is then treated as if it was a list with that one ndarray in it.
lagtime : int
Distance between two frames in the discretized trajectories under which their potential change of state
is considered a transition.
sparse : bool, default=False
Whether to use sparse matrices or dense matrices. Sparse matrices can make sense when dealing with a lot of
states.
Returns
-------
count_matrix : (N, N) ndarray or sparse array
The computed count matrix. Can be ndarray or sparse depending on whether sparse was set to true or false.
N is the number of encountered states, i.e., :code:`np.max(dtrajs)+1`.
Example
-------
>>> dtrajs = [np.array([0,0,1,1]), np.array([0,0,1])]
>>> count_matrix = TransitionCountEstimator.count(
... count_mode="sliding", dtrajs=dtrajs, lagtime=1, sparse=False
... )
>>> np.testing.assert_equal(count_matrix, np.array([[2, 2], [0, 1]]))
"""
if count_mode == 'sliding' or count_mode == 'sliding-effective':
count_matrix = msmest.count_matrix(dtrajs,
lagtime,
sliding=True,
sparse_return=sparse)
if count_mode == 'sliding-effective':
count_matrix /= lagtime
elif count_mode == 'sample':
count_matrix = msmest.count_matrix(dtrajs,
lagtime,
sliding=False,
sparse_return=sparse)
elif count_mode == 'effective':
count_matrix = msmest.effective_count_matrix(dtrajs, lagtime)
if not sparse and issparse(count_matrix):
count_matrix = count_matrix.toarray()
else:
raise ValueError('Count mode {} is unknown.'.format(count_mode))
return count_matrix
def test_blocksplit_dtrajs_sliding(self):
dtrajs = [
np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
np.array([0, 1, 9, 10])
]
for lag in range(1, 10):
dtrajs_new = blocksplit_trajs(dtrajs, blocksize=lag, sliding=True)
C1 = count_matrix(dtrajs, lag, sliding=True, nstates=11).toarray()
C2 = count_matrix(dtrajs_new, lag, sliding=True,
nstates=11).toarray()
assert np.all(C1 == C2)
def test_singletraj(self):
# lag 1
C = count_matrix(self.dtraj_long, 1)
Ceff = effective_count_matrix(self.dtraj_long, 1)
assert np.array_equal(Ceff.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff.nonzero())
assert np.all(Ceff.toarray() <= C.toarray())
# lag 100
C = count_matrix(self.dtraj_long, 100)
Ceff = effective_count_matrix(self.dtraj_long, 100)
assert np.array_equal(Ceff.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff.nonzero())
assert np.all(Ceff.toarray() <= C.toarray())
def test_multitraj(self):
dtrajs = [[1, 0, 1, 0, 1, 1, 0, 0, 0, 1], [2], [0, 1, 0, 1]]
# lag 1
C = count_matrix(dtrajs, 1)
Ceff = effective_count_matrix(dtrajs, 1)
assert np.array_equal(Ceff.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff.nonzero())
assert np.all(Ceff.toarray() <= C.toarray())
# lag 2
C = count_matrix(dtrajs, 2)
Ceff = effective_count_matrix(dtrajs, 2)
assert np.array_equal(Ceff.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff.nonzero())
assert np.all(Ceff.toarray() <= C.toarray())
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
self.dtraj = bdc.msm.simulate(10000, start=0)
self.tau = 1
"""Estimate MSM"""
self.C_MSM = count_matrix(self.dtraj, self.tau, sliding=True)
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = largest_connected_submatrix(self.C_MSM,
lcc=self.lcc_MSM)
self.mle_rev_max_err = 1E-8
self.P_MSM = transition_matrix(self.Ccc_MSM,
reversible=True,
maxerr=self.mle_rev_max_err)
self.mu_MSM = stationary_distribution(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k, tau=self.tau)
def test_simulate_recover_transition_matrix(msm):
# test if transition matrix can be reconstructed
N = 5000
trajs = msm.simulate(N, seed=42)
# trajs = msmgen.generate_traj(self.P, N, random_state=self.random_state)
C = count_matrix(trajs, 1, sparse_return=False)
T = transition_matrix(C)
np.testing.assert_allclose(T, msm.transition_matrix, atol=.01)
def test_multitraj_njobs(self):
dtrajs = [[1, 0, 1, 0, 1, 1, 0, 0, 0, 1], [2], [0, 1, 0, 1]]
# lag 1
C = count_matrix(dtrajs, 1)
Ceff = effective_count_matrix(dtrajs, 1, n_jobs=1)
assert np.array_equal(Ceff.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff.nonzero())
assert np.all(Ceff.toarray() <= C.toarray())
Ceff2 = effective_count_matrix(dtrajs, 1, n_jobs=2)
np.testing.assert_equal(Ceff2.toarray(), Ceff.toarray())
np.testing.assert_allclose(Ceff2.toarray(), Ceff.toarray())
assert np.array_equal(Ceff2.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff2.nonzero())
assert np.all(Ceff2.toarray() <= C.toarray())
# lag 2
C = count_matrix(dtrajs, 2)
Ceff2 = effective_count_matrix(dtrajs, 2)
assert np.array_equal(Ceff2.shape, C.shape)
assert np.array_equal(C.nonzero(), Ceff2.nonzero())
assert np.all(Ceff2.toarray() <= C.toarray())
def test_simulate(msm):
N = 1000
traj = msm.simulate(n_steps=N, start=0, seed=42)
# test shapes and sizes
assert traj.size == N
assert traj.min() >= 0
assert traj.max() <= 1
# test statistics of transition matrix
C = count_matrix(traj, 1)
Pest = transition_matrix(C)
assert np.max(np.abs(Pest - msm.transition_matrix)) < 0.025
def setUpClass(cls):
n_states = 50
traj_length = 10000
dtraj = np.zeros(traj_length, dtype=int)
dtraj[::2] = np.random.randint(1,
n_states,
size=(traj_length - 1) // 2 + 1)
c = count_matrix(dtraj, lag=1)
while not is_connected(c, directed=True):
dtraj = np.zeros(traj_length, dtype=int)
dtraj[::2] = np.random.randint(1,
n_states,
size=(traj_length - 1) // 2 + 1)
c = count_matrix(dtraj, lag=1)
#state_counts = np.bincount(dtraj)[:,np.newaxis]
ttraj = np.zeros(traj_length, dtype=int)
btraj = np.zeros((traj_length, 1))
cls.tram_trajs = ([ttraj], [dtraj], [btraj])
cls.T_ref = transition_matrix(c, reversible=True).toarray()
def test_birth_death_chain(fixed_seed, sparse):
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = deeptime.data.birth_death_chain(q, p)
dtraj = bdc.msm.simulate(10000, start=0)
tau = 1
reference_count_matrix = msmest.count_matrix(dtraj, tau, sliding=True)
reference_largest_connected_component = msmest.largest_connected_set(
reference_count_matrix)
reference_lcs = msmest.largest_connected_submatrix(
reference_count_matrix, lcc=reference_largest_connected_component)
reference_msm = msmest.transition_matrix(reference_lcs,
reversible=True,
maxerr=1e-8)
reference_statdist = msmana.stationary_distribution(reference_msm)
k = 3
reference_timescales = msmana.timescales(reference_msm, k=k, tau=tau)
msm = estimate_markov_model(dtraj, tau, sparse=sparse)
assert_equal(tau, msm.count_model.lagtime)
assert_array_equal(reference_largest_connected_component,
msm.count_model.connected_sets()[0])
assert_(scipy.sparse.issparse(msm.count_model.count_matrix) == sparse)
assert_(scipy.sparse.issparse(msm.transition_matrix) == sparse)
if sparse:
count_matrix = msm.count_model.count_matrix.toarray()
transition_matrix = msm.transition_matrix.toarray()
else:
count_matrix = msm.count_model.count_matrix
transition_matrix = msm.transition_matrix
assert_array_almost_equal(reference_lcs.toarray(), count_matrix)
assert_array_almost_equal(reference_count_matrix.toarray(), count_matrix)
assert_array_almost_equal(reference_msm.toarray(), transition_matrix)
assert_array_almost_equal(reference_statdist, msm.stationary_distribution)
assert_array_almost_equal(reference_timescales[1:], msm.timescales(k - 1))
def count_lagged(self,
lag,
count_mode='sliding',
mincount_connectivity='1/n',
show_progress=True,
n_jobs=None,
name='',
core_set=None,
milestoning_method='last_core'):
r""" Counts transitions at given lag time
Parameters
----------
lag : int
lagtime in trajectory steps
count_mode : str, optional, default='sliding'
mode to obtain count matrices from discrete trajectories. Should be one of:
* 'sliding' : A trajectory of length T will have :math:`T-\tau` counts
at time indexes
.. math:: (0 \rightarray \tau), (1 \rightarray \tau+1), ..., (T-\tau-1 \rightarray T-1)
* 'effective' : Uses an estimate of the transition counts that are
statistically uncorrelated. Recommended when used with a
Bayesian MSM.
* 'sample' : A trajectory of length T will have :math:`T / \tau` counts
at time indexes
.. math:: (0 \rightarray \tau), (\tau \rightarray 2 \tau), ..., (((T/tau)-1) \tau \rightarray T)
show_progress: bool, default=True
show the progress for the expensive effective count mode computation.
n_jobs: int or None
"""
# store lag time
self._lag = lag
# Compute count matrix
count_mode = count_mode.lower()
if core_set is not None and count_mode in ('sliding', 'sample'):
if milestoning_method == 'last_core':
# assign -1 frames to last visited core
for d in self._dtrajs:
assert d[0] != -1
while -1 in d:
mask = (d == -1)
d[mask] = d[np.roll(mask, -1)]
self._C = count_matrix(self._dtrajs,
lag,
sliding=count_mode == 'sliding')
else:
raise NotImplementedError(
'Milestoning method {} not implemented.'.format(
milestoning_method))
else:
cm = TransitionCountEstimator(lag,
count_mode=count_mode,
sparse=True).fit(
self._dtrajs).fetch_model()
self._C = cm.count_matrix
# store mincount_connectivity
if mincount_connectivity == '1/n':
mincount_connectivity = 1.0 / np.shape(self._C)[0]
self._mincount_connectivity = mincount_connectivity
self._count_model_full = TransitionCountModel(self._C)
self._connected_sets = self._count_model_full.connected_sets(
connectivity_threshold=self._mincount_connectivity)
self._count_model = self._count_model_full.submodel_largest(
connectivity_threshold=self._mincount_connectivity)
# set sizes and count matrices on reversibly connected sets
self._connected_set_sizes = np.array(
(len(cs) for cs in self._connected_sets))
# largest connected set
self._lcs = self._connected_sets[0]
# if lcs has no counts, make lcs empty
if submatrix(self._C, self._lcs).sum() == 0:
self._lcs = np.array([], dtype=int)
# mapping from full to lcs
self._full2lcs = -1 * np.ones((self._nstates), dtype=int)
self._full2lcs[self._lcs] = np.arange(len(self._lcs))
# remember that this function was called
self._counted_at_lag = True
def setUpClass(cls, init_trammbar):
# (1-D FEL) TRAM unit test
# (1) define mu(k,x) on a fine grid, k=0 is defined as unbiased
# (2) define coarse grid (of Markov states) on x
# (3) -> compute pi from the grid definition and mu. Compute the conditional mu_i^k
# (4) -> from pi, generate transtion matrix
# (5) -> run two-level stochastic process to generate the bias trajectories
# (6) optional if init_trammbar=True, add a global equilibrium trajectory for TRAMMBAR
cls.test_trammbar = init_trammbar
# (1)
if init_trammbar:
therm_states_local = [0, 1, 3] # 2 has only equilibrium data
therm_states_global = [1, 2] # 1 has both kinds of data
else:
therm_states_local = [0, 1, 2]
therm_states_global = []
therm_states = list(set(therm_states_local).union(therm_states_global))
n_therm_states_local = len(therm_states_local)
n_therm_states_global = len(therm_states_global)
n_therm_states_total = max(therm_states) + 1
n_conf_states = 3
n_micro_states = 50
traj_length = 30000
mu = np.zeros((n_therm_states_total, n_micro_states))
for k in therm_states:
mu[k, :] = np.random.rand(n_micro_states) * 0.8 + 0.2
if k > 0:
mu[k, :] *= (np.random.rand() * 0.8 + 0.2)
energy = -np.log(mu)
# (2)
chi = np.zeros((n_micro_states, n_conf_states)) # (crisp)
for i in range(n_conf_states):
chi[n_micro_states * i // n_conf_states:n_micro_states * (i + 1) //
n_conf_states, i] = 1
assert np.allclose(chi.sum(axis=1), np.ones(n_micro_states))
# (3)
# k x i k x i
mu_joint = mu[:, :, np.newaxis] * chi[np.newaxis, :, :]
assert np.allclose(mu_joint.sum(axis=2), mu)
z = mu_joint.sum(axis=1)
pi = z / z.sum(axis=1)[:, np.newaxis]
assert np.allclose(pi.sum(axis=1), np.ones(n_therm_states_total))
mu_conditional = mu_joint / z[:, np.newaxis, :]
assert np.allclose(mu_conditional.sum(axis=1),
np.ones((n_therm_states_total, n_conf_states)))
# (4)
T = np.zeros((n_therm_states_total, n_conf_states, n_conf_states))
for k in therm_states:
T[k, :, :] = T_matrix(-np.log(pi[k, :]))
assert np.allclose(T[k, :, :].sum(axis=1), np.ones(n_conf_states))
# (5)
ttrajs = []
dtrajs = []
btrajs = []
xes = np.zeros(n_therm_states_local * traj_length, dtype=int)
C = np.zeros(
(max(therm_states_local) + 1, n_conf_states, n_conf_states),
dtype=int)
h = 0
for k in therm_states_local:
ttrajs.append(k * np.ones(traj_length, dtype=int))
dtrajs.append(
generate_simple_trajectory(T[k, :, :], traj_length, 0))
C[k, :, :] = count_matrix(dtrajs[-1], lag=1).toarray()
btraj = np.zeros((traj_length, n_therm_states_total))
btrajs.append(btraj)
for t, i in enumerate(dtrajs[-1]):
x = tower_sample(mu_conditional[k, :, i])
assert mu_conditional[k, x, i] > 0
xes[h * traj_length + t] = x
btraj[t, :] = energy[:,
x] - energy[0,
x] # define k=0 as "unbiased"
h += 1
# (6)
if init_trammbar:
eq_ttrajs = []
eq_dtrajs = []
eq_btrajs = []
eq_xes = np.zeros(n_therm_states_global * traj_length, dtype=int)
h = 0
for k in therm_states_global:
eq_ttrajs.append(k * np.ones(traj_length, dtype=int))
eq_dtrajs.append(
global_equilibrium_samples(pi[k, :], traj_length))
eq_btraj = np.zeros((traj_length, n_therm_states_total))
eq_btrajs.append(eq_btraj)
for t, i in enumerate(eq_dtrajs[-1]):
x = tower_sample(mu_conditional[k, :, i])
assert mu_conditional[k, x, i] > 0
eq_xes[h * traj_length + t] = x
eq_btraj[t, :] = energy[:, x] - energy[0, x]
h += 1
cls.n_conf_states = n_conf_states
cls.therm_states = therm_states
cls.therm_states_global = therm_states_global
cls.therm_states_local = therm_states_local
cls.n_therm_states_local = n_therm_states_local
cls.n_therm_states_global = n_therm_states_global
cls.n_micro_states = n_micro_states
cls.ttrajs = ttrajs
cls.dtrajs = dtrajs
cls.btrajs = btrajs
if not init_trammbar:
cls.eq = None
else:
cls.eq = [False
] * n_therm_states_local + [True] * n_therm_states_global
cls.eq_ttrajs = eq_ttrajs
cls.eq_dtrajs = eq_dtrajs
cls.eq_btrajs = eq_btrajs
cls.eq_xes = eq_xes
cls.z = z
cls.T = T
cls.C = C
cls.energy = energy
cls.mu = mu
cls.xes = xes
def score(self, dtrajs, score_method=None, score_k=None):
""" Scores the MSM using the dtrajs using the variational approach for Markov processes [1]_ [2]_
Currently only implemented using dense matrices - will be slow for large state spaces.
Parameters
----------
dtrajs : list of arrays
test data (discrete trajectories).
score_method : str
Overwrite scoring method if desired. If `None`, the estimators scoring
method will be used. See __init__ for documentation.
score_k : int or None
Overwrite scoring rank if desired. If `None`, the estimators scoring
rank will be used. See __init__ for documentation.
score_method : str, optional, default='VAMP2'
Overwrite scoring method to be used if desired. If `None`, the estimators scoring
method will be used.
Available scores are based on the variational approach for Markov processes [1]_ [2]_ :
* 'VAMP1' Sum of singular values of the symmetrized transition matrix [2]_ .
If the MSM is reversible, this is equal to the sum of transition
matrix eigenvalues, also called Rayleigh quotient [1]_ [3]_ .
* 'VAMP2' Sum of squared singular values of the symmetrized transition matrix [2]_ .
If the MSM is reversible, this is equal to the kinetic variance [4]_ .
score_k : int or None
The maximum number of eigenvalues or singular values used in the
score. If set to None, all available eigenvalues will be used.
References
----------
.. [1] Noe, F. and F. Nueske: A variational approach to modeling slow processes
in stochastic dynamical systems. SIAM Multiscale Model. Simul. 11, 635-655 (2013).
.. [2] Wu, H and F. Noe: Variational approach for learning Markov processes
from time series data (in preparation)
.. [3] McGibbon, R and V. S. Pande: Variational cross-validation of slow
dynamical modes in molecular kinetics, J. Chem. Phys. 142, 124105 (2015)
.. [4] Noe, F. and C. Clementi: Kinetic distance and kinetic maps from molecular
dynamics simulation. J. Chem. Theory Comput. 11, 5002-5011 (2015)
"""
dtrajs = ensure_dtraj_list(dtrajs) # ensure format
# reset estimator data if needed
if score_method is not None:
self.score_method = score_method
if score_k is not None:
self.score_k = score_k
# determine actual scoring rank
if self.score_k is None:
self.score_k = self.nstates
if self.score_k > self.nstates:
self.logger.warning('Requested scoring rank {rank} exceeds number of MSM states. '
'Reduced to score_k = {nstates}'.format(rank=self.score_k, nstates=self.nstates))
self.score_k = self.nstates # limit to nstates
# training data
K = self.transition_matrix # model
C0t_train = self.count_matrix_active
from scipy.sparse import issparse
if issparse(K): # can't deal with sparse right now.
K = K.toarray()
if issparse(C0t_train): # can't deal with sparse right now.
C0t_train = C0t_train.toarray()
C00_train = _np.diag(C0t_train.sum(axis=1)) # empirical cov
Ctt_train = _np.diag(C0t_train.sum(axis=0)) # empirical cov
# test data
C0t_test_raw = count_matrix(dtrajs, self.lag, sparse_return=False)
# map to present active set
map_from = self.active_set[_np.where(self.active_set < C0t_test_raw.shape[0])[0]]
map_to = _np.arange(len(map_from))
C0t_test = _np.zeros((self.nstates, self.nstates))
C0t_test[_np.ix_(map_to, map_to)] = C0t_test_raw[_np.ix_(map_from, map_from)]
C00_test = _np.diag(C0t_test.sum(axis=1))
Ctt_test = _np.diag(C0t_test.sum(axis=0))
# score
from pyemma.util.metrics import vamp_score
return vamp_score(K, C00_train, C0t_train, Ctt_train, C00_test, C0t_test, Ctt_test,
k=self.score_k, score=self.score_method)
def testInputList(self):
dtrajs = [0, 1, 2, 0, 0, 1, 2, 1, 0]
count_matrix(dtrajs, 1)
def testInputNestedListsDiffSize(self):
dtrajs = [[0, 1, 2, 0, 0, 1, 2, 1, 0],
[0, 1, 0, 1, 1, 1, 1, 0, 2, 1, 2, 1]]
count_matrix(dtrajs, 1)
def testInputArray(self):
dtrajs = np.array([0, 1, 2, 0, 0, 1, 2, 1, 0])
count_matrix(dtrajs, 1)
def cktest_resource():
"""Reseed the rng to enforce 'deterministic' behavior"""
rnd_state = np.random.mtrand.get_state()
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
dtraj = bdc.msm.simulate(10000, start=0)
tau = 1
"""Estimate MSM"""
MSM = estimate_markov_model(dtraj, tau)
P_MSM = MSM.transition_matrix
mu_MSM = MSM.stationary_distribution
"""Meta-stable sets"""
A = [0, 1, 2]
B = [4, 5, 6]
w_MSM = np.zeros((2, mu_MSM.shape[0]))
w_MSM[0, A] = mu_MSM[A] / mu_MSM[A].sum()
w_MSM[1, B] = mu_MSM[B] / mu_MSM[B].sum()
K = 10
P_MSM_dense = P_MSM
p_MSM = np.zeros((K, 2))
w_MSM_k = 1.0 * w_MSM
for k in range(1, K):
w_MSM_k = np.dot(w_MSM_k, P_MSM_dense)
p_MSM[k, 0] = w_MSM_k[0, A].sum()
p_MSM[k, 1] = w_MSM_k[1, B].sum()
"""Assume that sets are equal, A(\tau)=A(k \tau) for all k"""
w_MD = 1.0 * w_MSM
p_MD = np.zeros((K, 2))
eps_MD = np.zeros((K, 2))
p_MSM[0, :] = 1.0
p_MD[0, :] = 1.0
eps_MD[0, :] = 0.0
for k in range(1, K):
"""Build MSM at lagtime k*tau"""
C_MD = count_matrix(dtraj, k * tau, sliding=True) / (k * tau)
lcc_MD = largest_connected_set(C_MD)
Ccc_MD = largest_connected_submatrix(C_MD, lcc=lcc_MD)
c_MD = Ccc_MD.sum(axis=1)
P_MD = transition_matrix(Ccc_MD).toarray()
w_MD_k = np.dot(w_MD, P_MD)
"""Set A"""
prob_MD = w_MD_k[0, A].sum()
c = c_MD[A].sum()
p_MD[k, 0] = prob_MD
eps_MD[k, 0] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Set B"""
prob_MD = w_MD_k[1, B].sum()
c = c_MD[B].sum()
p_MD[k, 1] = prob_MD
eps_MD[k, 1] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Input"""
yield MSM, p_MSM, p_MD
np.random.mtrand.set_state(rnd_state)
def test_nstates_keyword(self):
C = count_matrix(self.dtrajs_short, 1, sliding=False, nstates=10)
self.assertTrue(C.shape == (10, 10))
with self.assertRaises(ValueError):
C = count_matrix(self.dtrajs_short, 1, sliding=False, nstates=1)
def test_count_matrix_mult(self):
"""Small test cases"""
C = count_matrix(self.dtrajs_short, 1, sliding=False).toarray()
assert_allclose(C, self.B1_lag)
C = count_matrix(self.dtrajs_short, 2, sliding=False).toarray()
assert_allclose(C, self.B2_lag)
C = count_matrix(self.dtrajs_short, 3, sliding=False).toarray()
assert_allclose(C, self.B3_lag)
C = count_matrix(self.dtrajs_short, 1).toarray()
assert_allclose(C, self.B1_sliding)
C = count_matrix(self.dtrajs_short, 2).toarray()
assert_allclose(C, self.B2_sliding)
C = count_matrix(self.dtrajs_short, 3).toarray()
assert_allclose(C, self.B3_sliding)
"""Larger test cases"""
C = count_matrix(self.dtrajs_long, 1, sliding=False).toarray()
assert_allclose(C, self.C1_lag)
C = count_matrix(self.dtrajs_long, 7, sliding=False).toarray()
assert_allclose(C, self.C7_lag)
C = count_matrix(self.dtrajs_long, 13, sliding=False).toarray()
assert_allclose(C, self.C13_lag)
C = count_matrix(self.dtrajs_long, 1).toarray()
assert_allclose(C, self.C1_sliding)
C = count_matrix(self.dtrajs_long, 7).toarray()
assert_allclose(C, self.C7_sliding)
C = count_matrix(self.dtrajs_long, 13).toarray()
assert_allclose(C, self.C13_sliding)
"""Test raising of value error if lag greater than trajectory length"""
with self.assertRaises(ValueError):
C = count_matrix(self.dtrajs_short, 10)
def testInputFloat(self):
dtraj_with_floats = [0.0, 1, 0, 2, 3, 1, 0.1]
# dtraj_int = [0, 1, 0, 2, 3, 1, 0]
with self.assertRaises(ValueError):
count_matrix(dtraj_with_floats, 1)
