I'd like to use VAMPnet for a large amount of data. I'm coming from pyEMMA where managing this is easy thanks to the function pyemma.coordinates.source. I see that deeptime is lacking this function but I do see the partial_fit function in almost all the functions. My problem is how this can be used in VAMPnet? The fit and partial_fit functions seem to do different things: in the first one for instance it is asked also for validation data while the second is satisfied by just the training data, same thing for the number of epochs. Another thing is whether I should fetch the model at the end. Right now I'm trying to do a loop over my data in the following way:

import torch
import torch.nn as nn
import numpy as np
from deeptime.data import TimeLaggedDataset
from deeptime.util.torch import MLP
from torch.utils.data import DataLoader
from deeptime.decomposition.deep import VAMPNet

lobe = MLP(units=ns, nonlinearity=nn.ReLU)
vampnet = VAMPNet(lobe=lobe,learning_rate=3)
# paths is just a list of strings containing the path to .npy data
for path in paths:
    data = np.load(path)
    dataset = TimeLaggedDataset.from_trajectory(lagtime=500, data=data.astype(np.float32))
    lobe = MLP(units=ns, nonlinearity=nn.ReLU)
    vampnet = VAMPNet(lobe=lobe, learning_rate=1e-4)
    vampnet.partial_fit((dataset.data,dataset.data_lagged))
model = vampnet.fetch_model()  # I'm pretty sure this is not right at all as most of the code before

Note I'm not using the train_data and the val_data as you did in the documentation since partial_fit doesn't require it, but I'm pretty sure that I should somehow. I think that from the documentation is not clear how you should deal with this kind of problem. Thank you very much for your time

hi @brookehus !

This looks like a very exciting library!

Is there an example of the online covariance calulation.

Its a problem I am looking at, at the moment.

Kind regards, Andrew

This adds VAMP estimator/model and the infrastructure for lagged model validation (cktests).

During the path of getting the stuff to work, I noticed that calling fit on an estimator has unexpected side effects. That is why we need to take a copy of it in LaggedModelValidator. The factory pattern however should make the need for this copy unnecessary, but because we encapsulate the current model instance, we can not work around this. @clonker do you think it would be sane to call _create_model upon fit() to avoid this kind of hassle? How would we enforce this behavior without interfering with overridden fit methods?

The bug reported at https://github.com/rusty1s/pytorch_sparse/issues/180 and https://github.com/pyg-team/pytorch_geometric/issues/4095 propagates to deeptime, too. Fixing PyTorch to older versions in the setup might help.

Describe the bug A clear and concise description of what the bug is.

Here's a quick checklist in what to include:

• [x] Include a detailed description of the bug or suggestion
• [x] pip list or conda list of the environment you are using (please attach a txt file to the issue).
• [x] deeptime and operating system versions
• [x] Minimal example if possible, a Python script, zipped input data (if not too large)

