def setUpClass(cls): N_steps = 10000 N_traj = 20 lag = 1 T = np.linalg.matrix_power(np.array([[0.7, 0.2, 0.1], [0.1, 0.8, 0.1], [0.1, 0.1, 0.8]]), lag) dtrajs = [generate(T, N_steps) for _ in range(N_traj)] p0 = np.zeros(3) p1 = np.zeros(3) trajs = [] for dtraj in dtrajs: traj = np.zeros((N_steps, T.shape[0])) traj[np.arange(len(dtraj)), dtraj] = 1.0 trajs.append(traj) p0 += traj[:-lag, :].sum(axis=0) p1 += traj[lag:, :].sum(axis=0) estimator = VAMP(scaling=None, var_cutoff=1.0) cov = VAMP.covariance_estimator(lagtime=lag).fit(trajs).fetch_model() vamp = estimator.fit(cov).fetch_model() msm = estimate_markov_model(dtrajs, lag=lag, reversible=False) cls.trajs = trajs cls.dtrajs = dtrajs cls.trajs_timeshifted = list(timeshifted_split(cls.trajs, lagtime=lag, chunksize=5000)) cls.lag = lag cls.msm = msm cls.vamp = vamp cls.estimator = estimator cls.p0 = p0 / p0.sum() cls.p1 = p1 / p1.sum() cls.atol = np.finfo(np.float32).eps * 1000.0
def test_vamp_consistency(): trajectory = ellipsoids(seed=13).observations(10000, n_dim=50) cov_estimator = VAMP.covariance_estimator(lagtime=1) cov_estimator.compute_ctt = False cov_estimator.reversible = True cov_estimator.fit(trajectory) koopman1 = VAMP(dim=2).fit(cov_estimator).fetch_model() koopman2 = TICA(dim=2, scaling=None, lagtime=1).fit(trajectory).fetch_model() np.testing.assert_array_almost_equal(koopman1.singular_values, koopman2.singular_values, decimal=1) np.testing.assert_array_almost_equal( np.abs(koopman1.singular_vectors_left), np.abs(koopman2.singular_vectors_left), decimal=2) np.testing.assert_array_almost_equal( np.abs(koopman1.singular_vectors_right), np.abs(koopman2.singular_vectors_right), decimal=2) np.testing.assert_array_almost_equal(koopman1.timescales(), koopman2.timescales(), decimal=2)
def vamp_score_data(data, data_lagged, transformation=None, r=2, epsilon=1e-6, dim=None): r""" Computes VAMP score based on data and corresponding time-lagged data. Can be equipped with a transformation, defaults to 'identity' transformation. Parameters ---------- data : (T, n) ndarray Instantaneous data. data_lagged : (T, n) ndarray Time-lagged data. transformation : Callable Transformation on data that will be scored. r : int or str, optional, default=2 The type of VAMP score evaluated, see :meth:`deeptime.decomposition.vamp_score`. epsilon : float, optional, default=1e-6 Regularization parameter for the score, see :meth:`deeptime.decomposition.vamp_score`. dim : int, optional, default=None Number of components that should be scored. Defaults to all components. See :meth:`deeptime.decomposition.vamp_score`. Returns ------- score : float The VAMP score. See Also -------- vamp_score """ if transformation is None: def transformation(x): return x from deeptime.decomposition import VAMP cov_estimator = VAMP.covariance_estimator(1) cov = cov_estimator.partial_fit((transformation(data), transformation(data_lagged))).fetch_model() return VAMP().fit(cov).fetch_model().score(r=r, dim=dim, epsilon=epsilon)