def test_1D_data(self):
x = np.random.randn(10, 1)
vamp = pyemma_api_vamp([x], 1,
right=True) # just test that this doesn't raise
# Doing VAMP with 1-D data is just centering and normalizing the data.
assert_allclose_ignore_phase(
vamp.get_output()[0], (x - np.mean(x[1:, 0])) / np.std(x[1:, 0]))
def test_score_vs_MSM(self):
from pyemma.util.contexts import numpy_random_seed
with numpy_random_seed(32):
trajs_test, trajs_train = cvsplit_trajs(self.trajs)
with numpy_random_seed(32):
dtrajs_test, dtrajs_train = cvsplit_trajs(self.dtrajs)
methods = ('VAMP1', 'VAMP2', 'VAMPE')
for m in methods:
msm_train = estimate_markov_model(dtrajs=dtrajs_train,
lag=self.lag,
reversible=False)
score_msm = msm_train.score(dtrajs_test,
score_method=m,
score_k=None)
vamp_train = pyemma_api_vamp(data=trajs_train,
lag=self.lag,
dim=1.0)
score_vamp = vamp_train.score(test_data=trajs_test, score_method=m)
self.assertAlmostEqual(score_msm,
score_vamp,
places=2 if m == 'VAMPE' else 3,
msg=m)
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)
vamp = pyemma_api_vamp(trajs, lag=lag, scaling=None, dim=1.0)
msm = estimate_markov_model(dtrajs, lag=lag, reversible=False)
cls.trajs = trajs
cls.dtrajs = dtrajs
cls.lag = lag
cls.msm = msm
cls.vamp = vamp
cls.p0 = p0 / p0.sum()
cls.p1 = p1 / p1.sum()
cls.atol = np.finfo(vamp.output_type()).eps * 1000.0
def test_kinetic_map(self):
lag = 10
self.vamp = pyemma_api_vamp(self.trajs,
lag=lag,
scaling='km',
right=False)
transformed = [t[:-lag] for t in self.vamp.get_output()]
std = np.std(np.concatenate(transformed), axis=0)
np.testing.assert_allclose(
std,
self.vamp.singular_values[:self.vamp.dimension()],
atol=1e-4,
rtol=1e-4)
def do_test(self, dim, rank, test_partial_fit=False):
# setup
N_frames = [123, 456, 789]
N_trajs = len(N_frames)
A = random_matrix(dim, rank)
trajs = []
mean = np.random.randn(dim)
for i in range(N_trajs):
# set up data
white = np.random.randn(N_frames[i], dim)
brown = np.cumsum(white, axis=0)
correlated = np.dot(brown, A)
trajs.append(correlated + mean)
# test
tau = 50
vamp = pyemma_api_vamp(trajs, lag=tau, scaling=None)
vamp.right = True
_check_serialize(vamp)
assert vamp.dimension() <= rank
atol = np.finfo(vamp.output_type()).eps * 10.0
rtol = np.finfo(vamp.output_type()).resolution
phi_trajs = [sf[tau:, :] for sf in vamp.get_output()]
phi = np.concatenate(phi_trajs)
mean_right = phi.sum(axis=0) / phi.shape[0]
cov_right = phi.T.dot(phi) / phi.shape[0]
np.testing.assert_allclose(mean_right, 0.0, rtol=rtol, atol=atol)
np.testing.assert_allclose(cov_right,
np.eye(vamp.dimension()),
rtol=rtol,
atol=atol)
vamp.right = False
psi_trajs = [sf[0:-tau, :] for sf in vamp.get_output()]
psi = np.concatenate(psi_trajs)
mean_left = psi.sum(axis=0) / psi.shape[0]
cov_left = psi.T.dot(psi) / psi.shape[0]
np.testing.assert_allclose(mean_left, 0.0, rtol=rtol, atol=atol)
np.testing.assert_allclose(cov_left,
np.eye(vamp.dimension()),
rtol=rtol,
atol=atol)
# compute correlation between left and right
assert phi.shape[0] == psi.shape[0]
C01_psi_phi = psi.T.dot(phi) / phi.shape[0]
n = max(C01_psi_phi.shape)
C01_psi_phi = C01_psi_phi[0:n, :][:, 0:n]
np.testing.assert_allclose(
C01_psi_phi,
np.diag(vamp.singular_values[0:vamp.dimension()]),
rtol=rtol,
atol=atol)
if test_partial_fit:
vamp2 = pyemma_api_vamp(lag=tau, scaling=None)
for t in trajs:
vamp2.partial_fit(t)
vamp2 = _check_serialize(vamp2)
model_params = vamp._model.get_model_params()
model_params2 = vamp2._model.get_model_params()
atol = 1e-14
rtol = 1e-5
for n in model_params.keys():
if model_params[n] is not None and model_params2[n] is not None:
if n not in ('U', 'V'):
np.testing.assert_allclose(
model_params[n],
model_params2[n],
rtol=rtol,
atol=atol,
err_msg='failed for model param %s' % n)
else:
assert_allclose_ignore_phase(model_params[n],
model_params2[n],
atol=atol)
vamp2.singular_values # trigger diagonalization
vamp2.right = True
for t, ref in zip(trajs, phi_trajs):
assert_allclose_ignore_phase(vamp2.transform(t[tau:]),
ref,
rtol=rtol,
atol=atol)
vamp2.right = False
for t, ref in zip(trajs, psi_trajs):
assert_allclose_ignore_phase(vamp2.transform(t[0:-tau]),
ref,
rtol=rtol,
atol=atol)
def test_const_data(self):
from pyemma._ext.variational.util import ZeroRankError
with self.assertRaises(ZeroRankError):
pyemma_api_vamp([np.ones((10, 2))], 1)
with self.assertRaises(ZeroRankError):
pyemma_api_vamp([np.ones(10)], 1)
def test_default_cs(self):
v = pyemma_api_vamp(chunksize=None)
assert v.default_chunksize == v._FALLBACK_CHUNKSIZE