def test_rdl_decomposition(self): P = self.bdc.transition_matrix assert is_reversible(P) 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') assert Dn.dtype in (np.float32, np.float64) 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 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 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 test_relaxation(fingerprints_data): T = fingerprints_data.transition_matrix R, D, L = rdl_decomposition(T, k=4 if fingerprints_data.sparse else None) times = np.array([1, 5, 10, 20, 100]) ev = np.diagonal(D) ev_t = ev[np.newaxis, :]**times[:, np.newaxis] obs = np.zeros(10) obs[0] = 1 obs[1] = 1 p0 = np.zeros(10) p0[:4] = 0.25 if not fingerprints_data.sparse: """k=None""" relax_amp = np.dot(p0, R) * np.dot(L, obs) relax = np.dot(ev_t, relax_amp) relaxn = relaxation(T, p0, obs, times=times) assert_allclose(relaxn, relax) """k=4""" k = 4 relax_amp = np.dot(p0, R[:, 0:k]) * np.dot(L[0:k, :], obs) relax = np.dot(ev_t[:, 0:k], relax_amp) relaxn = relaxation(T, p0, obs, k=k, times=times) assert_allclose(relaxn, relax)
def test_rdl_decomposition(scenario, ncv_values, norm, statdist, reversible): k, bdc = scenario dim = bdc.q.shape[0] P = bdc.transition_matrix mu = bdc.stationary_distribution with assert_raises(ValueError) if bdc.sparse and k is None else nullcontext(): Rn, Dn, Ln = rdl_decomposition(P, reversible=reversible, norm=norm, ncv=ncv_values, k=k, mu=mu if statdist else None) Xn = Ln @ Rn """Right-eigenvectors""" assert_allclose(P @ Rn, Rn @ Dn) """Left-eigenvectors""" assert_allclose(Ln @ P, Dn @ Ln) """Orthonormality""" assert_allclose(Xn, np.eye(dim if k is None else k)) """Probability vector""" assert_allclose(np.sum(Ln[0, :]), 1.0) if norm == 'standard' and reversible: """Standard l2-normalization of right eigenvectors except dominant one""" Yn = Rn.T @ Rn assert_allclose(np.diag(Yn)[1:], 1.0) if norm == 'reversible': """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
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 _compute_eigendecomposition(self, neig): """ Conducts the eigenvalue decomposition and stores k eigenvalues, left and right eigenvectors """ self._p_id = _hash_numpy_array(self.transition_matrix) from deeptime.markov.tools.analysis import rdl_decomposition if self.reversible: self._R, self._D, self._L = rdl_decomposition(self.transition_matrix, norm='reversible', k=neig, ncv=self.ncv) # everything must be real-valued self._R = self._R.real self._D = self._D.real self._L = self._L.real else: self._R, self._D, self._L = rdl_decomposition(self.transition_matrix, k=neig, norm='standard', ncv=self.ncv) # if the imaginary parts are zero, discard them. if _np.all(self._R.imag == 0): self._R = _np.real(self._R) if _np.all(self._D.imag == 0): self._D = _np.real(self._D) if _np.all(self._L.imag == 0): self._L = _np.real(self._L) self._eigenvalues = _np.diag(self._D)
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
def test_correlation(fingerprints_data, observables): obs1, obs2 = observables T = fingerprints_data.transition_matrix R, D, L = rdl_decomposition(T, k=4 if fingerprints_data.sparse else None) mu = fingerprints_data.stationary_distribution times = np.array([1, 5, 10, 20, 100]) ev = np.diagonal(D) ev_t = ev[np.newaxis, :]**times[:, np.newaxis] if not fingerprints_data.sparse: """k=None""" acorr_amp = np.dot(mu * obs1, R) * np.dot(L, obs1) acorr = np.dot(ev_t, acorr_amp) acorrn = correlation(T, obs1, times=times) assert_allclose(acorrn, acorr) """k=4""" k = 4 acorr_amp = np.dot(mu * obs1, R[:, 0:k]) * np.dot(L[0:k, :], obs1) acorr = np.dot(ev_t[:, 0:k], acorr_amp) acorrn = correlation(T, obs1, times=times, k=k) assert_allclose(acorrn, acorr) """Cross-correlation""" if not fingerprints_data.sparse: """k=None""" corr_amp = np.dot(mu * obs1, R) * np.dot(L, obs2) corr = np.dot(ev_t, corr_amp) corrn = correlation(T, obs1, obs2=obs2, times=times) assert_allclose(corrn, corr) """k=4""" k = k corr_amp = np.dot(mu * obs1, R[:, 0:k]) * np.dot(L[0:k, :], obs2) corr = np.dot(ev_t[:, 0:k], corr_amp) corrn = correlation(T, obs1, obs2=obs2, times=times, k=k) assert_allclose(corrn, corr)
def __init__(self, complete: bool = True): self.complete = complete data = np.load(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'resources', 'TestData_OOM_MSM.npz')) if complete: self.dtrajs = [data['arr_%d' % k] for k in range(1000)] else: excluded = [ 21, 25, 30, 40, 66, 72, 74, 91, 116, 158, 171, 175, 201, 239, 246, 280, 300, 301, 310, 318, 322, 323, 339, 352, 365, 368, 407, 412, 444, 475, 486, 494, 510, 529, 560, 617, 623, 637, 676, 689, 728, 731, 778, 780, 811, 828, 838, 845, 851, 859, 868, 874, 895, 933, 935, 938, 958, 961, 968, 974, 984, 990, 999 ] self.dtrajs = [data['arr_%d' % k] for k in np.setdiff1d(np.arange(1000), excluded)] # Number of states: self.N = 5 # Lag time: self.tau = 5 self.dtrajs_lag = [traj[:-self.tau] for traj in self.dtrajs] # Rank: if complete: self.rank = 3 else: self.rank = 2 # Build models: self.msmrev = OOMReweightedMSM(lagtime=self.tau, rank_mode='bootstrap_trajs').fit(self.dtrajs) self.msmrev_sparse = OOMReweightedMSM(lagtime=self.tau, sparse=True, rank_mode='bootstrap_trajs') \ .fit(self.dtrajs) self.msm = OOMReweightedMSM(lagtime=self.tau, reversible=False, rank_mode='bootstrap_trajs').fit(self.dtrajs) self.msm_sparse = OOMReweightedMSM(lagtime=self.tau, reversible=False, sparse=True, rank_mode='bootstrap_trajs').fit(self.dtrajs) self.estimators = [self.msmrev, self.msm, self.msmrev_sparse, self.msm_sparse] self.msms = [est.fetch_model() for est in self.estimators] # Reference count matrices at lag time tau and 2*tau: if complete: self.C2t = data['C2t'] else: self.C2t = data['C2t_s'] self.Ct = np.sum(self.C2t, axis=1) if complete: self.Ct_active = self.Ct self.C2t_active = self.C2t self.active_faction = 1. else: lcc = msmest.largest_connected_set(self.Ct) self.Ct_active = msmest.largest_connected_submatrix(self.Ct, lcc=lcc) self.C2t_active = self.C2t[:4, :4, :4] self.active_fraction = np.sum(self.Ct_active) / np.sum(self.Ct) # Compute OOM-components: self.Xi, self.omega, self.sigma, self.l = oom_transformations(self.Ct_active, self.C2t_active, self.rank) # Compute corrected transition matrix: Tt_rev = compute_transition_matrix(self.Xi, self.omega, self.sigma, reversible=True) Tt = compute_transition_matrix(self.Xi, self.omega, self.sigma, reversible=False) # Build reference models: self.rmsmrev = MarkovStateModel(Tt_rev) self.rmsm = MarkovStateModel(Tt) # Active count fraction: self.hist = count_states(self.dtrajs) self.active_hist = self.hist[:-1] if not complete else self.hist self.active_count_frac = float(np.sum(self.active_hist)) / np.sum(self.hist) if not complete else 1. self.active_state_frac = 0.8 if not complete else 1. # Commitor and MFPT: a = np.array([0, 1]) b = np.array([4]) if complete else np.array([3]) self.comm_forward = self.rmsm.committor_forward(a, b) self.comm_forward_rev = self.rmsmrev.committor_forward(a, b) self.comm_backward = self.rmsm.committor_backward(a, b) self.comm_backward_rev = self.rmsmrev.committor_backward(a, b) self.mfpt = self.tau * self.rmsm.mfpt(a, b) self.mfpt_rev = self.tau * self.rmsmrev.mfpt(a, b) # PCCA: pcca = self.rmsmrev.pcca(3 if complete else 2) self.pcca_ass = pcca.assignments self.pcca_dist = pcca.metastable_distributions self.pcca_mem = pcca.memberships self.pcca_sets = pcca.sets # Experimental quantities: a = np.array([1, 2, 3, 4, 5]) b = np.array([1, -1, 0, -2, 4]) p0 = np.array([0.5, 0.2, 0.2, 0.1, 0.0]) if not complete: a = a[:-1] b = b[:-1] p0 = p0[:-1] pi = self.rmsm.stationary_distribution pi_rev = self.rmsmrev.stationary_distribution _, _, L_rev = ma.rdl_decomposition(Tt_rev) self.exp = np.dot(self.rmsm.stationary_distribution, a) self.exp_rev = np.dot(self.rmsmrev.stationary_distribution, a) self.corr_rev = np.zeros(10) self.rel = np.zeros(10) self.rel_rev = np.zeros(10) for k in range(10): Ck_rev = np.dot(np.diag(pi_rev), np.linalg.matrix_power(Tt_rev, k)) self.corr_rev[k] = np.dot(a.T, np.dot(Ck_rev, b)) self.rel[k] = np.dot(p0.T, np.dot(np.linalg.matrix_power(Tt, k), a)) self.rel_rev[k] = np.dot(p0.T, np.dot(np.linalg.matrix_power(Tt_rev, k), a)) self.fing_cor = np.dot(a.T, L_rev.T) * np.dot(b.T, L_rev.T) self.fing_rel = np.dot(a.T, L_rev.T) * np.dot((p0 / pi_rev).T, L_rev.T)
def test_rdl_decomposition_rev(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, reversible=True) """norm='standard'""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, reversible=True, norm='standard') 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) """Standard l2-normalization of right eigenvectors except dominant one""" Yn = np.dot(Rn.T, Rn) assert_allclose(np.diag(Yn)[1:], 1.0) """ncv is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, reversible=True, norm='standard', 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) """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'""" Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible', 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) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible', 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) """Reversibility""" assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn) """mu is not None""" """norm='standard'""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, reversible=True, norm='standard', mu=mu) 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) """Standard l2-normalization of right eigenvectors except dominant one""" Yn = np.dot(Rn.T, Rn) assert_allclose(np.diag(Yn)[1:], 1.0) """ncv is not None""" Rn, Dn, Ln = rdl_decomposition(P, k=self.k, reversible=True, norm='standard', ncv=self.ncv, mu=mu) 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) """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'""" Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible', k=self.k, mu=mu) 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) Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible', k=self.k, ncv=self.ncv, mu=mu) 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_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_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)