def test_base():
with assert_raises(NotImplementedError):
dt.kernels.Kernel()(1,
2) # base class does not implement call operator
k = GaussianKernel(1.)
with assert_raises(ValueError):
k * "weird object" # product kernel only supported with other kernels
def test_score():
kernel = GaussianKernel(1.)
dataset = bickley_jet(n_particles=100, n_jobs=1)
ds_2d = dataset.endpoints_dataset()
ds_3d = ds_2d.to_3d().cluster(4)
ref_score = KVAD(kernel, epsilon=1e-6).fit_fetch(ds_3d).score
with torch.no_grad():
chi_x = torch.from_numpy(ds_3d.data)
y = torch.from_numpy(ds_3d.data_lagged)
score_net = kvad_score(chi_x, y, kernel=kernel).numpy()
np.testing.assert_almost_equal(score_net, ref_score, decimal=1)
===================================================
This example shows an application of :class:`KernelCCA <deeptime.decomposition.KernelCCA>` on the
:meth:`bickley jet <deeptime.data.bickley_jet>` dataset. One can cluster in the singular function space
to find coherent structures.
"""
import matplotlib.pyplot as plt
import numpy as np
from deeptime.clustering import KMeans
from deeptime.data import bickley_jet
from deeptime.decomposition import KernelCCA
from deeptime.kernels import GaussianKernel
dataset = bickley_jet(n_particles=1000, n_jobs=8).endpoints_dataset()
kernel = GaussianKernel(.7)
estimator = KernelCCA(kernel, n_eigs=5, epsilon=1e-3)
model = estimator.fit((dataset.data, dataset.data_lagged)).fetch_model()
ev_real = np.real(model.eigenvectors)
kmeans = KMeans(n_clusters=7, n_jobs=8).fit(ev_real)
kmeans = kmeans.fetch_model()
fig = plt.figure()
gs = fig.add_gridspec(ncols=2, nrows=3)
ax = fig.add_subplot(gs[0, 0])
ax.scatter(*dataset.data.T, c=ev_real[:, 0])
ax.set_title('1st Eigenfunction')
return X, Y
def test_base():
with assert_raises(NotImplementedError):
dt.kernels.Kernel()(1,
2) # base class does not implement call operator
k = GaussianKernel(1.)
with assert_raises(ValueError):
k * "weird object" # product kernel only supported with other kernels
@pytest.mark.parametrize(
"kernel",
[
GaussianKernel(1.),
GaussianKernel(2.),
GaussianKernel(3.), # some Gaussian kernels
GaussianKernel(1., impl='binomial'),
GaussianKernel(
3., impl='binomial'), # some Gaussian kernels, binomial impl
GeneralizedGaussianKernel(np.linspace(
3, 5, num=7)), # a generalized Gaussian kernel
LaplacianKernel(3.3), # a Laplacian kernel
PolynomialKernel(3, 1.),
PolynomialKernel(7, 3.3), # some polynomial kernels
PolynomialKernel(3, 1.) * GaussianKernel(3.) *
LaplacianKernel(5.), # product kernel
PolynomialKernel(3, 1.) *
GeneralizedGaussianKernel(np.linspace(3, 5, num=7)) *
LaplacianKernel(5.) # product k.
@pytest.fixture
def data():
X = np.random.normal(size=(50, 7))
Y = np.random.normal(size=(30, 7))
return X, Y
def test_base():
with assert_raises(NotImplementedError):
dt.kernels.Kernel()(1, 2) # base class does not implement call operator
k = GaussianKernel(1.)
with assert_raises(ValueError):
k * "weird object" # product kernel only supported with other kernels
@pytest.mark.parametrize("kernel", [
GaussianKernel(1.), GaussianKernel(2.), GaussianKernel(3.), # some Gaussian kernels
GaussianKernel(1., impl='binomial'), GaussianKernel(3., impl='binomial'), # some Gaussian kernels, binomial impl
GeneralizedGaussianKernel(np.linspace(3, 5, num=7)), # a generalized Gaussian kernel
LaplacianKernel(3.3), # a Laplacian kernel
PolynomialKernel(3, 1.), PolynomialKernel(7, 3.3), # some polynomial kernels
PolynomialKernel(3, 1.) * GaussianKernel(3.) * LaplacianKernel(5.), # product kernel
PolynomialKernel(3, 1.) * GeneralizedGaussianKernel(np.linspace(3, 5, num=7)) * LaplacianKernel(5.) # product k.
], ids=lambda k: str(k))
def test_consistency(data, kernel):
xy_gram = kernel.apply(*data)
assert_equal(xy_gram.shape, (50, 30))
for i in range(50):
for j in range(30):
assert_almost_equal(xy_gram[i, j], kernel(data[0][i], data[1][j]), decimal=5)
clustering.
"""
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from deeptime.clustering import Kmeans
from deeptime.data import sqrt_model
from deeptime.decomposition import KernelCCA
from deeptime.kernels import GaussianKernel
dtraj, obs = sqrt_model(1500)
dtraj_test, obs_test = sqrt_model(5000)
kernel = GaussianKernel(2.)
est = KernelCCA(kernel, n_eigs=2)
model = est.fit((obs[1:], obs[:-1])).fetch_model()
evals = model.transform(obs_test)
clustering = Kmeans(2).fit(np.real(model.transform(obs))).fetch_model()
assignments = clustering.transform(np.real(evals))
n_mismatch = np.sum(np.abs(assignments - dtraj_test))
assignments_perm = np.where((assignments == 0) | (assignments == 1),
assignments ^ 1, assignments)
n_mismatch_perm = np.sum(np.abs(assignments_perm - dtraj_test))
if n_mismatch_perm < n_mismatch:
assignments = assignments_perm
n_mismatch = n_mismatch_perm