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 = birth_death_chain(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_4_2(self): t4 = timescales(self.P4)[1] lags = [int(t4)] its = msm.timescales_msm([self.dtraj4_2], lags=lags, n_jobs=1) est = its.timescales[0] np.testing.assert_array_less(est, t4 + 20.0) np.testing.assert_array_less(t4 - 20.0, est)
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 = birth_death_chain(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): """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_2_parallel(self): t2 = timescales(self.P2)[1] lags = [1, 2, 3, 4, 5] its = timescales_msm([self.dtraj2], lags=lags, n_jobs=1) est = its.timescales[0] np.testing.assert_array_less(est, t2 + 2.0) np.testing.assert_array_less(t2 - 2.0, est)
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_inf(): """Multiple eigenvalues of magnitude one, eigenvalues with non-zero imaginary part""" W = np.array([[0, 1], [1, 0]]) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('ignore') warnings.simplefilter('always', category=SpectralWarning) tsn = timescales(W) assert_allclose(tsn, np.array([np.inf, np.inf])) assert issubclass(w[-1].category, SpectralWarning)
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_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('ignore') warnings.simplefilter('always', category=ImaginaryEigenValueWarning) tsn = timescales(0.5 * self.T + 0.5 * self.P) assert_allclose(tsn, ts) assert issubclass(w[-1].category, ImaginaryEigenValueWarning)
def test_timescales_rev(self): P_dense = self.bdc.transition_matrix P = self.bdc.transition_matrix mu = self.bdc.stationary_distribution ev = eigvals(P_dense) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] ts = -1.0 / np.log(np.abs(ev)) tsn = timescales(P, reversible=True) assert_allclose(ts[1:], tsn[1:]) """k is not None""" tsn = timescales(P, k=self.k, reversible=True) assert_allclose(ts[1:self.k], tsn[1:]) """k is not None, mu is not None""" tsn = timescales(P, k=self.k, reversible=True, mu=mu) assert_allclose(ts[1:self.k], tsn[1:]) """tau=7""" """k is not None""" tsn = timescales(P, k=self.k, tau=7, reversible=True) assert_allclose(7 * ts[1:self.k], tsn[1:])
def test_timescales(scenario, ncv_values, tau, statdist, reversible): k, bdc = scenario P = bdc.transition_matrix mu = bdc.stationary_distribution ev = eigvals(P) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] ts = -1.0 / np.log(np.abs(ev)) with assert_raises(ValueError) if bdc.sparse and k is None else nullcontext(): tsn = timescales(P, k=k, tau=tau, mu=mu if statdist else None, reversible=reversible) assert_allclose(tau * ts[1:k], tsn[1:k])
def test_timescales_inf2(): """Eigenvalues with non-zero imaginary part""" ts = np.array([np.inf, 0.971044, 0.971044]) T = np.array([[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]]) P = np.array([[0.9, 0.1, 0.0], [0.5, 0.0, 0.5], [0.0, 0.1, 0.9]]) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('ignore') warnings.simplefilter('always', category=ImaginaryEigenValueWarning) tsn = timescales(0.5 * T + 0.5 * P) assert_allclose(tsn, ts) assert issubclass(w[-1].category, ImaginaryEigenValueWarning)
def test_fingerprint_correlation(fingerprints_data, observables): obs1, obs2 = observables T = fingerprints_data.transition_matrix ts = timescales(T, k=4 if fingerprints_data.sparse else None) R, D, L = rdl_decomposition(T, k=4 if fingerprints_data.sparse else None) mu = fingerprints_data.stationary_distribution tau = 7.5 if not fingerprints_data.sparse: """k=None, tau=1""" acorr_amp = np.dot(mu * obs1, R) * np.dot(L, obs1) tsn, acorr_ampn = fingerprint_correlation(T, obs1) assert_allclose(tsn, ts) assert_allclose(acorr_ampn, acorr_amp) """k=None, tau=7.5""" tau = tau tsn, acorr_ampn = fingerprint_correlation(T, obs1, tau=tau) assert_allclose(tsn, tau * ts) assert_allclose(acorr_ampn, acorr_amp) """k=4, tau=1""" k = 4 acorr_amp = np.dot(mu * obs1, R[:, 0:k]) * np.dot(L[0:k, :], obs1) tsn, acorr_ampn = fingerprint_correlation(T, obs1, k=k) assert_allclose(tsn, ts[0:k]) assert_allclose(acorr_ampn, acorr_amp) """k=4, tau=7.5""" tau = tau tsn, acorr_ampn = fingerprint_correlation(T, obs1, k=k, tau=tau) assert_allclose(tsn, tau * ts[0:k]) assert_allclose(acorr_ampn, acorr_amp) """Cross-correlation""" if not fingerprints_data.sparse: """k=None, tau=1""" corr_amp = np.dot(mu * obs1, R) * np.dot(L, obs2) tsn, corr_ampn = fingerprint_correlation(T, obs1, obs2=obs2) assert_allclose(tsn, ts) assert_allclose(corr_ampn, corr_amp) """k=None, tau=7.5""" tau = tau tsn, corr_ampn = fingerprint_correlation(T, obs1, obs2=obs2, tau=tau) assert_allclose(tsn, tau * ts) assert_allclose(corr_ampn, corr_amp) """k=4, tau=1""" corr_amp = np.dot(mu * obs1, R[:, 0:k]) * np.dot(L[0:k, :], obs2) tsn, corr_ampn = fingerprint_correlation(T, obs1, obs2=obs2, k=k) assert_allclose(tsn, ts[0:k]) assert_allclose(corr_ampn, corr_amp) """k=4, tau=7.5""" tsn, corr_ampn = fingerprint_correlation(T, obs1, obs2=obs2, k=k, tau=tau) assert_allclose(tsn, tau * ts[0:k]) assert_allclose(corr_ampn, corr_amp)
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 test_fingerprint_relaxation(fingerprints_data, observables): obs1, obs2 = observables T = fingerprints_data.transition_matrix ts = timescales(T, k=4 if fingerprints_data.sparse else None) R, D, L = rdl_decomposition(T, k=4 if fingerprints_data.sparse else None) """Initial vector for relaxation""" p0 = np.zeros(10) p0[0:4] = 0.25 if not fingerprints_data.sparse: """k=None""" relax_amp = np.dot(p0, R) * np.dot(L, obs1) tsn, relax_ampn = fingerprint_relaxation(T, p0, obs1) assert_allclose(tsn, ts) assert_allclose(relax_ampn, relax_amp) """k=4""" k = 4 relax_amp = np.dot(p0, R[:, 0:k]) * np.dot(L[0:k, :], obs1) tsn, relax_ampn = fingerprint_relaxation(T, p0, obs1, k=k) assert_allclose(tsn, ts[0:k]) assert_allclose(relax_ampn, relax_amp)
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 = birth_death_chain(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