Describe the bug I tried to run the ala2 notebook (https://github.com/deeptime-ml/deeptime-notebooks/blob/master/examples/ala2-example.ipynb) but ended up with quite different results with GPU v.s. CPU training. CPU had a much higher success rate and flat training curves compared to GPU. I am wondering if it is something common or if I had made any mistakes.

Results I tested with 10 individual runs with the same parameters as in the tutorial notebook.

• CPU

• GPU

System CPU: AMD EPYC 7551 GPU: RTX A5000 System: Ubuntu 20.04.1 Python 3.9 torch 1.11.0+cu113 deeptime '0.4.1+8.g38b0158.dirty' (main branch)

This pull request provides a simple implementation of the Sparse Identification of Nonlinear Dynamics (SINDy) method for nonlinear model discovery. It includes

• A SINDy estimator class for fitting a SINDyModel objects to data
• A SINDyModel class encapsulating the learned dynamical system
• Tests for the important methods and use-cases

The pull request is not quite complete—I still need to create an example showing how to use the new features—but I figured this was a good place for me to give you, the Scikit-time team, a chance to look at implementation. I tried to use existing sktime code as inspiration, but feel free to edit anything that doesn't conform to your standards or style.

The other thing I'd like to flag is that I wasn't able to test whether the auto-generated documentation all looked okay. I welcome any suggestions on how to improve it.

The following should print the empty set [] but instead prints [3].

import numpy as np
from deeptime.markov import TransitionCountEstimator

estimator = TransitionCountEstimator(lagtime=1, count_mode='sliding')

full_counts_model = estimator.fit_fetch(np.asarray([0, 1, 2, 3]))
submodel = full_counts_model.submodel_largest(
        connectivity_threshold=1,
        directed=True)
print(submodel.state_symbols)

I contacted you a few days ago regarding the VAMPnet usage. I solved everything but I think there's something missing. From the references it is reported that you could evaluate the ITS and the CKtest straight from the koopman matrix built on the transformed data from your VAMPnet. Starting from these data it isn't difficult to evaluate by your own the koopman operator, the ITS and the Chapmann-Kolmogorov test but for completeness I would ask these functions to be added so that the users could entrust your implementation, for sure much more robust and compact.

Again congratulations for this huge and extremely well organized library!

Hi, in the past with pyEMMA I was able to fit once with TICA and project on different amount of dimensions after. Currently if I use

tica = TICA(lagtime=20)
tica.fit(mydata)
tica.set_params(dim=3)
tica.transform(mydata)

after fitting it seems to ignore it and just returns the full dimensions (minus correlated features) Is there any way to achieve the same using deeptime? Since fitting takes lots of time it's quite useful to be able to test different number of dimensions without re-fitting the whole model.

• The documentation is now split into apidocs and a more narrative documentation
• the more narrative documentation is composed out of jupyter notebooks which are converted into html by the nbsphinx sphinx extension
• added first draft of clustering narrative documentation
• AMMs and OOMs are now part of the apidocs
• in mini batch clustering: when calling fit() the previous behavior was falling back to ordinary k-means. Now it takes shuffled samples of the dataset and performs clustering on these mini batches

Is your feature request related to a problem? Please describe. The TICA and VAMP decomposition classes both provide similar interfaces for .fit_from_timeseries(data). However, the TICA class allows a weights argument.

The VAMP decomposition, however, does not support weights, and throws an error if they're provided (see: https://github.com/deeptime-ml/deeptime/blob/11182accb1f8ce263f7c498b76c94bb657b5a998/deeptime/covariance/util/_running_moments.py#L245 )

Describe the solution you'd like Support for weights in VAMP.

I see some similarity between moments_XXXY() and moments_block(), but it seems like there was probably a reason for omitting support for weights from VAMP -- is that correct?

Is your feature request related to a problem? Please describe. I am doing Markov modelling for SAR/QSAR analysis of chemical compounds and would need sorted markov matrices.

I suggest to sort the Markov matrix according to the most stable state. Something like with better memory management:

def sort_markov_matrix(markov_matrix): 
    """Takes in random markov matrix
    returns sorted markov matrix 

    Args:
        markov_matrix (np.array): unsorted matrix

    Returns:
        (np.array): sorted Markov matrix
    """
    
    
    
    b = markov_matrix.copy()
    for i in range(len(markov_matrix)): 
        ref1 = markov_matrix[i,i]
        for j in range(i+1, len(markov_matrix)): 
            ref2 = markov_matrix[j, j]
            if ref2 > ref1: 
                markov_matrix[i, :] = b[j, :]
                markov_matrix[j, :] = b[i, :]
                b = markov_matrix.copy()
                for k in range(len(markov_matrix)):
                    markov_matrix[k,i] = b[k, j]
                    markov_matrix[k,j] = b[k, i]
                    b = markov_matrix.copy()
    return markov_matrix

Test with

def test_sort(): 
    a = np.array([[0.8, 0.1, 0.05, 0.05],[0.005, 0.9, 0.03, 0.015], [0.1, 0.2, 0.4, 0.3],[0.01, 0.02, 0.03, 0.94]])
    sorted_a = sort_markov_matrix(a)
    assert np.array_equal(sorted_a[0,:], np.array([0.94, 0.02, 0.01, 0.03])) == True, str(sorted_a[0,:])
    assert np.array_equal(sorted_a[1,:], np.array([0.015,0.9, 0.005, 0.03])) == True, str(sorted_a[1,:])
    assert np.array_equal(sorted_a[2,:], np.array([0.05, 0.1, 0.8, 0.05])) == True, str(sorted_a[2,:])
    assert np.array_equal(sorted_a[3,:], np.array([0.3, 0.2, 0.1, 0.4])) == True, str(sorted_a[3,:])

What do you think?

Hi All!

love the libray so far.

I was wondering if I could request a feature request of adding the calculation of the covariance matrix by this method below.

https://github.com/hrayrhar/T-CorEx

It does seem difficult in its current format and this api is so much easier to use.

Kind regards, Andrew