def test_timescales(self):
P_dense = self.bdc.transition_matrix()
P = self.bdc.transition_matrix_sparse()
ev = eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
with self.assertRaises(ValueError):
tsn = timescales(P)
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""k is not None, ncv is not None"""
tsn = timescales(P, k=self.k, ncv=self.ncv)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
def test_timescales(self):
P=self.bdc.transition_matrix()
ev=eigvals(P)
"""Sort with decreasing magnitude"""
ev=ev[np.argsort(np.abs(ev))[::-1]]
ts=-1.0/np.log(np.abs(ev))
"""k=None"""
tsn=timescales(P)
self.assertTrue(np.allclose(ts[1:], tsn[1:]))
"""k is not None"""
tsn=timescales(P, k=self.k)
self.assertTrue(np.allclose(ts[1:self.k], tsn[1:]))
"""tau=7"""
"""k=None"""
tsn=timescales(P, tau=7)
self.assertTrue(np.allclose(7*ts[1:], tsn[1:]))
"""k is not None"""
tsn=timescales(P, k=self.k, tau=7)
self.assertTrue(np.allclose(7*ts[1:self.k], tsn[1:]))
def test_4_2(self):
t4 = timescales(self.P4)[1]
lags = [int(t4)]
its = ImpliedTimescales([self.dtraj4_2], lags=lags)
est = its.timescales[0]
assert (np.alltrue(est < t4 + 20.0))
assert (np.alltrue(est > t4 - 20.0))
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)
P = bdc.transition_matrix()
self.dtraj = generate_traj(P, 10000, start=0)
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtraj, self.tau, sliding=True)
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k, tau=self.tau)
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
"""Test matrix-vector product against spectral decomposition"""
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs=obs1
"""Initial distribution"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
self.one_vec = np.ones(10)
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
self.one_vec=np.ones(10)
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
"""Test matrix-vector product against spectral decomposition"""
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs = obs1
"""Initial distribution"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
def test_2(self):
t2 = timescales(self.P2)[1]
lags = [1, 2, 3, 4, 5]
its = ImpliedTimescales([self.dtraj2], lags=lags)
est = its.timescales[0]
assert (np.alltrue(est < t2 + 2.0))
assert (np.alltrue(est > t2 - 2.0))
def test_2(self):
t2 = timescales(self.P2)[1]
lags = [1, 2, 3, 4, 5]
its = ImpliedTimescales([self.dtraj2], lags=lags)
est = its.timescales[0]
assert (np.alltrue(est < t2 + 2.0))
assert (np.alltrue(est > t2 - 2.0))
def test_4_2(self):
t4 = timescales(self.P4)[1]
lags = [int(t4)]
its = ImpliedTimescales([self.dtraj4_2], lags=lags)
est = its.timescales[0]
assert (np.alltrue(est < t4 + 20.0))
assert (np.alltrue(est > t4 - 20.0))
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)
P = bdc.transition_matrix()
self.dtraj = generate_traj(P, 10000, start=0)
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtraj, self.tau, sliding=True)
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k, tau=self.tau)
def test_timescales_2(self):
"""Eigenvalues with non-zero imaginary part"""
ts = np.array([np.inf, 0.971044, 0.971044])
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
tsn = timescales(0.5 * self.T + 0.5 * self.P)
assert_allclose(tsn, ts)
assert issubclass(w[-1].category, ImaginaryEigenValueWarning)
def test_timescales(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
tsn = timescales(P)
assert_allclose(ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k=None"""
tsn = timescales(P, tau=7)
assert_allclose(7 * ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
def test_timescales_1(self):
"""Multiple eigenvalues of magnitude one,
eigenvalues with non-zero imaginary part"""
ts = np.array([np.inf, np.inf])
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
tsn = timescales(self.W)
assert_allclose(tsn, ts)
assert issubclass(w[-1].category, SpectralWarning)
def _estimate_ts_tau(self, C, tau):
r"""Estimate timescales from the given count matrix.
"""
# connected set
C = (connected_cmatrix(C)).toarray()
if (len(C) > 1):
# estimate transition matrix
T = tmatrix(C, reversible=self._reversible)
# timescales
ts = timescales(T, tau, k=min(self._nits, len(T)) + 1)[1:]
return ts
else:
return None # no timescales available
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
self.tau=7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
"""Initial vector for relaxation"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
self.tau = 7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
"""Initial vector for relaxation"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
def get_timescales(self, k):
ts=timescales(self.T, k=k, tau=self.lagtime)
return ts
def get_timescales(self, k):
ts = timescales(self.T, k=k, tau=self.lagtime)
return ts
