def test_transition_matrix(self): print("Transition Matrix:\n") print(self.smm0.trans) print(mdot(self.smm0.eigenvectors_right(), np.diag(np.power(self.smm0.eigenvalues().real, 1)), self.smm0.eigenvectors_left())) print("Transition Matrix Squared:\n") print(mdot(self.smm0.trans, self.smm0.trans)) print(mdot(self.smm0.eigenvectors_right(), np.diag(np.power(self.smm0.eigenvalues().real, 2)), self.smm0.eigenvectors_left()))
def test_propagate(self): # If the nonstationary MM is actually stationary, should get the same result as eval(0).propagate print(self.lcnsmm2.propagate(self.p0_1, 0)) print(self.lcnsmm2.propagate(self.p0_1, 1)) print(self.lcnsmm2.propagate(self.p0_1, 2)) print(self.lcnsmm2.propagate(self.p0_1, 3)) print(self.lcnsmm2.eval(0).propagate(self.p0_1, 0)) print(self.lcnsmm2.eval(0).propagate(self.p0_1, 1)) print(self.lcnsmm2.eval(0).propagate(self.p0_1, 2)) print(self.lcnsmm2.eval(0).propagate(self.p0_1, 3)) print(self.p0_1) print(np.dot(self.p0_1, self.trans2)) print(np.dot(self.p0_1, np.dot(self.trans2, self.trans2))) print(np.dot(self.p0_1, np.dot(self.trans2, np.dot(self.trans2, self.trans2)))) print(mdot(self.p0_1, self.trans2, self.trans2, self.trans2)) print(mdot(self.p0_1.T, self.trans2, self.trans2, self.trans2)) print(self.lcnsmm2.eval(0).propagate(np.array([1.0, 0, 0]), 2)) print(self.lcnsmm2.eval(0).propagate(np.array([0, 1.0, 0]), 2)) print(self.lcnsmm2.eval(0).propagate(np.array([0, 0, 1.0]), 2)) k = int(self.timeendpoint) self.assertTrue( np.allclose(self.lcnsmm2.propagate(self.p0_1, k), self.lcnsmm2.eval(0).propagate(self.p0_1, k))) # If MM0 and MM1 have the same stationary distribution, it should be stationary for the ccnsmm self.assertTrue(np.allclose(self.lcnsmm2.propagate(self.p0_0, k), self.p0_0))
def vamp_e_score(K, C00_train, C0t_train, Ctt_train, C00_test, C0t_test, Ctt_test, k=None): """ Computes the VAMP-E score of a kinetic model. Ranks the kinetic model described by the estimation of covariances C00, C0t and Ctt, defined by: :math:`C_{0t}^{train} = E_t[x_t x_{t+\tau}^T]` :math:`C_{tt}^{train} = E_t[x_{t+\tau} x_{t+\tau}^T]` These model covariances might have been subject to symmetrization or reweighting, depending on the type of model used. The covariances C00, C0t and Ctt of the test data are direct empirical estimates. singular vectors U and V using the test data with covariances C00, C0t, Ctt. U and V should come from the SVD of the symmetrized transition matrix or Koopman matrix: :math:`(C00^{train})^{-(1/2)} C0t^{train} (Ctt^{train})^{-(1/2)} = U S V.T` Parameters: ----------- K : ndarray(n, k) left singular vectors of the symmetrized transition matrix or Koopman matrix C00_train : ndarray(n, n) covariance matrix of the training data, defined by :math:`C_{00}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_t^T` C0t_train : ndarray(n, n) time-lagged covariance matrix of the training data, defined by :math:`C_{0t}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_{t+\tau}^T` Ctt_train : ndarray(n, n) covariance matrix of the training data, defined by :math:`C_{tt}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_{t+\tau} x_{t+\tau}^T` C00_test : ndarray(n, n) covariance matrix of the test data, defined by :math:`C_{00}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_t^T` C0t_test : ndarray(n, n) time-lagged covariance matrix of the test data, defined by :math:`C_{0t}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_{t+\tau}^T` Ctt_test : ndarray(n, n) covariance matrix of the test data, defined by :math:`C_{tt}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_{t+\tau} x_{t+\tau}^T` k : int number of slow processes to consider in the score Returns: -------- vampE : float VAMP-E score """ # SVD of symmetrized operator in empirical distribution U, s, V = _svd_sym_koopman(K, C00_train, Ctt_train) if k is not None: U = U[:, :k] S = np.diag(s[:k]) V = V[:, :k] score = np.trace(2.0 * mdot(V, S, U.T, C0t_test) - mdot(V, S, U.T, C00_test, U, S, V.T, Ctt_test)) return score
def _svd_sym_koopman(K, C00_train, Ctt_train): """ Computes the SVD of the symmetrized Koopman operator in the empirical distribution. """ from pyemma._ext.variational.solvers.direct import spd_inv_sqrt # reweight operator to empirical distribution C0t_re = mdot(C00_train, K) # symmetrized operator and SVD K_sym = mdot(spd_inv_sqrt(C00_train), C0t_re, spd_inv_sqrt(Ctt_train)) U, S, Vt = np.linalg.svd(K_sym, compute_uv=True, full_matrices=False) # projects back to singular functions of K U = mdot(spd_inv_sqrt(C00_train), U) Vt = mdot(Vt,spd_inv_sqrt(Ctt_train)) return U, S, Vt.T
def is_scalable_tm(self): """ ToDo Document :param transd: ndarray - diagonal array :param transu: ndarray - left eigenvector matrix :param transv: ndarray (default=None) - inverse matrix of transu :return: bool - True if D*U*V is scalable, otherwise False """ # For large scaling factors (tau), the scaling of the transition matrix approaches # # I + (1/tau) ln(trans) # # This will be a transition matrix for sufficiently large tau if # 1. all diagonal elements of ln(trans) are <= 0 # 2. all off-diagonal elements ln(trans) are >= 0 # # Therefore the matrix is called "scalable" if it satisfies these properties. # # The diagonal decomposition is used for a fast calculation of the natural log lntransd = np.diag(np.log(np.diag(self.transD))) delta = mdot(self.transV, lntransd, self.transU) # FIXME: This is not optimized, it does twice as many sign checks as necessary deltadiag = np.diag(delta) deltatril = np.tril(delta, -1) deltatriu = np.triu(delta, 1) if np.all(deltadiag <= 0) and np.all(deltatril >= 0) and np.all(deltatriu >= 0): return True else: return False
def is_scalable_tm(self, transd, transu, transv=None): """ A transition matrix has all non-negative entries whose rows sum to one. The input parameters contain the diagonal decomposition of a transition matrix: trans = transv * transd * transu where transd is diagonal and transv is the inverse of transu. The scaling of trans by scaling factor tau is defined as the transition matrix S satisfying S = trans^(1/tau) For large scaling factors (tau), the scaling of a base transition matrix trans approaches I + (1/tau) ln( trans) Proof: For any matrix M, M = exp( ln(M) ) M^(1/tau) = exp( (1/tau)*ln(M) ) When |(1/tau)*ln(M)|<< 1, M^(1/tau) ~ I + (1/tau)*ln(M) The matrix I + (1/tau)*ln(trans) will have non-negative elements for sufficiently large tau if and only if 1. all diagonal elements of ln(trans) are <= 0 2. all off-diagonal elements of ln(trans) are >= 0 Therefore the matrix trans is called "scalable" if it satisfies these properties. The definition of the natural logarithm for a matrix is given in terms of its Taylor's series: ln(I + X) = X - (1/2) X^2 + (1/3) X^3 ... Based on this definition, the diagonal decomposition may be used for a fast calculation of natural logarithm of trans. ln(trans) = transv * ln(transd) * transu The natural logarithm of a diagonal matrix is obtained by taking the natural logarithm of each diagonal entry. This is also a result of the Taylor's series definition. :param transd: ndarray - diagonal array :param transu: ndarray - left eigenvector matrix :param transv: ndarray (default=None) - inverse matrix of transu :return: bool - True if trans = transv*transd*transu is scalable, otherwise False """ if transv is None: transv = np.linalg.inv(transu) lntransd = np.diag(np.log(np.diag(transd))) delta = mdot(transv, lntransd, transu) # delta = natural logarithm of the transition matrix deltadiag = np.diag(delta) # the diagonal of the matrix delta deltatril = np.tril(delta, -1) # the strict lower triangular part of delta deltatriu = np.triu(delta, 1) # the strict upper triangular part of delta if np.all(deltadiag <= 0) and np.all(deltatril >= 0) and np.all(deltatriu >= 0): return True else: return False
def propagate(self, p0, k): r""" Propagates the initial distribution p0 k times Computes the product .. math:: p_k = p_0^T P^k If the lag time of transition matrix :math:`P` is :math:`\tau`, this will provide the probability distribution at time :math:`k \tau`. Parameters ---------- p0 : ndarray(n) Initial distribution. Vector of size of the active set. k : int Number of time steps Returns ---------- pk : ndarray(n) Distribution after k steps. Vector of size of the active set. """ p0 = _types.ensure_ndarray(p0, ndim=1, kind='numeric') assert _types.is_int(k) and k >= 0, 'k must be a non-negative integer' if k == 0: # simply return p0 normalized return p0 / p0.sum() micro = False # are we on microstates space? if len(p0) == self.nstates_obs: micro = True # project to hidden and compute p0 = _np.dot(self.observation_probabilities, p0) self._ensure_eigendecomposition(self.nstates) from pyemma.util.linalg import mdot pk = mdot(p0.T, self.eigenvectors_right(), _np.diag(_np.power(self.eigenvalues(), k)), self.eigenvectors_left()) if micro: pk = _np.dot(pk, self.observation_probabilities ) # convert back to microstate space # normalize to 1.0 and return return pk / pk.sum()
def propagate(self, p0, k): r""" Propagates the initial distribution p0 k times Computes the product .. math:: p_k = p_0^T P^k If the lag time of transition matrix :math:`P` is :math:`\tau`, this will provide the probability distribution at time :math:`k \tau`. Parameters ---------- p0 : ndarray(n,) Initial distribution. Vector of size of the active set. k : int Number of time steps Returns ---------- pk : ndarray(n,) Distribution after k steps. Vector of size of the active set. """ p0 = _types.ensure_ndarray(p0, ndim=1, size=self.nstates, kind='numeric') assert _types.is_int(k) and k >= 0, 'k must be a non-negative integer' if k == 0: # simply return p0 normalized return p0 / p0.sum() if self.is_sparse: # sparse: we don't have a full eigenvalue set, so just propagate pk = _np.array(p0) for i in range(k): pk = _np.dot(pk.T, self.transition_matrix) else: # dense: employ eigenvalue decomposition self._ensure_eigendecomposition(self.nstates) from pyemma.util.linalg import mdot pk = mdot(p0.T, self.eigenvectors_right(), _np.diag(_np.power(self.eigenvalues(), k)), self.eigenvectors_left()).real # normalize to 1.0 and return return pk / pk.sum()
def score(self, test_model=None, score_method='VAMP2'): """Compute the VAMP score for this model or the cross-validation score between self and a second model. Parameters ---------- test_model : VAMPModel, optional, default=None If `test_model` is not None, this method computes the cross-validation score between self and `test_model`. It is assumed that self was estimated from the "training" data and `test_model` was estimated from the "test" data. The score is computed for one realization of self and `test_model`. Estimation of the average cross-validation score and partitioning of data into test and training part is not performed by this method. If `test_model` is None, this method computes the VAMP score for the model contained in self. score_method : str, optional, default='VAMP2' Available scores are based on the variational approach for Markov processes [1]_: * 'VAMP1' Sum of singular values of the half-weighted Koopman matrix [1]_ . If the model is reversible, this is equal to the sum of Koopman matrix eigenvalues, also called Rayleigh quotient [1]_. * 'VAMP2' Sum of squared singular values of the half-weighted Koopman matrix [1]_ . If the model is reversible, this is equal to the kinetic variance [2]_ . * 'VAMPE' Approximation error of the estimated Koopman operator with respect to the true Koopman operator up to an additive constant [1]_ . Returns ------- score : float If `test_model` is not None, returns the cross-validation VAMP score between self and `test_model`. Otherwise return the selected VAMP-score of self. References ---------- .. [1] Wu, H. and Noe, F. 2017. Variational approach for learning Markov processes from time series data. arXiv:1707.04659v1 .. [2] Noe, F. and Clementi, C. 2015. Kinetic distance and kinetic maps from molecular dynamics simulation. J. Chem. Theory. Comput. doi:10.1021/acs.jctc.5b00553 """ # TODO: implement for TICA too if test_model is None: test_model = self Uk = self.U[:, 0:self.dimension()] Vk = self.V[:, 0:self.dimension()] res = None if score_method == 'VAMP1' or score_method == 'VAMP2': A = spd_inv_sqrt(Uk.T.dot(test_model.C00).dot(Uk)) B = Uk.T.dot(test_model.C0t).dot(Vk) C = spd_inv_sqrt(Vk.T.dot(test_model.Ctt).dot(Vk)) ABC = mdot(A, B, C) if score_method == 'VAMP1': res = np.linalg.norm(ABC, ord='nuc') elif score_method == 'VAMP2': res = np.linalg.norm(ABC, ord='fro')**2 elif score_method == 'VAMPE': Sk = np.diag(self.singular_values[0:self.dimension()]) res = np.trace(2.0 * mdot(Vk, Sk, Uk.T, test_model.C0t) - mdot( Vk, Sk, Uk.T, test_model.C00, Uk, Sk, Vk.T, test_model.Ctt)) else: raise ValueError('"score" should be one of VAMP1, VAMP2 or VAMPE') # add the contribution (+1) of the constant singular functions to the result assert res return res + 1
def vamp_2_score(K, C00_train, C0t_train, Ctt_train, C00_test, C0t_test, Ctt_test, k=None): """ Computes the VAMP-2 score of a kinetic model. Ranks the kinetic model described by the estimation of covariances C00, C0t and Ctt, defined by: :math:`C_{0t}^{train} = E_t[x_t x_{t+\tau}^T]` :math:`C_{tt}^{train} = E_t[x_{t+\tau} x_{t+\tau}^T]` These model covariances might have been subject to symmetrization or reweighting, depending on the type of model used. The covariances C00, C0t and Ctt of the test data are direct empirical estimates. singular vectors U and V using the test data with covariances C00, C0t, Ctt. U and V should come from the SVD of the symmetrized transition matrix or Koopman matrix: :math:`(C00^{train})^{-(1/2)} C0t^{train} (Ctt^{train})^{-(1/2)} = U S V.T` Parameters: ----------- K : ndarray(n, k) left singular vectors of the symmetrized transition matrix or Koopman matrix C00_train : ndarray(n, n) covariance matrix of the training data, defined by :math:`C_{00}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_t^T` C0t_train : ndarray(n, n) time-lagged covariance matrix of the training data, defined by :math:`C_{0t}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_{t+\tau}^T` Ctt_train : ndarray(n, n) covariance matrix of the training data, defined by :math:`C_{tt}^{train} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_{t+\tau} x_{t+\tau}^T` C00_test : ndarray(n, n) covariance matrix of the test data, defined by :math:`C_{00}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_t^T` C0t_test : ndarray(n, n) time-lagged covariance matrix of the test data, defined by :math:`C_{0t}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_t x_{t+\tau}^T` Ctt_test : ndarray(n, n) covariance matrix of the test data, defined by :math:`C_{tt}^{test} = (T-\tau)^{-1} \sum_{t=0}^{T-\tau} x_{t+\tau} x_{t+\tau}^T` k : int number of slow processes to consider in the score Returns: -------- vamp2 : float VAMP-2 score """ from pyemma._ext.variational.solvers.direct import spd_inv_sqrt # SVD of symmetrized operator in empirical distribution U, S, V = _svd_sym_koopman(K, C00_train, Ctt_train) if k is not None: U = U[:, :k] # S = S[:k][:, :k] V = V[:, :k] A = spd_inv_sqrt(mdot(U.T, C00_test, U)) B = mdot(U.T, C0t_test, V) C = spd_inv_sqrt(mdot(V.T, Ctt_test, V)) # compute square frobenius, equal to the sum of squares of singular values score = np.linalg.norm(mdot(A, B, C), ord='fro') ** 2 return score