class TestCommittorDense(unittest.TestCase): def setUp(self): 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) def tearDown(self): pass def test_forward_comittor(self): P = self.bdc.transition_matrix() un = committor(P, [0, 1], [8, 9], forward=True) u = self.bdc.committor_forward(1, 8) assert_allclose(un, u) def test_backward_comittor(self): P = self.bdc.transition_matrix() un = committor(P, [0, 1], [8, 9], forward=False) u = self.bdc.committor_backward(1, 8) assert_allclose(un, u)
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)
class TestCommittorSparse(unittest.TestCase): def setUp(self): p = np.zeros(100) q = np.zeros(100) p[0:-1] = 0.5 q[1:] = 0.5 p[49] = 0.01 q[51] = 0.1 self.bdc = BirthDeathChain(q, p) def tearDown(self): pass def test_forward_comittor(self): P = self.bdc.transition_matrix_sparse() un = committor(P, range(10), range(90, 100), forward=True) u = self.bdc.committor_forward(9, 90) assert_allclose(un, u) def test_backward_comittor(self): P = self.bdc.transition_matrix_sparse() un = committor(P, range(10), range(90, 100), forward=False) u = self.bdc.committor_backward(9, 90) assert_allclose(un, u)
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): """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.dtrajs = [generate_traj(P, 10000, start=0)] self.tau = 1 """Estimate MSM""" self.C_MSM = cmatrix(self.dtrajs, self.tau, sliding=True).toarray() 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 + 1, tau=self.tau)[1:]
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.dtrajs = [generate_traj(P, 10000, start=0)] self.tau = 1 """Estimate MSM""" self.C_MSM = cmatrix(self.dtrajs, self.tau, sliding=True).toarray() 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+1, tau=self.tau)[1:]
def setUp(self): p = np.zeros(100) q = np.zeros(100) p[0:-1] = 0.5 q[1:] = 0.5 p[49] = 0.01 q[51] = 0.1 self.bdc = BirthDeathChain(q, p)
class TestCorrelationSparse(unittest.TestCase): 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 test_correlation(self): """Auto-correlation""" acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot( self.L, self.obs1) acorr = np.dot(self.ev_t, acorr_amp) acorrn = correlation(self.T, self.obs1, k=self.k, times=self.times) assert_allclose(acorrn, acorr) """Cross-correlation""" corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot( self.L, self.obs2) corr = np.dot(self.ev_t, corr_amp) corrn = correlation(self.T, self.obs1, obs2=self.obs2, k=self.k, times=self.times) assert_allclose(corrn, corr)
def setUp(self): 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.T = self.bdc.transition_matrix() self.mu = self.bdc.stationary_distribution() self.A = create_rate_matrix()
class TestRelaxationDense(unittest.TestCase): def setUp(self): 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() """Test matrix-vector product against spectral decomposition""" R, D, L=rdl_decomposition(self.T) self.L=L self.R=R self.ts=timescales(self.T) self.times=np.array([1, 5, 10, 20, 100]) ev=np.diagonal(D) self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis] self.k=4 """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_relaxation(self): """k=None""" relax_amp=np.dot(self.p0, self.R)*np.dot(self.L, self.obs) relax=np.dot(self.ev_t, relax_amp) relaxn=relaxation(self.T, self.p0, self.obs, times=self.times) self.assertTrue(np.allclose(relaxn, relax)) """k=4""" k=self.k relax_amp=np.dot(self.p0, self.R[:,0:k])*np.dot(self.L[0:k,:], self.obs) relax=np.dot(self.ev_t[:,0:k], relax_amp) relaxn=relaxation(self.T, self.p0, self.obs, k=k, times=self.times) self.assertTrue(np.allclose(relaxn, relax))
def setUp(self): self.dim = 100 self.k = 10 """Set up meta-stable birth-death chain""" p = np.zeros(self.dim) p[0:-1] = 0.5 q = np.zeros(self.dim) q[1:] = 0.5 p[self.dim / 2 - 1] = 0.001 q[self.dim / 2 + 1] = 0.001 self.bdc = BirthDeathChain(q, p)
class TestRelaxationDense(unittest.TestCase): def setUp(self): 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() """Test matrix-vector product against spectral decomposition""" R, D, L = rdl_decomposition(self.T) self.L = L self.R = R self.ts = timescales(self.T) self.times = np.array([1, 5, 10, 20, 100]) ev = np.diagonal(D) self.ev_t = ev[np.newaxis, :] ** self.times[:, np.newaxis] self.k = 4 """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_relaxation(self): """k=None""" relax_amp = np.dot(self.p0, self.R) * np.dot(self.L, self.obs) relax = np.dot(self.ev_t, relax_amp) relaxn = relaxation(self.T, self.p0, self.obs, times=self.times) assert_allclose(relaxn, relax) """k=4""" k = self.k relax_amp = np.dot(self.p0, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs) relax = np.dot(self.ev_t[:, 0:k], relax_amp) relaxn = relaxation(self.T, self.p0, self.obs, k=k, times=self.times) assert_allclose(relaxn, relax)
class TestCorrelationSparse(unittest.TestCase): 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 test_correlation(self): """Auto-correlation""" acorr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L, self.obs1) acorr=np.dot(self.ev_t, acorr_amp) acorrn=correlation(self.T, self.obs1, k=self.k, times=self.times) self.assertTrue(np.allclose(acorrn, acorr)) """Cross-correlation""" corr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L, self.obs2) corr=np.dot(self.ev_t, corr_amp) corrn=correlation(self.T, self.obs1, obs2=self.obs2, k=self.k, times=self.times) self.assertTrue(np.allclose(corrn, corr))
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)
class TestAssessmentDense(unittest.TestCase): def setUp(self): 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.T = self.bdc.transition_matrix() self.mu = self.bdc.stationary_distribution() self.A = create_rate_matrix() def test_IsRateMatrix(self): self.assert_(is_rate_matrix(self.A), \ 'A should be a rate matrix') # manipulate matrix so it isn't a rate matrix any more self.A[0][0] = 3 self.assertFalse(is_rate_matrix(self.A), \ 'matrix is not a rate matrix') def test_IsReversible(self): # create a reversible matrix self.assertTrue(is_reversible(self.T, self.mu), "T should be reversible") def test_is_transition_matrix(self): self.assertTrue(is_transition_matrix(self.T)) """Larger test-case to prevent too restrictive tolerance settings""" X=np.random.random((2000, 2000)) Tlarge=X/X.sum(axis=1)[:,np.newaxis] self.assertTrue(is_transition_matrix(Tlarge)) def test_is_connected(self): self.assertTrue(is_connected(self.T)) self.assertTrue(is_connected(self.T, directed=False))
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
class TestAssessmentDense(unittest.TestCase): def setUp(self): 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.T = self.bdc.transition_matrix() self.mu = self.bdc.stationary_distribution() self.A = create_rate_matrix() def test_IsRateMatrix(self): self.assert_(is_rate_matrix(self.A), 'A should be a rate matrix') # manipulate matrix so it isn't a rate matrix any more self.A[0][0] = 3 self.assertFalse(is_rate_matrix(self.A), 'matrix is not a rate matrix') def test_IsReversible(self): # create a reversible matrix self.assertTrue(is_reversible(self.T, self.mu), "T should be reversible") def test_is_transition_matrix(self): self.assertTrue(is_transition_matrix(self.T)) """Larger test-case to prevent too restrictive tolerance settings""" X = np.random.random((2000, 2000)) Tlarge = X / X.sum(axis=1)[:, np.newaxis] self.assertTrue(is_transition_matrix(Tlarge)) def test_is_connected(self): self.assertTrue(is_connected(self.T)) self.assertTrue(is_connected(self.T, directed=False))
def setUp(self): self.dim=100 self.k=10 """Set up meta-stable birth-death chain""" p=np.zeros(self.dim) p[0:-1]=0.5 q=np.zeros(self.dim) q[1:]=0.5 p[self.dim/2-1]=0.001 q[self.dim/2+1]=0.001 self.bdc=BirthDeathChain(q, p)
class TestAssessmentDense(unittest.TestCase): def setUp(self): 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.T = self.bdc.transition_matrix() self.mu = self.bdc.stationary_distribution() self.A = create_rate_matrix() def test_IsRateMatrix(self): self.assert_(is_rate_matrix(self.A), \ 'A should be a rate matrix') # manipulate matrix so it isn't a rate matrix any more self.A[0][0] = 3 self.assertFalse(is_rate_matrix(self.A), \ 'matrix is not a rate matrix') def test_IsReversible(self): # create a reversible matrix self.assertTrue(is_reversible(self.T, self.mu), "T should be reversible") def test_is_transition_matrix(self): self.assertTrue(is_transition_matrix(self.T)) def test_is_connected(self): self.assertTrue(is_connected(self.T)) self.assertTrue(is_connected(self.T, directed=False))
class TestExpectation(unittest.TestCase): def setUp(self): 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() obs1 = np.zeros(10) obs1[0] = 1 obs1[1] = 1 self.obs1 = obs1 def test_expectation(self): exp = np.dot(self.mu, self.obs1) expn = expectation(self.T, self.obs1) assert_allclose(exp, expn)
class TestExpectation(unittest.TestCase): def setUp(self): 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() obs1 = np.zeros(10) obs1[0] = 1 obs1[1] = 1 self.obs1=obs1 def test_expectation(self): exp=np.dot(self.mu, self.obs1) expn=expectation(self.T, self.obs1) self.assertTrue(np.allclose(exp, expn))
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
class TestDecomposition(unittest.TestCase): def setUp(self): self.dim = 100 self.k = 10 self.ncv = 40 """Set up meta-stable birth-death chain""" p = np.zeros(self.dim) p[0:-1] = 0.5 q = np.zeros(self.dim) q[1:] = 0.5 p[self.dim / 2 - 1] = 0.001 q[self.dim / 2 + 1] = 0.001 self.bdc = BirthDeathChain(q, p) def test_statdist_decomposition(self): P = self.bdc.transition_matrix_sparse() mu = self.bdc.stationary_distribution() mun = stationary_distribution_from_eigenvector(P, ncv=self.ncv) assert_allclose(mu, mun) def test_statdist_iteration(self): P = self.bdc.transition_matrix_sparse() mu = self.bdc.stationary_distribution() mun = stationary_distribution_from_backward_iteration(P) assert_allclose(mu, mun) def test_eigenvalues(self): P = self.bdc.transition_matrix() P_dense = self.bdc.transition_matrix() ev = eigvals(P_dense) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] """k=None""" with self.assertRaises(ValueError): evn = eigenvalues(P) """k is not None""" evn = eigenvalues(P, k=self.k) assert_allclose(ev[0:self.k], evn) """k is not None and ncv is not None""" evn = eigenvalues(P, k=self.k, ncv=self.ncv) assert_allclose(ev[0:self.k], evn) def test_eigenvectors(self): P_dense = self.bdc.transition_matrix() P = self.bdc.transition_matrix_sparse() ev, L, R = eig(P_dense, left=True, right=True) ind = np.argsort(np.abs(ev))[::-1] ev = ev[ind] R = R[:, ind] L = L[:, ind] vals = ev[0:self.k] """k=None""" with self.assertRaises(ValueError): Rn = eigenvectors(P) with self.assertRaises(ValueError): Ln = eigenvectors(P, right=False) """k is not None""" Rn = eigenvectors(P, k=self.k) assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn)) Ln = eigenvectors(P, right=False, k=self.k) assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln) """k is not None and ncv is not None""" Rn = eigenvectors(P, k=self.k, ncv=self.ncv) assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn)) Ln = eigenvectors(P, right=False, k=self.k, ncv=self.ncv) assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln) def test_rdl_decomposition(self): P = self.bdc.transition_matrix_sparse() mu = self.bdc.stationary_distribution() """Non-reversible""" """k=None""" with self.assertRaises(ValueError): Rn, Dn, Ln = rdl_decomposition(P) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(P.dot(Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """k is not None, ncv is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, ncv=self.ncv) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(P.dot(Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversible""" """k=None""" with self.assertRaises(ValueError): Rn, Dn, Ln = rdl_decomposition(P, norm='reversible') """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, norm='reversible') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(P.dot(Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """k is not None ncv is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, norm='reversible', ncv=self.ncv) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(P.dot(Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) 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:])
class TestDecompositionDense(unittest.TestCase): def setUp(self): self.dim = 100 self.k = 10 """Set up meta-stable birth-death chain""" p = np.zeros(self.dim) p[0:-1] = 0.5 q = np.zeros(self.dim) q[1:] = 0.5 p[int(self.dim / 2 - 1)] = 0.001 q[int(self.dim / 2 + 1)] = 0.001 self.bdc = BirthDeathChain(q, p) def test_statdist(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() mun = stationary_distribution(P) assert_allclose(mu, mun) def test_eigenvalues(self): P = self.bdc.transition_matrix() ev = eigvals(P) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] """k=None""" evn = eigenvalues(P) assert_allclose(ev, evn) """k is not None""" evn = eigenvalues(P, k=self.k) assert_allclose(ev[0:self.k], evn) def test_eigenvectors(self): P = self.bdc.transition_matrix() # k==None ev = eigvals(P) ev = ev[np.argsort(np.abs(ev))[::-1]] Dn = np.diag(ev) # right eigenvectors Rn = eigenvectors(P) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dn)) # left eigenvectors Ln = eigenvectors(P, right=False).T assert_allclose(np.dot(Ln.T,P),np.dot(Dn,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(Xn.shape[0]) Xn[di] = 0.0 assert_allclose(Xn,0) # k!=None Dnk = Dn[:,0:self.k][0:self.k,:] # right eigenvectors Rn = eigenvectors(P, k=self.k) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dnk)) # left eigenvectors Ln = eigenvectors(P, right=False, k=self.k).T assert_allclose(np.dot(Ln.T,P),np.dot(Dnk,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(self.k) Xn[di] = 0.0 assert_allclose(Xn,0) def test_eigenvalues_reversible(self): P = self.bdc.transition_matrix() ev = eigvals(P) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] """reversible without given mu""" evn = eigenvalues(P, reversible=True) assert_allclose(ev, evn) """reversible with given mu""" evn = eigenvalues(P, reversible=True, mu=self.bdc.stationary_distribution()) assert_allclose(ev, evn) def test_eigenvectors_reversible(self): P = self.bdc.transition_matrix() # k==None ev = eigvals(P) ev = ev[np.argsort(np.abs(ev))[::-1]] Dn = np.diag(ev) # right eigenvectors Rn = eigenvectors(P, reversible=True) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dn)) # left eigenvectors Ln = eigenvectors(P, right=False, reversible=True).T assert_allclose(np.dot(Ln.T,P),np.dot(Dn,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(Xn.shape[0]) Xn[di] = 0.0 assert_allclose(Xn,0) # k!=None Dnk = Dn[:,0:self.k][0:self.k,:] # right eigenvectors Rn = eigenvectors(P, k=self.k, reversible=True) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dnk)) # left eigenvectors Ln = eigenvectors(P, right=False, k=self.k, reversible=True).T assert_allclose(np.dot(Ln.T,P),np.dot(Dnk,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(self.k) Xn[di] = 0.0 assert_allclose(Xn,0) def test_rdl_decomposition(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() """Non-reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible', k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) def test_rdl_decomposition_rev(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() """norm='standard'""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='standard') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Standard l2-normalization of right eigenvectors except dominant one""" Yn = np.dot(Rn.T, Rn) assert_allclose(np.diag(Yn)[1:], 1.0) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, reversible=True, norm='standard') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Standard l2-normalization of right eigenvectors except dominant one""" Yn = np.dot(Rn.T, Rn) assert_allclose(np.diag(Yn)[1:], 1.0) """norm='reversible'""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible', k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) 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_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:])
class TestDecompositionDense(unittest.TestCase): def setUp(self): self.dim = 100 self.k = 10 """Set up meta-stable birth-death chain""" p = np.zeros(self.dim) p[0:-1] = 0.5 q = np.zeros(self.dim) q[1:] = 0.5 p[self.dim / 2 - 1] = 0.001 q[self.dim / 2 + 1] = 0.001 self.bdc = BirthDeathChain(q, p) def test_statdist(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() mun = stationary_distribution(P) assert_allclose(mu, mun) def test_eigenvalues(self): P = self.bdc.transition_matrix() ev = eigvals(P) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] """k=None""" evn = eigenvalues(P) assert_allclose(ev, evn) """k is not None""" evn = eigenvalues(P, k=self.k) assert_allclose(ev[0:self.k], evn) def test_eigenvectors(self): P = self.bdc.transition_matrix() # k==None ev = eigvals(P) ev = ev[np.argsort(np.abs(ev))[::-1]] Dn = np.diag(ev) # right eigenvectors Rn = eigenvectors(P) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dn)) # left eigenvectors Ln = eigenvectors(P, right=False) assert_allclose(np.dot(Ln.T,P),np.dot(Dn,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(Xn.shape[0]) Xn[di] = 0.0 assert_allclose(Xn,0) # k!=None Dnk = Dn[:,0:self.k][0:self.k,:] # right eigenvectors Rn = eigenvectors(P, k=self.k) assert_allclose(np.dot(P,Rn),np.dot(Rn,Dnk)) # left eigenvectors Ln = eigenvectors(P, right=False, k=self.k) assert_allclose(np.dot(Ln.T,P),np.dot(Dnk,Ln.T)) # orthogonality Xn = np.dot(Ln.T, Rn) di = np.diag_indices(self.k) Xn[di] = 0.0 assert_allclose(Xn,0) def test_rdl_decomposition(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() """Non-reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible', k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) 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:])
class TestCorrelationDense(unittest.TestCase): def setUp(self): 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() R, D, L = rdl_decomposition(self.T, norm='reversible') self.L = L self.R = R self.ts = timescales(self.T) self.times = np.array([1, 5, 10, 20, 100]) ev = np.diagonal(D) self.ev_t = ev[np.newaxis, :] ** self.times[:, np.newaxis] self.k = 4 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 test_correlation(self): """Auto-correlation""" """k=None""" acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(self.L, self.obs1) acorr = np.dot(self.ev_t, acorr_amp) acorrn = correlation(self.T, self.obs1, times=self.times) assert_allclose(acorrn, acorr) """k=4""" k = self.k acorr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs1) acorr = np.dot(self.ev_t[:, 0:k], acorr_amp) acorrn = correlation(self.T, self.obs1, times=self.times, k=k) assert_allclose(acorrn, acorr) """Cross-correlation""" """k=None""" corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(self.L, self.obs2) corr = np.dot(self.ev_t, corr_amp) corrn = correlation(self.T, self.obs1, obs2=self.obs2, times=self.times) assert_allclose(corrn, corr) """k=4""" k = self.k corr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs2) corr = np.dot(self.ev_t[:, 0:k], corr_amp) corrn = correlation(self.T, self.obs1, obs2=self.obs2, times=self.times, k=k) assert_allclose(corrn, corr)
class TestFingerprintSparse(unittest.TestCase): 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 test_fingerprint_correlation(self): """Autocorrelation""" """k=4, tau=1""" k = self.k acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot( self.L, self.obs1) tsn, acorr_ampn = fingerprint_correlation(self.T, self.obs1, k=k) assert_allclose(tsn, self.ts) assert_allclose(acorr_ampn, acorr_amp) """k=4, tau=7.5""" tau = self.tau tsn, acorr_ampn = fingerprint_correlation(self.T, self.obs1, k=k, tau=tau) assert_allclose(tsn, tau * self.ts) assert_allclose(acorr_ampn, acorr_amp) """Cross-correlation""" """k=4, tau=1""" k = self.k corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot( self.L, self.obs2) tsn, corr_ampn = fingerprint_correlation(self.T, self.obs1, obs2=self.obs2, k=k) assert_allclose(tsn, self.ts) assert_allclose(corr_ampn, corr_amp) """k=4, tau=7.5""" tau = self.tau tsn, corr_ampn = fingerprint_correlation(self.T, self.obs1, obs2=self.obs2, k=k, tau=tau) assert_allclose(tsn, tau * self.ts) assert_allclose(corr_ampn, corr_amp) def test_fingerprint_relaxation(self): one_vec = np.ones(self.T.shape[0]) relax_amp = np.dot(self.p0, self.R) * np.dot(self.L, self.obs1) tsn, relax_ampn = fingerprint_relaxation(self.T, self.p0, self.obs1, k=self.k) assert_allclose(tsn, self.ts) assert_allclose(relax_ampn, relax_amp)
class TestDecomposition(unittest.TestCase): def setUp(self): self.dim=100 self.k=10 self.ncv=40 """Set up meta-stable birth-death chain""" p=np.zeros(self.dim) p[0:-1]=0.5 q=np.zeros(self.dim) q[1:]=0.5 p[self.dim/2-1]=0.001 q[self.dim/2+1]=0.001 self.bdc=BirthDeathChain(q, p) def test_statdist_decomposition(self): P=self.bdc.transition_matrix_sparse() mu=self.bdc.stationary_distribution() mun=stationary_distribution_from_eigenvector(P, ncv=self.ncv) self.assertTrue(np.allclose(mu, mun)) def test_statdist_iteration(self): P=self.bdc.transition_matrix_sparse() mu=self.bdc.stationary_distribution() mun=stationary_distribution_from_backward_iteration(P) self.assertTrue(np.allclose(mu, mun)) def test_eigenvalues(self): P=self.bdc.transition_matrix() P_dense=self.bdc.transition_matrix() ev=eigvals(P_dense) """Sort with decreasing magnitude""" ev=ev[np.argsort(np.abs(ev))[::-1]] """k=None""" with self.assertRaises(ValueError): evn=eigenvalues(P) """k is not None""" evn=eigenvalues(P, k=self.k) self.assertTrue(np.allclose(ev[0:self.k], evn)) """k is not None and ncv is not None""" evn=eigenvalues(P, k=self.k, ncv=self.ncv) self.assertTrue(np.allclose(ev[0:self.k], evn)) def test_eigenvectors(self): P_dense=self.bdc.transition_matrix() P=self.bdc.transition_matrix_sparse() ev, L, R=eig(P_dense, left=True, right=True) ind=np.argsort(np.abs(ev))[::-1] ev=ev[ind] R=R[:,ind] L=L[:,ind] vals=ev[0:self.k] """k=None""" with self.assertRaises(ValueError): Rn=eigenvectors(P) with self.assertRaises(ValueError): Ln=eigenvectors(P, right=False) """k is not None""" Rn=eigenvectors(P, k=self.k) self.assertTrue(np.allclose(vals[np.newaxis,:]*Rn, P.dot(Rn))) Ln=eigenvectors(P, right=False, k=self.k) self.assertTrue(np.allclose(P.transpose().dot(Ln), vals[np.newaxis,:]*Ln)) """k is not None and ncv is not None""" Rn=eigenvectors(P, k=self.k, ncv=self.ncv) self.assertTrue(np.allclose(vals[np.newaxis,:]*Rn, P.dot(Rn))) Ln=eigenvectors(P, right=False, k=self.k, ncv=self.ncv) self.assertTrue(np.allclose(P.transpose().dot(Ln), vals[np.newaxis,:]*Ln)) def test_rdl_decomposition(self): P=self.bdc.transition_matrix_sparse() mu=self.bdc.stationary_distribution() """Non-reversible""" """k=None""" with self.assertRaises(ValueError): Rn, Dn, Ln=rdl_decomposition(P) """k is not None""" Rn, Dn, Ln=rdl_decomposition(P, k=self.k) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """k is not None, ncv is not None""" Rn, Dn, Ln=rdl_decomposition(P, k=self.k, ncv=self.ncv) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversible""" """k=None""" with self.assertRaises(ValueError): Rn, Dn, Ln=rdl_decomposition(P, norm='reversible') """k is not None""" Rn, Dn, Ln=rdl_decomposition(P, k=self.k, norm='reversible') Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversibility""" self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn)) """k is not None ncv is not None""" Rn, Dn, Ln=rdl_decomposition(P, k=self.k, norm='reversible', ncv=self.ncv) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversibility""" self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn)) 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) self.assertTrue(np.allclose(ts[1:self.k], tsn[1:])) """k is not None, ncv is not None""" tsn=timescales(P, k=self.k, ncv=self.ncv) self.assertTrue(np.allclose(ts[1:self.k], tsn[1:])) """tau=7""" """k is not None""" tsn=timescales(P, k=self.k, tau=7) self.assertTrue(np.allclose(7*ts[1:self.k], tsn[1:]))
class TestDecompositionDense(unittest.TestCase): def setUp(self): self.dim=100 self.k=10 """Set up meta-stable birth-death chain""" p=np.zeros(self.dim) p[0:-1]=0.5 q=np.zeros(self.dim) q[1:]=0.5 p[self.dim/2-1]=0.001 q[self.dim/2+1]=0.001 self.bdc=BirthDeathChain(q, p) def test_statdist(self): P=self.bdc.transition_matrix() mu=self.bdc.stationary_distribution() mun=stationary_distribution(P) self.assertTrue(np.allclose(mu, mun)) def test_eigenvalues(self): P=self.bdc.transition_matrix() ev=eigvals(P) """Sort with decreasing magnitude""" ev=ev[np.argsort(np.abs(ev))[::-1]] """k=None""" evn=eigenvalues(P) self.assertTrue(np.allclose(ev, evn)) """k is not None""" evn=eigenvalues(P, k=self.k) self.assertTrue(np.allclose(ev[0:self.k], evn)) def test_eigenvectors(self): P=self.bdc.transition_matrix() ev, L, R=eig(P, left=True, right=True) ind=np.argsort(np.abs(ev))[::-1] R=R[:,ind] L=L[:,ind] """k=None""" Rn=eigenvectors(P) self.assertTrue(np.allclose(R, Rn)) Ln=eigenvectors(P, right=False) self.assertTrue(np.allclose(L, Ln)) """k is not None""" Rn=eigenvectors(P, k=self.k) self.assertTrue(np.allclose(R[:,0:self.k], Rn)) Ln=eigenvectors(P, right=False, k=self.k) self.assertTrue(np.allclose(L[:,0:self.k], Ln)) def test_rdl_decomposition(self): P=self.bdc.transition_matrix() mu=self.bdc.stationary_distribution() """Non-reversible""" """k=None""" Rn, Dn, Ln=rdl_decomposition(P) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.dim))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """k is not None""" Rn, Dn, Ln=rdl_decomposition(P, k=self.k) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversible""" """k=None""" Rn, Dn, Ln=rdl_decomposition(P, norm='reversible') Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.dim))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversibility""" self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn)) """k is not None""" Rn, Dn, Ln=rdl_decomposition(P, norm='reversible', k=self.k) Xn=np.dot(Ln, Rn) """Right-eigenvectors""" self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn))) """Left-eigenvectors""" self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln))) """Orthonormality""" self.assertTrue(np.allclose(Xn, np.eye(self.k))) """Probability vector""" self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0)) """Reversibility""" self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn)) 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:]))
class TestFingerprintSparse(unittest.TestCase): 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 test_fingerprint_correlation(self): """Autocorrelation""" """k=4, tau=1""" k=self.k acorr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L,self.obs1) tsn, acorr_ampn=fingerprint_correlation(self.T, self.obs1, k=k) self.assertTrue(np.allclose(tsn, self.ts)) self.assertTrue(np.allclose(acorr_ampn, acorr_amp)) """k=4, tau=7.5""" tau=self.tau tsn, acorr_ampn=fingerprint_correlation(self.T, self.obs1, k=k, tau=tau) self.assertTrue(np.allclose(tsn, tau*self.ts)) self.assertTrue(np.allclose(acorr_ampn, acorr_amp)) """Cross-correlation""" """k=4, tau=1""" k=self.k corr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L,self.obs2) tsn, corr_ampn=fingerprint_correlation(self.T, self.obs1, obs2=self.obs2, k=k) self.assertTrue(np.allclose(tsn, self.ts)) self.assertTrue(np.allclose(corr_ampn, corr_amp)) """k=4, tau=7.5""" tau=self.tau tsn, corr_ampn=fingerprint_correlation(self.T, self.obs1, obs2=self.obs2, k=k, tau=tau) self.assertTrue(np.allclose(tsn, tau*self.ts)) self.assertTrue(np.allclose(corr_ampn, corr_amp)) def test_fingerprint_relaxation(self): one_vec=np.ones(self.T.shape[0]) relax_amp=np.dot(self.p0, self.R)*np.dot(self.L, self.obs1) tsn, relax_ampn=fingerprint_relaxation(self.T, self.p0, self.obs1, k=self.k) self.assertTrue(np.allclose(tsn, self.ts)) self.assertTrue(np.allclose(relax_ampn, relax_amp))
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() dtraj = generate_traj(P, 10000, start=0) tau = 1 """Estimate MSM""" C_MSM = cmatrix(dtraj, tau) lcc_MSM = largest_connected_set(C_MSM) Ccc_MSM = connected_cmatrix(C_MSM, lcc=lcc_MSM) P_MSM = tmatrix(Ccc_MSM) mu_MSM = statdist(P_MSM) """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.toarray() 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 = cmatrix(dtraj, k * tau, sliding=True) / (k * tau) lcc_MD = largest_connected_set(C_MD) Ccc_MD = connected_cmatrix(C_MD, lcc=lcc_MD) c_MD = Ccc_MD.sum(axis=1) P_MD = tmatrix(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""" self.P_MSM = P_MSM self.lcc_MSM = lcc_MSM self.dtraj = dtraj self.tau = tau self.K = K self.A = A self.B = B """Expected results""" self.p_MSM = p_MSM self.p_MD = p_MD self.eps_MD = eps_MD
class TestDecompositionDense(unittest.TestCase): def setUp(self): self.dim = 100 self.k = 10 """Set up meta-stable birth-death chain""" p = np.zeros(self.dim) p[0:-1] = 0.5 q = np.zeros(self.dim) q[1:] = 0.5 p[self.dim / 2 - 1] = 0.001 q[self.dim / 2 + 1] = 0.001 self.bdc = BirthDeathChain(q, p) def test_statdist(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() mun = stationary_distribution(P) assert_allclose(mu, mun) def test_eigenvalues(self): P = self.bdc.transition_matrix() ev = eigvals(P) """Sort with decreasing magnitude""" ev = ev[np.argsort(np.abs(ev))[::-1]] """k=None""" evn = eigenvalues(P) assert_allclose(ev, evn) """k is not None""" evn = eigenvalues(P, k=self.k) assert_allclose(ev[0:self.k], evn) def test_eigenvectors(self): P = self.bdc.transition_matrix() ev, L, R = eig(P, left=True, right=True) ind = np.argsort(np.abs(ev))[::-1] R = R[:, ind] L = L[:, ind] """k=None""" Rn = eigenvectors(P) assert_allclose(R, Rn) Ln = eigenvectors(P, right=False) assert_allclose(L, Ln) """k is not None""" Rn = eigenvectors(P, k=self.k) assert_allclose(R[:, 0:self.k], Rn) Ln = eigenvectors(P, right=False, k=self.k) assert_allclose(L[:, 0:self.k], Ln) def test_rdl_decomposition(self): P = self.bdc.transition_matrix() mu = self.bdc.stationary_distribution() """Non-reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversible""" """k=None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible') Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.dim)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """k is not None""" Rn, Dn, Ln = rdl_decomposition(P, norm='reversible', k=self.k) Xn = np.dot(Ln, Rn) """Right-eigenvectors""" assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn)) """Left-eigenvectors""" assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln)) """Orthonormality""" assert_allclose(Xn, np.eye(self.k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) 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:])