def _diagonalize(self):
"""Performs SVD on covariance matrices and save left, right singular vectors and values in the model.
Parameters
----------
scaling : None or string, default=None
Scaling to be applied to the VAMP modes upon transformation
* None: no scaling will be applied, variance of the singular
functions is 1
* 'kinetic map' or 'km': singular functions are scaled by
singular value. Note that only the left singular functions
induce a kinetic map.
"""
L0, self._rank0 = spd_inv_sqrt(self.C00,
epsilon=self.epsilon,
return_rank=True)
Lt, self._rankt = spd_inv_sqrt(self.Ctt,
epsilon=self.epsilon,
return_rank=True)
A = L0.T.dot(self.C0t).dot(Lt)
Uprime, s, Vprimeh = np.linalg.svd(A, compute_uv=True)
self._singular_values = s
self._L0 = L0
self._Lt = Lt
# don't pass any values calling this method again!!!
m = VAMPModel._dimension(self._rank0, self._rankt, self.dim,
self._singular_values)
U = L0.dot(Uprime[:, :m]) # U in the paper singular_vectors_left
V = Lt.dot(Vprimeh[:m, :].T) # V in the paper singular_vectors_right
# scale vectors
if self.scaling is not None:
U *= s[np.newaxis, 0:m]
self._U = U
self._V = V
self._svd_performed = True
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