Migrated from GitHub

data/.pylintrc

@@ -0,0 +1,55 @@
+## look at http://docutils.sourceforge.net/sandbox/py-rest-doc/utils/pylintrc
+# for some of the options that are available
+
+[MESSAGES CONTROL]
+disable=C0103,R0904,R0903,W0511,R0801,R0401,I0013,W0622,C0325,R0205,W1201,W0621,R0913,R0914,C0415,W0719,R0917
+
+[FORMAT]
+# Maximum number of characters on a single line.
+max-line-length=100
+
+[DESIGN]
+# Maximum number of arguments for function / method
+max-args=15
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+# Maximum number of locals for function / method body
+max-locals=15
+# Maximum number of return / yield for function / method body
+max-returns=6
+# Maximum number of branch for function / method body
+max-branches=30
+# Maximum number of statements in function / method body
+max-statements=65
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+# Maximum number of attributes for a class (see R0902).
+max-attributes=40
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=60
+# checks for similarities and duplicated code. This computation may be
+# memory / CPU intensive, so you should disable it if you experiments some
+# problems.
+#
+
+[SIMILARITIES]
+# Minimum lines number of a similarity.
+min-similarity-lines=25
+# Ignore comments when computing similarities.
+ignore-comments=yes
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+[TYPECHECK]
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamically set).
+#ignored-classes=foo.bar
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=torch,torch_geometric,torch_scatter,torch_cluster,torch_sparse,ptu_dijkstra,scipy.spatial,matplotlib,Cython

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Adam Gosztolai, EPFL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/MANIFEST.in

@@ -0,0 +1 @@
+include MARBLE/default_params.yaml

data/MARBLE/__init__.py

@@ -0,0 +1,6 @@
+"""MARBLE main functions."""
+
+from MARBLE.main import net
+from MARBLE.postprocessing import distribution_distances
+from MARBLE.postprocessing import embed_in_2D
+from MARBLE.preprocessing import construct_dataset

data/MARBLE/dataloader.py

@@ -0,0 +1,97 @@
+"""Data loader module."""
+
+import torch
+from torch_cluster import random_walk
+from torch_geometric.loader import NeighborSampler as NS
+
+
+def loaders(data, par):
+    """Loaders."""
+    nb = [par["n_sampled_nb"]] * par["order"]
+
+    train_loader = NeighborSampler(
+        data.edge_index,
+        sizes=nb,
+        batch_size=par["batch_size"],
+        shuffle=True,
+        num_nodes=data.num_nodes,
+        node_idx=data.train_mask,
+    )
+
+    val_loader = NeighborSampler(
+        data.edge_index,
+        sizes=nb,
+        batch_size=par["batch_size"],
+        shuffle=False,
+        num_nodes=data.num_nodes,
+        node_idx=data.val_mask,
+    )
+
+    test_loader = NeighborSampler(
+        data.edge_index,
+        sizes=nb,
+        batch_size=par["batch_size"],
+        shuffle=False,
+        num_nodes=data.num_nodes,
+        node_idx=data.test_mask,
+    )
+
+    return train_loader, val_loader, test_loader
+
+
+class NeighborSampler(NS):
+    """Neighbor Sampler."""
+
+    def sample(self, batch):
+        """Sample."""
+        row, col, _ = self.adj_t.coo()
+
+        # For each node in `batch`, we sample a direct neighbor (as positive
+        # sample) and a random node (as negative sample):
+        batch = torch.tensor(batch)
+        pos_batch = random_walk(row, col, batch, walk_length=1, coalesced=False)
+        neg_batch = torch.randint(0, self.adj_t.size(1), (batch.numel(),))
+        batch = torch.cat([batch, pos_batch[:, 1], neg_batch], dim=0)
+
+        return super().sample(batch)
+
+
+# =============================================================================
+# below is an alternative implementation, not working yet
+# =============================================================================
+
+# from torch_geometric.loader import LinkNeighborLoader
+# from torch_geometric.utils import subgraph
+
+# def loaders(data, par):
+
+#     nb = [par['n_sampled_nb'] for i in range(max(par['order'], par['depth']))]
+
+#     train_loader = LinkNeighborLoader(
+#         data,
+#         num_neighbors=nb,
+#         shuffle=True,
+#         batch_size=par['batch_size'],
+#         edge_label_index=subgraph(data.train_mask, data.edge_index)[0],
+#         neg_sampling_ratio=1
+#     )
+
+#     val_loader = LinkNeighborLoader(
+#         data,
+#         num_neighbors=nb,
+#         shuffle=False,
+#         batch_size=par['batch_size'],
+#         edge_label_index=subgraph(data.val_mask, data.edge_index)[0],
+#         neg_sampling_ratio=1
+#     )
+
+#     test_loader = LinkNeighborLoader(
+#         data,
+#         num_neighbors=nb,
+#         shuffle=False,
+#         batch_size=par['batch_size'],
+#         edge_label_index=subgraph(data.test_mask, data.edge_index)[0],
+#         neg_sampling_ratio=1
+#     )
+
+#     return train_loader, val_loader, test_loader

data/MARBLE/default_params.yaml

@@ -0,0 +1,25 @@
+#training parameters
+epochs : 100 # optimisation epochs
+batch_size : 64 # batch size
+lr: 0.01 # learning rate
+momentum: 0.9
+dropout: 0. # dropout in the MLP
+batch_norm: True # batch normalisation
+hidden_channels: [32] # number of hidden channels
+bias: True # learn bias parameters in MLP
+
+#manifold/signal parameters
+order: 2 # order to which to compute the directional derivatives
+inner_product_features: False
+diffusion: True
+frac_sampled_nb: -1 # fraction of neighbours to sample for gradient computation (if -1 then all neighbours)
+include_positions: False # include positions as features
+include_self: True # include vector at the center of feature
+
+# embedding parameters
+out_channels: 3 # number of output channels (if null, then =hidden_channels)
+vec_norm: False # normalise features at each order of derivatives
+emb_norm: False # spherical output
+
+# other params
+seed: 0 # seed for reproducibility

data/MARBLE/dynamics.py

@@ -0,0 +1,208 @@
+"""Dynamics module, adapted from DE_library.
+
+TODO: clean this up
+"""
+
+import sys
+
+import numpy as np
+from scipy.integrate import ode
+from scipy.integrate import odeint
+
+
+def fun_vanderpol(par=None):
+    """Van der parol oscillator exhibiting a degenerate Hopf bifurcation"""
+    if par is None:
+        par = {"mu": 1.0}
+
+    def f(_, X):
+        x, y = X
+        f1 = y
+        f2 = par["mu"] * (1 - x**2) * y - x
+
+        return [f1, f2]
+
+    def jac(_, X):
+        x, y = X
+        df1 = [0.0, 1.0]
+        df2 = [-2.0 * par["mu"] * x * y - 1.0, -par["mu"] * x**2]
+
+        return [df1, df2]
+
+    return f, jac
+
+
+def load_ODE(whichmodel, par=None):
+    """Load ODE system.
+
+    Args:
+        whichmodel (string): ODE system from ODE_library.py
+        par (dict, optional): parameters. The default is None
+
+    Returns:
+        f (Callable): ODE function
+        jac (Callable): Jacobian
+    """
+    if par is None:
+        f, jac = getattr(sys.modules[__name__], f"fun_{whichmodel}")()
+    else:
+        f, jac = getattr(sys.modules[__name__], f"fun_{whichmodel}")(par)
+
+    return f, jac
+
+
+def solve_ODE(f, jac, t, x0, solver="standard"):
+    """Solve ODE."""
+    if solver == "standard":
+        x = odeint(f, x0, t, Dfun=jac, tfirst=True)
+        xprime = [f(t_, x_) for t_, x_ in zip(t, x)]
+
+    elif solver == "zvode":
+        r = ode(f, jac)
+        r.set_integrator("zvode", method="bdf")
+        # r.set_integrator('dopri5')
+        r.set_initial_value(x0, t[0])
+
+        # Run ODE integrator
+        x = [x0]
+        xprime = [f(0.0, x0)]
+
+        for _t in t[1:]:
+            r.integrate(_t)
+            x.append(np.real(r.y))
+            xprime.append(f(r.t, np.real(r.y)))
+
+    return np.vstack(x), np.vstack(xprime)
+
+
+def addnoise(X, **noise_pars):
+    """Add noise to trajectories.
+
+    Args:
+        X (numpy array): Trajectories
+        noise_pars: additional keyword argument to specify noise parameters
+
+    Returns:
+        X (len(t)xlen(X0) numpy array) Trajectory
+    """
+    if noise_pars["noise"] == "Gaussian":
+        mu = noise_pars["mu"]
+        sigma = noise_pars["sigma"]
+        X += np.random.normal(mu, sigma, size=X.shape)
+
+    return X
+
+
+def simulate_ODE(whichmodel, t, X0, par=None, **noise_pars):
+    """Load ODE functions and run appropriate solver.
+
+    Args:
+        whichmodel (string): ODE system from ODE_library.py
+        t (array or list): Time steps to evaluate system at
+        x0 (array or list): Initial condition. Size must match the dimension of the ODE system
+        par (dict, optional): Parameters. The default is None
+
+    Returns:
+        X (list): Solution
+        Xprime (list): Time derivative of solution
+    """
+    f, jac = load_ODE(whichmodel, par=par)
+    X, Xprime = solve_ODE(f, jac, t, X0)
+
+    if noise_pars:
+        X = addnoise(X, **noise_pars)
+
+    return X, Xprime
+
+
+def simulate_trajectories(whichmodel, X0_range, t=1, par=None, **noise_pars):
+    """Compute a number of trajectories from the given initial conditions.
+
+    Args:
+        Same as in simulate_ODE(), except:
+        whichmodel (string): ODE system from ODE_library.py
+        X0_range (list(list)): List of initial conditions
+        t (array or list): Time steps to evaluate system at
+        par (dict, optional): Parameters. The default is None
+        noise_pars: additional keyword argument to specify noise parameters
+
+    Returns:
+        X_list (list(list)): Solution for all trajectories
+        Xprime_list (list): Time derivative of solution for all trajectories
+    """
+    X_list, Xprime_list = [], []
+    for X0 in X0_range:
+        X, Xprime = simulate_ODE(whichmodel, t, X0, par=par, **noise_pars)
+        X_list.append(X)
+        Xprime_list.append(Xprime)
+
+    return X_list, Xprime_list
+
+
+def reject_outliers(*args, min_v=-5, max_v=5):
+    """Reject outliers."""
+    inds = []
+    for arg in args:
+        inds.append(np.where((arg > min_v).all(1) * (arg < max_v).all(1))[0])
+
+    return list(set.intersection(*map(set, inds)))
+
+
+def parabola(X, Y, alpha=0.05):
+    """Parabola."""
+    Z = -((alpha * X) ** 2) - (alpha * Y) ** 2
+
+    return np.column_stack([X.flatten(), Y.flatten(), Z.flatten()])
+
+
+def embed_parabola(pos, vel, alpha=0.05):
+    """Embed on parabola."""
+    for i, (p, v) in enumerate(zip(pos, vel)):
+        end_point = p + v
+        new_endpoint = parabola(end_point[:, 0], end_point[:, 1], alpha=alpha)
+        pos[i] = parabola(p[:, 0], p[:, 1], alpha=alpha)
+        vel[i] = new_endpoint - pos[i]
+    return pos, vel
+
+
+def sample_2d(N=100, interval=None, method="uniform", seed=0):
+    """Sample N points in a 2D area."""
+    if interval is None:
+        interval = [[-1, -1], [1, 1]]
+    if method == "uniform":
+        x = np.linspace(interval[0][0], interval[1][0], int(np.sqrt(N)))
+        y = np.linspace(interval[0][1], interval[1][1], int(np.sqrt(N)))
+        x, y = np.meshgrid(x, y)
+        x = np.vstack((x.flatten(), y.flatten())).T
+
+    elif method == "random":
+        np.random.seed(seed)
+        x = np.random.uniform(
+            (interval[0][0], interval[0][1]), (interval[1][0], interval[1][1]), (N, 2)
+        )
+
+    return x
+
+
+def initial_conditions(n, reps, area=None, seed=0):
+    """Generate iniital condition."""
+    if area is None:
+        area = [[-3, -3], [3, 3]]
+    X0_range = [sample_2d(n, area, "random", seed=i + seed) for i in range(reps)]
+
+    return X0_range
+
+
+def simulate_vanderpol(mu, X0, t, keep_v=False):
+    """Simulate vanderpol."""
+    p, v = simulate_trajectories("vanderpol", X0, t, par={"mu": mu})
+    pos, vel = [], []
+    for p_, v_ in zip(p, v):
+        if keep_v:
+            ind = reject_outliers(p_)
+        else:
+            ind = reject_outliers(p_, v_)
+        pos.append(p_[ind])
+        vel.append(v_[ind])
+
+    return pos, vel

data/MARBLE/geometry.py

@@ -0,0 +1,602 @@
+"""Geometry module."""
+
+import numpy as np
+import ot
+import scipy.sparse as sp
+import torch
+import torch_geometric.utils as PyGu
+import umap
+from sklearn.cluster import KMeans
+from sklearn.cluster import MeanShift
+from sklearn.decomposition import PCA
+from sklearn.manifold import MDS
+from sklearn.manifold import TSNE
+from sklearn.manifold import Isomap
+from sklearn.metrics import pairwise_distances
+from sklearn.preprocessing import StandardScaler
+from torch_geometric.nn import knn_graph
+from torch_geometric.nn import radius_graph
+from torch_scatter import scatter_add
+
+from ptu_dijkstra import connections, tangent_frames  # isort:skip
+
+from MARBLE.lib.cknn import cknneighbors_graph  # isort:skip
+from MARBLE import utils  # isort:skip
+
+
+def furthest_point_sampling(x, N=None, spacing=0.0, start_idx=0):
+    """A greedy O(N^2) algorithm to do furthest points sampling
+
+    Args:
+        x (nxdim matrix): input data
+        N (int): number of sampled points
+        stop_crit: when reaching this fraction of the total manifold diameter, we stop sampling
+        start_idx: index of starting node
+
+    Returns:
+        perm: node indices of the N sampled points
+        lambdas: list of distances of furthest points
+    """
+    if spacing == 0.0:
+        return torch.arange(len(x)), None
+
+    D = utils.np2torch(pairwise_distances(x))
+    n = D.shape[0] if N is None else N
+    diam = D.max()
+
+    perm = torch.zeros(n, dtype=torch.int64)
+    perm[0] = start_idx
+    lambdas = torch.zeros(n)
+    ds = D[start_idx, :].flatten()
+    for i in range(1, n):
+        idx = torch.argmax(ds)
+        perm[i] = idx
+        lambdas[i] = ds[idx]
+        ds = torch.minimum(ds, D[idx, :])
+
+        if N is None:
+            if lambdas[i] / diam < spacing:
+                perm = perm[:i]
+                lambdas = lambdas[:i]
+                break
+
+    assert len(perm) == len(np.unique(perm)), "Returned duplicated points"
+
+    return perm, lambdas
+
+
+def cluster(x, cluster_typ="kmeans", n_clusters=15, seed=0):
+    """Cluster data.
+
+    Args:
+        x (nxdim matrix) data
+        cluster_typ: Clustering method.
+        n_clusters: Number of clusters.
+        seed: seed
+
+    Returns:
+        clusters: sklearn cluster object
+    """
+    clusters = {}
+    if cluster_typ == "kmeans":
+        kmeans = KMeans(n_clusters=n_clusters, random_state=seed).fit(x)
+        clusters["n_clusters"] = n_clusters
+        clusters["labels"] = kmeans.labels_
+        clusters["centroids"] = kmeans.cluster_centers_
+    elif cluster_typ == "meanshift":
+        meanshift = MeanShift(bandwidth=n_clusters).fit(x)
+        clusters["n_clusters"] = len(set(meanshift.labels_))
+        clusters["labels"] = meanshift.labels_
+        clusters["centroids"] = meanshift.cluster_centers_
+    else:
+        raise NotImplementedError
+
+    return clusters
+
+
+def embed(x, embed_typ="umap", dim_emb=2, manifold=None, verbose=True, seed=0, **kwargs):
+    """Embed data to 2D space.
+
+    Args:
+        x (nxdim matrix): data
+        embed_typ: embedding method. The default is 'tsne'.
+
+    Returns:
+        emb (nx2 matrix): embedded data
+    """
+    if x.shape[1] <= 2:
+        print(
+            f"\n No {embed_typ} embedding performed. Embedding seems to be \
+              already in 2D."
+        )
+        return x, None
+
+    if embed_typ == "tsne":
+        x = StandardScaler().fit_transform(x)
+        if manifold is not None:
+            raise Exception("t-SNE cannot fit on existing manifold")
+
+        emb = TSNE(init="random", learning_rate="auto", random_state=seed).fit_transform(x)
+
+    elif embed_typ == "umap":
+        x = StandardScaler().fit_transform(x)
+        if manifold is None:
+            manifold = umap.UMAP(n_components=dim_emb, random_state=seed, **kwargs).fit(x)
+
+        emb = manifold.transform(x)
+
+    elif embed_typ == "MDS":
+        if manifold is not None:
+            raise Exception("MDS cannot fit on existing manifold")
+
+        emb = MDS(
+            n_components=dim_emb, n_init=20, dissimilarity="precomputed", random_state=seed
+        ).fit_transform(x)
+
+    elif embed_typ == "PCA":
+        if manifold is None:
+            manifold = PCA(n_components=dim_emb).fit(x)
+
+        emb = manifold.transform(x)
+
+    elif embed_typ == "Isomap":
+        radius = pairwise_distances(x)
+        radius = 0.1 * (radius.max() - radius.min())
+        if manifold is None:
+            manifold = Isomap(n_components=dim_emb, n_neighbors=None, radius=radius).fit(x)
+
+        emb = manifold.transform(x)
+
+    else:
+        raise NotImplementedError
+
+    if verbose:
+        print(f"Performed {embed_typ} embedding on embedded results.")
+
+    return emb, manifold
+
+
+def relabel_by_proximity(clusters):
+    """Update clusters labels such that nearby clusters in the embedding get similar labels.
+
+    Args:
+        clusters: sklearn object containing 'centroids', 'n_clusters', 'labels' as attributes
+
+    Returns:
+        clusters: sklearn object with updated labels
+    """
+    pd = pairwise_distances(clusters["centroids"], metric="euclidean")
+    pd += np.max(pd) * np.eye(clusters["n_clusters"])
+
+    mapping = {}
+    id_old = 0
+    for i in range(clusters["n_clusters"]):
+        id_new = np.argmin(pd[id_old, :])
+        while id_new in mapping:
+            pd[id_old, id_new] += np.max(pd)
+            id_new = np.argmin(pd[id_old, :])
+        mapping[id_new] = i
+        id_old = id_new
+
+    labels = clusters["labels"]
+    clusters["labels"] = np.array([mapping[label] for label in labels])
+    clusters["centroids"] = clusters["centroids"][list(mapping.keys())]
+
+    return clusters
+
+
+def compute_distribution_distances(clusters=None, data=None, slices=None):
+    """Compute the distance between clustered distributions across datasets.
+
+    Args:
+        clusters: sklearn object containing 'centroids', 'slices', 'labels' as attributes
+
+    Returns:
+        dist: distance matrix
+        gamma: optimal transport matrix
+        centroid_distances: distances between cluster centroids
+    """
+    s = slices
+    pdists, cdists = None, None
+    if clusters is not None:
+        # compute discrete measures supported on cluster centroids
+        labels = clusters["labels"]
+        labels = [labels[s[i] : s[i + 1]] + 1 for i in range(len(s) - 1)]
+        nc, nl = clusters["n_clusters"], len(labels)
+        bins_dataset = []
+        for l_ in labels:  # loop over datasets
+            bins = [(l_ == i + 1).sum() for i in range(nc)]  # loop over clusters
+            bins = np.array(bins)
+            bins_dataset.append(bins / bins.sum())
+
+        cdists = pairwise_distances(clusters["centroids"])
+        gamma = np.zeros([nl, nl, nc, nc])
+
+    elif data is not None:
+        # compute empirical measures from datapoints
+        nl = len(s) - 1
+
+        bins_dataset = []
+        for i in range(nl):
+            mu = np.ones(s[i + 1] - s[i])
+            mu /= len(mu)
+            bins_dataset.append(mu)
+
+        pdists = pairwise_distances(data.emb)
+    else:
+        raise Exception("No input provided.")
+
+    # compute distance between measures
+    dist = np.zeros([nl, nl])
+    for i in range(nl):
+        for j in range(i + 1, nl):
+            mu, nu = bins_dataset[i], bins_dataset[j]
+
+            if data is not None and pdists is not None:
+                cdists = pdists[s[i] : s[i + 1], s[j] : s[j + 1]]
+
+            dist[i, j] = ot.emd2(mu, nu, cdists)
+            dist[j, i] = dist[i, j]
+
+            if clusters is not None:
+                gamma[i, j, ...] = ot.emd(mu, nu, cdists)
+                gamma[j, i, ...] = gamma[i, j, ...]
+            else:
+                gamma = None
+
+    return dist, gamma
+
+
+def neighbour_vectors(pos, edge_index):
+    """Local out-going edge vectors around each node.
+
+    Args:
+        pos (nxdim matrix): node positions
+        edge_index (2xE matrix): edge indices
+
+    Returns:
+        nvec (Exdim matrix): neighbourhood vectors.
+
+    """
+    ei, ej = edge_index[0], edge_index[1]
+    nvec = pos[ej] - pos[ei]
+
+    return nvec
+
+
+def project_gauge_to_neighbours(nvec, gauges, edge_index):
+    """Project the gauge vectors to local edge vectors.
+
+    Args:
+        nvec (Exdim matrix): neighbourhood vectors
+        local_gauge (dimxnxdim torch tensor): if None, global gauge is generated
+
+    Returns:
+        list of (nxn) torch tensors of projected components
+    """
+    n, _, d = gauges.shape
+    ei = edge_index[0]
+    proj = torch.einsum("bi,bic->bc", nvec, gauges[ei])
+
+    proj = [sp.coo_matrix((proj[:, i], (edge_index)), [n, n]).tocsr() for i in range(d)]
+
+    return proj
+
+
+def gradient_op(pos, edge_index, gauges):
+    """Directional derivative kernel from Beaini et al. 2021.
+
+    Args:
+        pos (nxdim Matrix) node positions
+        edge_index (2x|E| matrix) edge indices
+        gauge (list): orthonormal unit vectors
+
+    Returns:
+        list of (nxn) Anisotropic kernels
+    """
+    nvec = neighbour_vectors(pos, edge_index)
+    F = project_gauge_to_neighbours(nvec, gauges, edge_index)
+
+    K = []
+    for _F in F:
+        norm = np.repeat(np.add.reduceat(np.abs(_F.data), _F.indptr[:-1]), np.diff(_F.indptr))
+        _F.data /= norm
+        _F -= sp.diags(np.array(_F.sum(1)).flatten())
+        _F = _F.tocoo()
+        K.append(torch.sparse_coo_tensor(np.vstack([_F.row, _F.col]), _F.data.data))
+
+    return K
+
+
+def normalize_sparse_matrix(sp_tensor):
+    """Normalize sparse matrix."""
+    row_sum = sp_tensor.sum(axis=1)
+    row_sum[row_sum == 0] = 1  # to avoid divide by zero
+    sp_tensor = sp_tensor.multiply(1.0 / row_sum)
+
+    return sp_tensor
+
+
+def global_to_local_frame(x, gauges, length_correction=False, reverse=False):
+    """Transform signal into local coordinates."""
+
+    if reverse:
+        proj = torch.einsum("bji,bi->bj", gauges, x)
+    else:
+        proj = torch.einsum("bij,bi->bj", gauges, x)
+
+    if length_correction:
+        norm_x = x.norm(p=2, dim=1, keepdim=True)
+        norm_proj = proj.norm(p=2, dim=1, keepdim=True)
+        proj = proj / norm_proj * norm_x
+
+    return proj
+
+
+def project_to_gauges(x, gauges, dim=2):
+    """Project to gauges."""
+    coeffs = torch.einsum("bij,bi->bj", gauges, x)
+    return torch.einsum("bj,bij->bi", coeffs[:, :dim], gauges[:, :, :dim])
+
+
+def manifold_dimension(Sigma, frac_explained=0.9):
+    """Estimate manifold dimension based on singular vectors"""
+
+    if frac_explained == 1.0:
+        return Sigma.shape[1]
+
+    Sigma **= 2
+    Sigma /= Sigma.sum(1, keepdim=True)
+    Sigma = Sigma.cumsum(dim=1)
+    var_exp = Sigma.mean(0) - Sigma.std(0)
+    dim_man = torch.where(var_exp >= frac_explained)[0][0] + 1
+
+    print("\nFraction of variance explained: ", var_exp.tolist())
+
+    return int(dim_man)
+
+
+def fit_graph(x, graph_type="cknn", par=1, delta=1.0, metric="euclidean"):
+    """Fit graph to node positions"""
+
+    if graph_type == "cknn":
+        edge_index = cknneighbors_graph(x, n_neighbors=par, delta=delta, metric=metric).tocoo()
+        edge_index = np.vstack([edge_index.row, edge_index.col])
+        edge_index = utils.np2torch(edge_index, dtype="double")
+
+    elif graph_type == "knn":
+        edge_index = knn_graph(x, k=par)
+        edge_index = PyGu.add_self_loops(edge_index)[0]
+
+    elif graph_type == "radius":
+        edge_index = radius_graph(x, r=par)
+        edge_index = PyGu.add_self_loops(edge_index)[0]
+
+    else:
+        raise NotImplementedError
+
+    assert is_connected(edge_index), "Graph is not connected! Try increasing k."
+
+    edge_index = PyGu.to_undirected(edge_index)
+    pdist = torch.nn.PairwiseDistance(p=2)
+    edge_weight = pdist(x[edge_index[0]], x[edge_index[1]])
+    edge_weight = 1 / edge_weight
+
+    return edge_index, edge_weight
+
+
+def is_connected(edge_index):
+    """Check if it is connected."""
+    adj = torch.sparse_coo_tensor(edge_index, torch.ones(edge_index.shape[1]))
+    deg = torch.sparse.sum(adj, 0).values()
+
+    return (deg > 1).all()
+
+
+def compute_laplacian(data, normalization="rw"):
+    """Compute Laplacian."""
+    edge_index, edge_attr = PyGu.get_laplacian(
+        data.edge_index,
+        edge_weight=data.edge_weight,
+        normalization=normalization,
+        num_nodes=data.num_nodes,
+    )
+
+    # return PyGu.to_dense_adj(edge_index, edge_attr=edge_attr).squeeze()
+    return torch.sparse_coo_tensor(edge_index, edge_attr).coalesce()
+
+
+def compute_connection_laplacian(data, R, normalization="rw"):
+    r"""Connection Laplacian
+
+    Args:
+        data: Pytorch geometric data object.
+        R (nxnxdxd): Connection matrices between all pairs of nodes. Default is None,
+            in case of a global coordinate system.
+        normalization: None, 'rw'
+                 1. None: No normalization
+                 :math:`\mathbf{L} = \mathbf{D} - \mathbf{A}`
+
+                 2. "rw"`: Random-walk normalization
+                 :math:`\mathbf{L} = \mathbf{I} - \mathbf{D}^{-1} \mathbf{A}`
+
+    Returns:
+        ndxnd normalised connection Laplacian matrix.
+    """
+    n = data.x.shape[0]
+    d = R.size()[0] // n
+
+    # unnormalised (combinatorial) laplacian, to be normalised later
+    L = compute_laplacian(data, normalization=None)  # .to_sparse()
+
+    # rearrange into block form (kron(L, ones(d,d)))
+    edge_index = utils.expand_edge_index(L.indices(), dim=d)
+    L = torch.sparse_coo_tensor(edge_index, L.values().repeat_interleave(d * d))
+
+    # unnormalised connection laplacian
+    # Lc(i,j) = L(i,j)*R(i,j) if (i,j)=\in E else 0
+    Lc = L * R
+
+    # normalize
+    edge_index, edge_weight = PyGu.remove_self_loops(data.edge_index, data.edge_weight)
+    if edge_weight is None:
+        edge_weight = torch.ones(edge_index.size(1), device=edge_index.device)
+
+    # degree matrix
+    deg = scatter_add(edge_weight, edge_index[0], dim=0, dim_size=n)
+
+    if normalization == "rw":
+        deg_inv = 1.0 / deg
+        deg_inv.masked_fill_(deg_inv == float("inf"), 0)
+        deg_inv = deg_inv.repeat_interleave(d, dim=0)
+        Lc = torch.diag(deg_inv).to_sparse() @ Lc
+
+    return Lc.coalesce()
+
+
+def compute_gauges(data, dim_man=None, n_geodesic_nb=10, processes=1):
+    """Orthonormal gauges for the tangent space at each node.
+
+    Args:
+        data: Pytorch geometric data object.
+        n_geodesic_nb: number of geodesic neighbours. The default is 10.
+        processes: number of CPUs to use
+
+    Returns:
+        gauges (nxdimxdim matrix): Matrix containing dim unit vectors for each node.
+        Sigma: Singular valued
+    """
+    X = data.pos.numpy().astype(np.float64)
+    A = PyGu.to_scipy_sparse_matrix(data.edge_index).tocsr()
+
+    # make chunks for data processing
+    sl = data._slice_dict["x"]  # pylint: disable=protected-access
+    n = len(sl) - 1
+    X = [X[sl[i] : sl[i + 1]] for i in range(n)]
+    A = [A[sl[i] : sl[i + 1], :][:, sl[i] : sl[i + 1]] for i in range(n)]
+
+    if dim_man is None:
+        dim_man = X[0].shape[1]
+
+    inputs = [X, A, dim_man, n_geodesic_nb]
+    out = utils.parallel_proc(
+        _compute_gauges,
+        range(n),
+        inputs,
+        processes=processes,
+        desc="\n---- Computing tangent spaces...",
+    )
+
+    gauges, Sigma = zip(*out)
+    gauges, Sigma = np.vstack(gauges), np.vstack(Sigma)
+
+    return utils.np2torch(gauges), utils.np2torch(Sigma)
+
+
+def _compute_gauges(inputs, i):
+    """Helper function to compute_gauges()"""
+    X_chunks, A_chunks, dim_man, n_geodesic_nb = inputs
+    gauges, Sigma = tangent_frames(X_chunks[i], A_chunks[i], dim_man, n_geodesic_nb)
+
+    return gauges, Sigma
+
+
+def compute_connections(data, gauges, processes=1):
+    """Find smallest rotations R between gauges pairs. It is assumed that the first
+    row of edge_index is what we want to align to, i.e.,
+    gauges(i) = gauges(j)@R[i,j].T
+
+    R[i,j] is optimal rotation that minimises ||X - RY||_F computed by SVD:
+    X, Y = gauges[i].T, gauges[j].T
+    U, _, Vt = scipy.linalg.svd(X.T@Y)
+    R[i,j] = U@Vt
+
+    Args:
+        data: Pytorch geometric data object
+        gauges (nxdxd matrix): Orthogonal unit vectors for each node
+        processes: number of CPUs to use
+
+    Returns:
+        (n*dim,n*dim) matrix of rotation matrices
+    """
+    gauges = np.array(gauges, dtype=np.float64)
+    A = PyGu.to_scipy_sparse_matrix(data.edge_index).tocsr()
+
+    # make chunks for data processing
+    sl = data._slice_dict["x"]  # pylint: disable=protected-access
+    dim_man = gauges.shape[-1]
+
+    n = len(sl) - 1
+    gauges = [gauges[sl[i] : sl[i + 1]] for i in range(n)]
+    A = [A[sl[i] : sl[i + 1], :][:, sl[i] : sl[i + 1]] for i in range(n)]
+
+    inputs = [gauges, A, dim_man]
+    out = utils.parallel_proc(
+        _compute_connections,
+        range(n),
+        inputs,
+        processes=processes,
+        desc="\n---- Computing connections...",
+    )
+
+    return utils.to_block_diag(out)
+
+
+def _compute_connections(inputs, i):
+    """helper function to compute_connections()"""
+    gauges_chunks, A_chunks, dim_man = inputs
+
+    R = connections(gauges_chunks[i], A_chunks[i], dim_man)
+
+    edge_index = np.vstack([A_chunks[i].tocoo().row, A_chunks[i].tocoo().col])
+    edge_index = torch.tensor(edge_index)
+    edge_index = utils.expand_edge_index(edge_index, dim=R.shape[-1])
+    return torch.sparse_coo_tensor(edge_index, R.flatten(), dtype=torch.float32).coalesce()
+
+
+def compute_eigendecomposition(A, k=None, eps=1e-8):
+    """Eigendecomposition of a square matrix A.
+
+    Args:
+        A: square matrix A
+        k: number of eigenvectors
+        eps: small error term
+
+    Returns:
+        evals (k): eigenvalues of the Laplacian
+        evecs (V,k): matrix of eigenvectors of the Laplacian
+    """
+    if A is None:
+        return None
+
+    if k is None:
+        A = A.to_dense().double()
+    else:
+        indices, values, size = A.indices(), A.values(), A.size()
+        A = sp.coo_array((values, (indices[0], indices[1])), shape=size)
+
+    failcount = 0
+    while True:
+        try:
+            if k is None:
+                evals, evecs = torch.linalg.eigh(A)  # pylint: disable=not-callable
+            else:
+                evals, evecs = sp.linalg.eigsh(A, k=k, which="SM")
+                evals, evecs = torch.tensor(evals), torch.tensor(evecs)
+
+            evals = torch.clamp(evals, min=0.0)
+            evecs *= np.sqrt(len(evecs))
+
+            break
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            print(e)
+            if failcount > 3:
+                raise ValueError("failed to compute eigendecomp") from e
+            failcount += 1
+            print("--- decomp failed; adding eps ===> count: " + str(failcount))
+            if k is None:
+                A += torch.eye(A.shape[0]) * (eps * 10 ** (failcount - 1))
+            else:
+                A += sp.eye(A.shape[0]) * (eps * 10 ** (failcount - 1))
+
+    return evals.float(), evecs.float()

data/MARBLE/layers.py

@@ -0,0 +1,130 @@
+"""Layer module."""
+
+import torch
+from torch import nn
+from torch_geometric.nn.conv import MessagePassing
+
+from MARBLE import smoothing as s
+
+
+class Diffusion(nn.Module):
+    """Diffusion with learned t."""
+
+    def __init__(self, tau0=0.0):
+        """initialise."""
+        super().__init__()
+
+        self.diffusion_time = nn.Parameter(torch.tensor(float(tau0)))
+
+    def forward(self, x, L, Lc=None, method="spectral"):
+        """Forward."""
+        if method == "spectral":
+            assert len(L) == 2, "L must be a matrix or a pair of eigenvalues and eigenvectors"
+
+        # making sure diffusion times are positive
+        with torch.no_grad():
+            self.diffusion_time.data = torch.clamp(self.diffusion_time, min=1e-8)
+
+        t = self.diffusion_time
+
+        if Lc is not None:
+            out = s.vector_diffusion(x, t, Lc, L=L, method=method, normalise=True)
+        else:
+            out = [s.scalar_diffusion(x_, t, method, L) for x_ in x.T]
+            out = torch.cat(out, axis=1)
+
+        return out
+
+
+class AnisoConv(MessagePassing):
+    """Anisotropic Convolution"""
+
+    def __init__(self, **kwargs):
+        """Initialize."""
+        super().__init__(aggr="add", **kwargs)
+
+    def forward(self, x, kernels):
+        """Forward."""
+        out = []
+        for K in kernels:
+            out.append(self.propagate(K, x=x))
+
+        # [[dx1/du, dx2/du], [dx1/dv, dx2/dv]] -> [dx1/du, dx1/dv, dx2/du, dx2/dv]
+        out = torch.stack(out, axis=2)
+        out = out.view(out.shape[0], -1)
+
+        return out
+
+    def message_and_aggregate(self, K_t, x):
+        """Message passing step. If K_t is a txs matrix (s sources, t targets),
+        do matrix multiplication K_t@x, broadcasting over column features.
+        If K_t is a t*dimxs*dim matrix, in case of manifold computations,
+        then first reshape, assuming that the columns of x are ordered as
+        [dx1/du, x1/dv, ..., dx2/du, dx2/dv, ...].
+        """
+        n, dim = x.shape
+
+        if (K_t.size(dim=1) % n * dim) == 0:
+            n_ch = torch.div(n * dim, K_t.size(dim=1), rounding_mode="floor")
+            x = x.view(-1, n_ch)
+
+        x = K_t.matmul(x, reduce=self.aggr)
+
+        return x.view(-1, dim)
+
+
+class InnerProductFeatures(nn.Module):
+    r"""Compute scaled inner-products between channel vectors.
+
+    Input: (V x C*D) vector of (V x n_i) list of vectors with \sum_in_i = C*D
+    Output: (VxC) dot products
+    """
+
+    def __init__(self, C, D):
+        super().__init__()
+
+        self.C, self.D = C, D
+
+        self.O_mat = nn.ModuleList()
+        for _ in range(C):
+            self.O_mat.append(nn.Linear(D, D, bias=False))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        """Reset parameters."""
+        for i, _ in enumerate(self.O_mat):
+            self.O_mat[i].weight.data = torch.eye(self.D)
+
+    def forward(self, x):
+        """Forward."""
+        if not isinstance(x, list):
+            x = [x]
+
+        x = [x_.view(x_.shape[0], -1, self.D) for x_ in x]
+
+        # for scalar signals take magnitude
+        if self.D == 1:
+            x = [x_.norm(dim=2) for x_ in x]
+
+            return torch.cat(x, axis=1)
+
+        # for vector signals take inner products
+        # bring to form where all columns are vector in the tangent space
+        # so taking inner products is possible
+        # [ x1 dx1/du ...]
+        #  x2 dx1/dv
+        #  x3 dx1/dw
+        x = [x_.swapaxes(1, 2) for x_ in x]
+        x = torch.cat(x, axis=2)
+
+        assert x.shape[2] == self.C, "Number of channels is incorrect!"
+
+        # O_ij@x_j
+        Ox = [self.O_mat[j](x[..., j]) for j in range(self.C)]
+        Ox = torch.stack(Ox, dim=2)
+
+        # \sum_j x_i^T@O_ij@x_j
+        xOx = torch.einsum("bki,bkj->bi", x, Ox)
+
+        return torch.tanh(xOx).reshape(x.shape[0], -1)

data/MARBLE/lib/__init__.py

@@ -0,0 +1 @@
+"""Lib module."""

data/MARBLE/lib/cknn.py

@@ -0,0 +1,146 @@
+"""Module imported and adapted from https://github.com/chlorochrule/cknn."""
+
+import numpy as np
+from scipy.sparse import csr_matrix
+from scipy.spatial.distance import pdist
+from scipy.spatial.distance import squareform
+
+
+def cknneighbors_graph(
+    X,
+    n_neighbors,
+    delta=1.0,
+    metric="euclidean",
+    t="inf",
+    include_self=False,
+    is_sparse=True,
+    return_instance=False,
+):
+    """Main function to call, see CkNearestNeighbors for the doc."""
+    cknn = CkNearestNeighbors(
+        n_neighbors=n_neighbors,
+        delta=delta,
+        metric=metric,
+        t=t,
+        include_self=include_self,
+        is_sparse=is_sparse,
+    )
+    cknn.cknneighbors_graph(X)
+
+    if return_instance:
+        return cknn
+    return cknn.ckng
+
+
+class CkNearestNeighbors(object):
+    """This object provides the all logic of CkNN.
+
+    Args:
+        n_neighbors: int, optional, default=5
+            Number of neighbors to estimate the density around the point.
+            It appeared as a parameter `k` in the paper.
+
+        delta: float, optional, default=1.0
+            A parameter to decide the radius for each points. The combination
+            radius increases in proportion to this parameter.
+
+        metric: str, optional, default='euclidean'
+            The metric of each points. This parameter depends on the parameter
+            `metric` of scipy.spatial.distance.pdist.
+
+        t: 'inf' or float or int, optional, default='inf'
+            The decay parameter of heat kernel. The weights are calculated as
+            follow:
+
+                W_{ij} = exp(-(||x_{i}-x_{j}||^2)/t)
+
+            For more infomation, read the paper 'Laplacian Eigenmaps for
+            Dimensionality Reduction and Data Representation', Belkin, et. al.
+
+        include_self: bool, optional, default=True
+            All diagonal elements are 1.0 if this parameter is True.
+
+        is_sparse: bool, optional, default=True
+            The method `cknneighbors_graph` returns csr_matrix object if this
+            parameter is True else returns ndarray object.
+    """
+
+    def __init__(
+        self,
+        n_neighbors=5,
+        delta=1.0,
+        metric="euclidean",
+        t="inf",
+        include_self=False,
+        is_sparse=True,
+    ):
+        self.n_neighbors = n_neighbors
+        self.delta = delta
+        self.metric = metric
+        self.t = t
+        self.include_self = include_self
+        self.is_sparse = is_sparse
+        self.ckng = None
+
+    def cknneighbors_graph(self, X):
+        """A method to calculate the CkNN graph
+
+        Args:
+            X: ndarray
+                The data matrix.
+
+        return: csr_matrix (if self.is_sparse is True)
+                or ndarray(if self.is_sparse is False)
+        """
+
+        n_neighbors = self.n_neighbors
+        delta = self.delta
+        metric = self.metric
+        t = self.t
+        include_self = self.include_self
+        is_sparse = self.is_sparse
+
+        n_samples = X.shape[0]
+
+        if n_neighbors < 1 or n_neighbors > n_samples - 1:
+            raise ValueError("`n_neighbors` must be in the range 1 to number of samples")
+        if len(X.shape) != 2:
+            raise ValueError("`X` must be 2D matrix")
+        if n_samples < 2:
+            raise ValueError("At least 2 data points are required")
+
+        if metric == "precomputed":
+            if X.shape[0] != X.shape[1]:
+                raise ValueError("`X` must be square matrix")
+            dmatrix = X
+        else:
+            dmatrix = squareform(pdist(X, metric=metric))
+
+        darray_n_nbrs = np.partition(dmatrix, n_neighbors)[:, [n_neighbors]]
+        ratio_matrix = dmatrix / np.sqrt(darray_n_nbrs.dot(darray_n_nbrs.T))
+        diag_ptr = np.arange(n_samples)
+
+        if not isinstance(delta, (int, float)):
+            raise ValueError("Invalid argument type. Type of `delta` must be float or int")
+        adjacency = csr_matrix(ratio_matrix < delta)
+
+        if include_self:
+            adjacency[diag_ptr, diag_ptr] = True
+        else:
+            adjacency[diag_ptr, diag_ptr] = False
+
+        if t == "inf":
+            neigh = adjacency.astype(float)
+        else:
+            mask = adjacency.nonzero()
+            weights = np.exp(-np.power(dmatrix[mask], 2) / t)
+            dmatrix[:] = 0.0
+            dmatrix[mask] = weights
+            neigh = csr_matrix(dmatrix)
+
+        if is_sparse:
+            self.ckng = neigh
+        else:
+            self.ckng = neigh.toarray()
+
+        return self.ckng

data/MARBLE/lib/ptu_dijkstra.pyx

@@ -0,0 +1,689 @@
+"""
+Contains modified scripts from the ptu_dijkstra algorithm.
+
+The Fibbonacci Heap data structure and several components related to Dijkstra's
+standard algorithm were adopted from `scipy.sparse.csgraph._shortest_path.pyx`,
+authored and copywrited by Jake Vanderplas  -- <vanderplas@astro.washington.edu>
+under BSD in 2011.
+
+Author of all additional code pertaining to the PTU Dijkstra Algorithm is
+Max Budninskiy (C). License: modified (3-clause) BSD, 2020.
+"""
+import warnings
+
+import numpy as np
+from scipy.sparse.csgraph._validation import validate_graph
+
+cimport cython
+cimport numpy as np
+cimport scipy.linalg.cython_lapack as cython_lapack
+from libc.math cimport sqrt
+from libc.stdlib cimport free
+from libc.stdlib cimport malloc
+
+DTYPE = np.float64
+ctypedef np.float64_t DTYPE_t
+
+ITYPE = np.int32
+ctypedef np.int32_t ITYPE_t
+
+
+def tangent_frames(X,
+                 csgraph,
+                 d,
+                 K):
+    """
+    Algorithm for tangent frame computation.
+
+    Parameters
+    ----------
+    X: numpy matrix
+        (N, D) matrix of N input data points in D dimensional space sampling a
+        lower dimensional manifold S
+    csgraph : sparse matrix
+        Distance weighted proximity graph of pointset X
+    d : int
+        Dimension of the manifold S
+    K : int
+        Number of points to include in geodesic neighborhoods. Geodesic
+        neighborhood of a point x of size K is K nearest neighbors to x in
+        the proximity graph. Notice it's different than simple K nearest
+        neighbors in ambient D dimensional space. Geodesic neighborhood of
+        point x is used to compute local tangent space to the data manifold at
+        x.
+
+    Returns
+    -------
+
+    Notes
+    -----
+    The input csgraph is symmetrized first.
+    """
+    N = X.shape[0]
+    D = X.shape[1]
+    cdef ITYPE_t N_t = N
+    cdef ITYPE_t K_t = K
+    cdef ITYPE_t D_t = D
+    cdef ITYPE_t d_t = d
+
+    if K >= N:
+        raise ValueError(
+            "Geodesic neighborhood size must be less than the "
+            "total number of samples"
+        )
+    if K < d:
+        raise ValueError(
+            "Geodesic neighborhood size must be larger or equal to the "
+            "embedding dimension"
+        )
+    if D < d:
+        raise ValueError(
+            "Embedding dimension must be less or equal to the ambient "
+            "dimension of input data"
+        )
+
+    csgraph = validate_graph(csgraph, directed=True, dtype=DTYPE,
+                             dense_output=False)
+
+    if np.any(csgraph.data < 0):
+        warnings.warn("Graph has negative weights: \
+                      negative distances are not allowed.")
+
+    # initialize ptu distances, and tangent spaces
+    ptu_dists = np.zeros((N, N), dtype=DTYPE)
+    ptu_dists.fill(np.inf)
+    tangents = np.empty((N, D, d), dtype=DTYPE)
+    Sigma = np.empty((N, d), dtype=DTYPE)
+
+    # symmetrize the graph
+    csgraphT = csgraph.T.tocsr()
+    symmetrized_graph = csgraph.maximum(csgraphT)
+    graph_data = symmetrized_graph.data
+    graph_indices = symmetrized_graph.indices
+    graph_indptr = symmetrized_graph.indptr
+    
+    e = len(graph_indices)
+
+    tangents_status = _geodesic_neigborhood_tangents(
+            X,
+            graph_data,
+            graph_indices,
+            graph_indptr,
+            tangents,
+            Sigma,
+            N_t,
+            K_t,
+            D_t,
+            d_t
+    )
+    if tangents_status == -1:
+        raise RuntimeError(
+            'Local tangent space approximation failed, at least one geodesic '
+            'neighborhood does not span d-dimensional space'
+        )
+
+    return tangents, Sigma
+        
+        
+def connections(tangents,
+                csgraph,
+                d):
+    """
+    Algorithm for tangent frame computation.
+
+    Parameters
+    ----------
+    tangents
+    csgraph : sparse matrix
+        Distance weighted proximity graph of pointset X
+    d : int
+        Dimension of the manifold S
+
+    Returns
+    -------
+    
+
+    Notes
+    -----
+    The input csgraph is symmetrized first.
+    """
+    N = tangents.shape[0]
+    D = tangents.shape[1]
+    cdef ITYPE_t N_t = N
+    cdef ITYPE_t D_t = D
+    cdef ITYPE_t d_t = d
+
+    if D < d:
+        raise ValueError(
+            "Embedding dimension must be less or equal to the ambient "
+            "dimension of input data"
+        )
+
+    csgraph = validate_graph(csgraph, directed=True, dtype=DTYPE,
+                             dense_output=False)
+
+    if np.any(csgraph.data < 0):
+        warnings.warn("Graph has negative weights: \
+                      negative distances are not allowed.")
+
+    # initialize ptu distances, and tangent spaces
+    ptu_dists = np.zeros((N, N), dtype=DTYPE)
+    ptu_dists.fill(np.inf)
+
+    # symmetrize the graph
+    csgraphT = csgraph.T.tocsr()
+    symmetrized_graph = csgraph.maximum(csgraphT)
+    graph_data = symmetrized_graph.data
+    graph_indices = symmetrized_graph.indices
+    graph_indptr = symmetrized_graph.indptr
+    
+    e = len(graph_indices)
+    R = np.empty(shape=[e, d, d], dtype=DTYPE)
+
+    _parallel_transport_dijkstra(
+            graph_indices,
+            graph_indptr,
+            tangents,
+            R,
+            N_t,
+            D_t,
+            d_t
+    )
+
+    return R
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef _parallel_transport_dijkstra(
+            int[:] csr_indices,
+            int[:] csr_indptr,
+            double[:, :, :] tangents,
+            double[:, :, :] R,
+            int N,
+            int D,
+            int d
+            ):
+    """
+    Performs parallel transport Dijkstra pairwise distance estimation.
+
+    Parameters:
+    csr_indices: array (int)
+        Indices of sparce csr proximity graph matrix.
+    csr_indptr: array (int)
+        Index pointers of sparce csr proximity graph matrix.
+    tangents: 3 dimensional tensor
+        Collection of N local tangent space bases of size (D, d).
+    N: int
+        Number of points in dataset X.
+    D: int
+        Ambient dimension of pointset X.
+    d: int
+        Dimension of manifold S that is sampled by X.
+    """
+    cdef:
+        int i, k, p, q, j, count
+        int info, lwork = 6*d
+        double temp
+
+        np.ndarray[DTYPE_t, ndim=1] Work = np.empty(shape=[lwork], dtype=DTYPE)
+        np.ndarray[DTYPE_t, ndim=2] TtT = np.empty(shape=[d, d], dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=2] U = np.empty(shape=[d, d], dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=2] VT = np.empty(shape=[d, d], dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=1] S = np.empty(shape=d, dtype=DTYPE)
+
+    count = 0
+    for i in range(N):
+        for j in csr_indices[csr_indptr[i]:csr_indptr[i+1]]:
+                for p in range(d):
+                    for q in range(d):
+                        temp = 0
+                        for k in range(D):
+                            temp += tangents[i, k, p] * tangents[j, k, q]
+                        TtT[p, q] = temp
+
+                # U, S, VT = SVD(TtT)
+                # see LAPACK docs for details
+                cython_lapack.dgesvd(
+                    'A',
+                    'A',
+                    &d,
+                    &d,
+                    &TtT[0, 0],
+                    &d,
+                    &S[0],
+                    &U[0, 0],
+                    &d,
+                    &VT[0, 0],
+                    &d,
+                    &Work[0],
+                    &lwork,
+                    &info
+                )
+
+                for p in range(d):
+                    for q in range(d):
+                        temp = 0
+                        for k in range(d):
+                            temp += U[p, k] * VT[k, q]
+                        R[count,p,q] = temp
+                count += 1
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef int _geodesic_neigborhood_tangents(
+            double[:, :] X,
+            double[:] csr_weights,
+            int[:] csr_indices,
+            int[:] csr_indptr,
+            double[:, :, :] tangents,
+            double[:, :] Sigma,
+            int N,
+            int K,
+            int D,
+            int d,
+            ):
+    """
+    Computes a tangent space for every input point using geodesic neighborhoods.
+
+    Parameters:
+    X: matrix
+        The (N, D) matrix of N input data points in D dimensional space sampling
+        a lower dimensional manifold S.
+    csr_weights: array
+        Values of sparse csr distance weighted adjacency matrix
+        representing proximity graph of pointset X.
+    csr_indices: array (int)
+        Indices of sparce csr proximity graph matrix.
+    csr_indptr: array (int)
+        Index pointers of sparce csr proximity graph matrix.
+    tangets: 3 dimensional tensor
+        [Output] Collection of N local tangent space bases of size (D, d).
+    Sigma: 2 dimensional tensor
+        [Output] Singular values for all vertices
+    N: int
+        Number of points in dataset X.
+    K: int
+        Number of points used to define a gedesic neighborhood.
+    D: int
+        Ambient dimension of pointset X.
+    d: int
+        Dimension of manifold S that is sampled by X.
+    """
+    cdef:
+        unsigned int i, j, k, l, p, q, scanned_cntr, k_current
+        int return_pred = 0, Kp1 = K + 1, mn = min(D, Kp1)
+        int info, lwork = max(3*min(D, Kp1) + max(D, Kp1), 5*min(D, Kp1))
+        double mean, next_val
+
+        np.ndarray[DTYPE_t, ndim=2] geoNbh = np.empty(shape=[D, Kp1], dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=2] U = np.empty(shape=(D, mn), dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=2] VT = np.empty(shape=(mn, Kp1), dtype=DTYPE, order='F')
+        np.ndarray[DTYPE_t, ndim=1] S = np.empty(shape=mn, dtype=DTYPE)
+        np.ndarray[DTYPE_t, ndim=1] Work = np.empty(shape=[lwork], dtype=DTYPE)
+        np.ndarray[ITYPE_t, ndim=1] geoNbh_indices = np.empty(shape=Kp1, dtype=ITYPE)
+
+        FibonacciHeap heap
+        FibonacciNode *v
+        FibonacciNode *nodes = <FibonacciNode*> malloc(N *
+                                                       sizeof(FibonacciNode))
+        FibonacciNode *current_node
+
+    if nodes == NULL:
+        raise MemoryError("Failed to allocate memory in _geodesic_neigborhood_tangents")
+
+    for i in range(N):
+
+        # initialize nodes for Dijkstra
+        for k in range(N):
+            initialize_node(&nodes[k], k)
+
+        # insert node i into heap
+        heap.min_node = NULL
+        insert_node(&heap, &nodes[i])
+
+        # counter of processed points closest to i
+        scanned_cntr = 0
+
+        # perform standard Dijkstra until K closest points are discovered
+        # keep track of the indices of these K points
+        while (heap.min_node) and (scanned_cntr <= K):
+            v = remove_min(&heap)
+            v.state = SCANNED
+            j = v.index
+            geoNbh_indices[scanned_cntr] = j
+            scanned_cntr += 1
+            if scanned_cntr <= K:
+                for k in range(csr_indptr[j], csr_indptr[j + 1]):
+                    k_current = csr_indices[k]
+                    current_node = &nodes[k_current]
+                    if current_node.state != SCANNED:
+                        next_val = v.val + csr_weights[k]
+                        if current_node.state == NOT_IN_HEAP:
+                            current_node.state = IN_HEAP
+                            current_node.val = next_val
+                            insert_node(&heap, current_node)
+                        elif current_node.val > next_val:
+                            decrease_val(&heap, current_node,
+                                         next_val)
+
+        # construct and center geodesic neighborhood from indices
+        for p in range(D):
+            mean = 0
+            for q in range(Kp1):
+                geoNbh[p, q] = X[geoNbh_indices[q], p]
+                mean += geoNbh[p, q]
+            mean = mean / Kp1
+            for q in range(Kp1):
+                geoNbh[p, q] -= mean
+
+        # perform SVD of the geodesic neighborhood points
+        # see LAPACK docs for details
+        cython_lapack.dgesvd(
+            'S',
+            'N',
+            &D,
+            &Kp1,
+            &geoNbh[0, 0],
+            &D,
+            &S[0],
+            &U[0, 0],
+            &D,
+            &VT[0, 0],
+            &mn,
+            &Work[0],
+            &lwork,
+            &info
+        )
+
+        # d left singular vectors form a basis for tangent space at point i
+        for q in range(d):
+            if S[q] < 1e-10:
+                return -1
+            for p in range(D):
+                tangents[i, p, q] = U[p, q]
+                
+        # d left singular vectors form a basis for tangent space at point i
+        for q in range(d):
+            Sigma[i, q] = S[q]
+
+    free(nodes)
+    return 1
+
+######################################################################
+# FibonacciNode structure
+#  This structure and the operations on it are the nodes of the
+#  Fibonacci heap.
+#
+cdef enum FibonacciState:
+    SCANNED
+    NOT_IN_HEAP
+    IN_HEAP
+
+
+cdef struct FibonacciNode:
+    unsigned int index
+    unsigned int rank
+    unsigned int source
+    FibonacciState state
+    DTYPE_t val
+    FibonacciNode* parent
+    FibonacciNode* left_sibling
+    FibonacciNode* right_sibling
+    FibonacciNode* children
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void initialize_node(FibonacciNode* node,
+                          unsigned int index,
+                          DTYPE_t val=0):
+    # Assumptions: - node is a valid pointer
+    #              - node is not currently part of a heap
+    node.index = index
+    node.source = -9999
+    node.val = val
+    node.rank = 0
+    node.state = NOT_IN_HEAP
+
+    node.parent = NULL
+    node.left_sibling = NULL
+    node.right_sibling = NULL
+    node.children = NULL
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef FibonacciNode* rightmost_sibling(FibonacciNode* node):
+    # Assumptions: - node is a valid pointer
+    cdef FibonacciNode* temp = node
+    while(temp.right_sibling):
+        temp = temp.right_sibling
+    return temp
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef FibonacciNode* leftmost_sibling(FibonacciNode* node):
+    # Assumptions: - node is a valid pointer
+    cdef FibonacciNode* temp = node
+    while(temp.left_sibling):
+        temp = temp.left_sibling
+    return temp
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void add_child(FibonacciNode* node, FibonacciNode* new_child):
+    # Assumptions: - node is a valid pointer
+    #              - new_child is a valid pointer
+    #              - new_child is not the sibling or child of another node
+    new_child.parent = node
+
+    if node.children:
+        add_sibling(node.children, new_child)
+    else:
+
+        node.children = new_child
+        new_child.right_sibling = NULL
+        new_child.left_sibling = NULL
+        node.rank = 1
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void add_sibling(FibonacciNode* node, FibonacciNode* new_sibling):
+    # Assumptions: - node is a valid pointer
+    #              - new_sibling is a valid pointer
+    #              - new_sibling is not the child or sibling of another node
+    cdef FibonacciNode* temp = rightmost_sibling(node)
+    temp.right_sibling = new_sibling
+    new_sibling.left_sibling = temp
+    new_sibling.right_sibling = NULL
+    new_sibling.parent = node.parent
+    if new_sibling.parent:
+        new_sibling.parent.rank += 1
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void remove(FibonacciNode* node):
+    # Assumptions: - node is a valid pointer
+    if node.parent:
+        node.parent.rank -= 1
+        if node.left_sibling:
+            node.parent.children = node.left_sibling
+        elif node.right_sibling:
+            node.parent.children = node.right_sibling
+        else:
+            node.parent.children = NULL
+
+    if node.left_sibling:
+        node.left_sibling.right_sibling = node.right_sibling
+    if node.right_sibling:
+        node.right_sibling.left_sibling = node.left_sibling
+
+    node.left_sibling = NULL
+    node.right_sibling = NULL
+    node.parent = NULL
+
+
+######################################################################
+# FibonacciHeap structure
+#  This structure and operations on it use the FibonacciNode
+#  routines to implement a Fibonacci heap
+
+ctypedef FibonacciNode* pFibonacciNode
+
+
+cdef struct FibonacciHeap:
+    FibonacciNode* min_node
+    pFibonacciNode[100] roots_by_rank  # maximum number of nodes is ~2^100.
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void insert_node(FibonacciHeap* heap,
+                      FibonacciNode* node):
+    # Assumptions: - heap is a valid pointer
+    #              - node is a valid pointer
+    #              - node is not the child or sibling of another node
+    if heap.min_node:
+        add_sibling(heap.min_node, node)
+        if node.val < heap.min_node.val:
+            heap.min_node = node
+    else:
+        heap.min_node = node
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void decrease_val(FibonacciHeap* heap,
+                       FibonacciNode* node,
+                       DTYPE_t newval):
+    # Assumptions: - heap is a valid pointer
+    #              - newval <= node.val
+    #              - node is a valid pointer
+    #              - node is not the child or sibling of another node
+    #              - node is in the heap
+    node.val = newval
+    if node.parent and (node.parent.val >= newval):
+        remove(node)
+        insert_node(heap, node)
+    elif heap.min_node.val > node.val:
+        heap.min_node = node
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef void link(FibonacciHeap* heap, FibonacciNode* node):
+    # Assumptions: - heap is a valid pointer
+    #              - node is a valid pointer
+    #              - node is already within heap
+
+    cdef FibonacciNode *linknode
+    cdef FibonacciNode *parent
+    cdef FibonacciNode *child
+
+    if heap.roots_by_rank[node.rank] == NULL:
+        heap.roots_by_rank[node.rank] = node
+    else:
+        linknode = heap.roots_by_rank[node.rank]
+        heap.roots_by_rank[node.rank] = NULL
+
+        if node.val < linknode.val or node == heap.min_node:
+            remove(linknode)
+            add_child(node, linknode)
+            link(heap, node)
+        else:
+            remove(node)
+            add_child(linknode, node)
+            link(heap, linknode)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cdef FibonacciNode* remove_min(FibonacciHeap* heap):
+    # Assumptions: - heap is a valid pointer
+    #              - heap.min_node is a valid pointer
+    cdef:
+        FibonacciNode *temp
+        FibonacciNode *temp_right
+        FibonacciNode *out
+        unsigned int i
+
+    # make all min_node children into root nodes
+    if heap.min_node.children:
+        temp = leftmost_sibling(heap.min_node.children)
+        temp_right = NULL
+
+        while temp:
+            temp_right = temp.right_sibling
+            remove(temp)
+            add_sibling(heap.min_node, temp)
+            temp = temp_right
+
+        heap.min_node.children = NULL
+
+    # choose a root node other than min_node
+    temp = leftmost_sibling(heap.min_node)
+    if temp == heap.min_node:
+        if heap.min_node.right_sibling:
+            temp = heap.min_node.right_sibling
+        else:
+            out = heap.min_node
+            heap.min_node = NULL
+            return out
+
+    # remove min_node, and point heap to the new min
+    out = heap.min_node
+    remove(heap.min_node)
+    heap.min_node = temp
+
+    # re-link the heap
+    for i in range(100):
+        heap.roots_by_rank[i] = NULL
+
+    while temp:
+        if temp.val < heap.min_node.val:
+            heap.min_node = temp
+        temp_right = temp.right_sibling
+        link(heap, temp)
+        temp = temp_right
+
+    return out
+
+
+######################################################################
+# Debugging: Functions for printing the Fibonacci heap
+#
+#cdef void print_node(FibonacciNode* node, int level=0):
+#    print '%s(%i,%i) %i' % (level*'   ', node.index, node.val, node.rank)
+#    if node.children:
+#        print_node(leftmost_sibling(node.children), level+1)
+#    if node.right_sibling:
+#        print_node(node.right_sibling, level)
+#
+#
+#cdef void print_heap(FibonacciHeap* heap):
+#    print "---------------------------------"
+#    print "min node: (%i, %i)" % (heap.min_node.index, heap.min_node.val)
+#    if heap.min_node:
+#        print_node(leftmost_sibling(heap.min_node))
+#    else:
+#        print "[empty heap]"

data/MARBLE/main.py

@@ -0,0 +1,469 @@
+"""Main network"""
+
+import glob
+import os
+import warnings
+from datetime import datetime
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+import torch.optim as opt
+import yaml
+from torch import nn
+from torch_geometric.nn import MLP
+from tqdm import tqdm
+
+from MARBLE import dataloader
+from MARBLE import geometry
+from MARBLE import layers
+from MARBLE import utils
+
+
+class net(nn.Module):
+    """MARBLE neural network.
+
+    The possible parameters and their default values are described below,
+    and can be accessed via the `params` dictionnary in this class constructor.
+
+    Args:
+        batch_size: batch size (default=64)
+        epochs: optimisation epochs (default=20)
+        lr: iniital learning rate (default=0.01)
+        momentum: momentum (default=0.9)
+        diffusion: set to True to use diffusion layer before gradient computation (default=False)
+        include_positions: include positions as features (warning: this is untested) (default=False)
+        include_self: include vector at the center of feature (default=True)
+        order: order to which to compute the directional derivatives (default=2)
+        inner_product_features: transform gradient features to inner product features (default=True)
+        frac_sampled_nb: fraction of neighbours to sample for gradient computation
+            (if -1 then all neighbours) (default=-1)
+        dropout: dropout in the MLP (default=0.)
+        hidden_channels: number of hidden channels (default=16). If list, then adds multiple layers.
+        out_channels: number of output channels (if null, then =hidden_channels) (default=3)
+        bias: learn bias parameters in MLP (default=True)
+        vec_norm: normalise features at each derivative order to unit length (default=False)
+        emb_norm: normalise MLP output to unit length (default=False)
+        batch_norm: batch normalisation (default=True)
+        seed: seed for reproducibility
+    """
+
+    def __init__(self, data, loadpath=None, params=None, verbose=True):
+        """
+        Constructor of the MARBLE net.
+
+        Args:
+            data: PyG data
+            loadpath: path to a model file, or a directory with models (best model will be used)
+            params: dict with parameters to overwrite default params or a path to a yaml file
+            verbose: run in verbose mode
+        """
+        super().__init__()
+
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        if loadpath is not None:
+            if Path(loadpath).is_dir():
+                loadpath = max(glob.glob(f"{loadpath}/best_model*"))
+            self.params = torch.load(loadpath, map_location=device)["params"]
+        else:
+            if params is not None:
+                self.params = params
+            else:
+                self.params = {}
+
+        self._epoch = 0  # to resume optimisation
+        self.parse_parameters(data)
+        self.check_parameters(data)
+        self.setup_layers()
+        self.loss = loss_fun()
+        self.reset_parameters()
+        self.timestamp = None
+
+        if verbose:
+            utils.print_settings(self)
+
+        if loadpath is not None:
+            self.load_model(loadpath)
+
+    def parse_parameters(self, data):
+        """Load default parameters and merge with user specified parameters"""
+
+        file = os.path.dirname(__file__) + "/default_params.yaml"
+        with open(file, "rb") as f:
+            params = yaml.safe_load(f)
+
+        params["dim_signal"] = data.x.shape[1]
+        params["dim_emb"] = data.pos.shape[1]
+
+        if hasattr(data, "dim_man"):
+            params["dim_man"] = data.dim_man
+
+        # merge dictionaries without duplications
+        for key in params.keys():
+            if key not in self.params.keys():
+                self.params[key] = params[key]
+
+        if params["frac_sampled_nb"] != -1:
+            self.params["n_sampled_nb"] = int(data.degree * params["frac_sampled_nb"])
+        else:
+            self.params["n_sampled_nb"] = -1
+
+        if self.params["batch_norm"]:
+            self.params["batch_norm"] = "batch_norm"
+        else:
+            self.params["batch_norm"] = None
+
+    def check_parameters(self, data):
+        """Check parameter validity"""
+
+        assert self.params["order"] > 0, "Derivative order must be at least 1!"
+
+        if self.params["vec_norm"]:
+            assert data.x.shape[1] > 1, "Using vec_norm=True is not permitted for scalar signals"
+
+        if self.params["diffusion"]:
+            assert hasattr(data, "L"), "No Laplacian found. Compute it in preprocessing()!"
+
+        pars = [
+            "batch_size",
+            "epochs",
+            "lr",
+            "momentum",
+            "order",
+            "inner_product_features",
+            "dim_signal",
+            "dim_emb",
+            "frac_sampled_nb",
+            "dropout",
+            "diffusion",
+            "hidden_channels",
+            "out_channels",
+            "bias",
+            "batch_norm",
+            "vec_norm",
+            "emb_norm",
+            "seed",
+            "include_positions",
+            "include_self",
+        ]
+
+        for p in pars:
+            assert p in list(self.params.keys()), f"Parameter {p} is not specified!"
+
+    def reset_parameters(self):
+        """reset parmaeters."""
+        for layer in self.children():
+            if hasattr(layer, "reset_parameters"):
+                layer.reset_parameters()
+
+    def setup_layers(self):
+        """Setup layers."""
+
+        s, d, o = self.params["dim_signal"], self.params["dim_emb"], self.params["order"]
+        if "dim_man" in self.params.keys():
+            s = d = self.params["dim_man"]
+
+        # diffusion
+        self.diffusion = layers.Diffusion()
+
+        # gradient features
+        self.grad = nn.ModuleList(layers.AnisoConv() for i in range(o))
+
+        # cumulated number of channels after gradient features
+        cum_channels = s * (1 - d ** (o + 1)) // (1 - d)
+        if not self.params["include_self"]:
+            cum_channels -= s
+
+        if self.params["inner_product_features"]:
+            cum_channels //= s
+            if s == 1:
+                cum_channels = o + 1
+
+            self.inner_products = layers.InnerProductFeatures(cum_channels, s)
+        else:
+            self.inner_products = None
+
+        if self.params["include_positions"]:
+            cum_channels += d
+
+        # encoder
+        if not isinstance(self.params["hidden_channels"], list):
+            self.params["hidden_channels"] = [self.params["hidden_channels"]]
+
+        channel_list = (
+            [cum_channels] + self.params["hidden_channels"] + [self.params["out_channels"]]
+        )
+
+        self.enc = MLP(
+            channel_list=channel_list,
+            dropout=self.params["dropout"],
+            bias=self.params["bias"],
+            norm=self.params["batch_norm"],
+        )
+
+    def forward(self, data, n_id, adjs=None):
+        """Forward pass.
+        Messages are passed to a set target nodes (current batch) from source
+        nodes. The source nodes and target nodes form a bipartite graph to
+        simplify message passing. By convention, the first size[1] entries of x
+        are the target nodes, i.e, x = concat[x_target, x_other]."""
+
+        x = data.x
+        n, d = x.shape[0], data.gauges.shape[2]
+        mask = data.mask
+
+        # diffusion
+        if self.params["diffusion"]:
+            if hasattr(data, "Lc"):
+                x = geometry.global_to_local_frame(x, data.gauges)
+                x = self.diffusion(x, data.L, Lc=data.Lc, method="spectral")
+                x = geometry.global_to_local_frame(x, data.gauges, reverse=True)
+            else:
+                x = self.diffusion(x, data.L, method="spectral")
+
+        # local gauges
+        if self.params["inner_product_features"]:
+            x = geometry.global_to_local_frame(x, data.gauges)
+
+        # restrict to current batch
+        x = x[n_id]
+        mask = mask[n_id]
+        if data.kernels[0].size(0) == n * d:
+            n_id = utils.expand_index(n_id, d)
+        else:
+            d = 1
+
+        if self.params["vec_norm"]:
+            x = F.normalize(x, dim=-1, p=2)
+
+        # gradients
+        if self.params["include_self"]:
+            out = [x]
+        else:
+            out = []
+        for i, (_, _, size) in enumerate(adjs):
+            kernels = [K[n_id[: size[1] * d], :][:, n_id[: size[0] * d]] for K in data.kernels]
+
+            x = self.grad[i](x, kernels)
+
+            if self.params["vec_norm"]:
+                x = F.normalize(x, dim=-1, p=2)
+
+            out.append(x)
+
+        last_size = adjs[-1][2]
+        # take target nodes
+        out = [o[: last_size[1]] for o in out]
+
+        # inner products
+        if self.params["inner_product_features"]:
+            out = self.inner_products(out)
+        else:
+            out = torch.cat(out, axis=1)
+
+        if self.params["include_positions"]:
+            out = torch.hstack([data.pos[n_id[: last_size[1]]], out])
+
+        emb = self.enc(out)
+
+        if self.params["emb_norm"]:  # spherical output
+            emb = F.normalize(emb)
+
+        return emb, mask[: last_size[1]]
+
+    def evaluate(self, data):
+        """Evaluate."""
+        warnings.warn("MARBLE.evaluate() is deprecated. Use MARBLE.transform() instead.")
+        return self.transform(data)
+
+    def transform(self, data):
+        """Forward pass @ evaluation (no minibatches)"""
+        with torch.no_grad():
+            size = (data.x.shape[0], data.x.shape[0])
+            adjs = utils.EdgeIndex(data.edge_index, torch.arange(data.edge_index.shape[1]), size)
+            adjs = utils.to_list(adjs) * self.params["order"]
+
+            try:
+                data.kernels = [
+                    utils.to_SparseTensor(K.coalesce().indices(), value=K.coalesce().values()).t()
+                    for K in utils.to_list(data.kernels)
+                ]
+            except Exception:  # pylint: disable=broad-exception-caught
+                pass
+
+            _, data, adjs = utils.move_to_gpu(self, data, adjs)
+            out, _ = self.forward(data, torch.arange(len(data.x)), adjs)
+            utils.detach_from_gpu(self, data, adjs)
+
+            data.emb = out.detach().cpu()
+
+            return data
+
+    def batch_loss(self, data, loader, train=False, verbose=False, optimizer=None):
+        """Loop over minibatches provided by loader function.
+
+        Args:
+            x : (nxdim) feature matrix
+            loader : dataloader object from dataloader.py
+
+        """
+
+        if train:  # training mode (enables dropout in MLP)
+            self.train()
+
+        if verbose:
+            print("\n")
+
+        cum_loss = 0
+        for batch in tqdm(loader, disable=not verbose):
+            _, n_id, adjs = batch
+            adjs = [adj.to(data.x.device) for adj in utils.to_list(adjs)]
+            emb, mask = self.forward(data, n_id, adjs)
+            loss = self.loss(emb, mask)
+            cum_loss += float(loss)
+
+            if optimizer is not None:
+                optimizer.zero_grad()  # zero gradients, otherwise accumulates
+                loss.backward()  # backprop
+                optimizer.step()
+
+        self.eval()
+
+        return cum_loss / len(loader), optimizer
+
+    def run_training(self, data, outdir=None, verbose=False):
+        """Run training."""
+        warnings.warn("MARBLE.run_training() is deprecated. Use MARBLE.fit() instead.")
+
+        self.fit(data, outdir=outdir, verbose=verbose)
+
+    def fit(self, data, outdir=None, verbose=False):
+        """Network training.
+
+        Args:
+            data: PyG data
+            outdir: folder to save intermediate models
+            verbose: run in verbose mode
+        """
+
+        print("\n---- Training network ...")
+
+        self.timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+
+        print(f"\n---- Timestamp: {self.timestamp}")
+
+        # load to gpu (if possible)
+        # pylint: disable=self-cls-assignment
+        self, data, _ = utils.move_to_gpu(self, data)
+
+        # data loader
+        train_loader, val_loader, test_loader = dataloader.loaders(data, self.params)
+        optimizer = opt.SGD(
+            self.parameters(), lr=self.params["lr"], momentum=self.params["momentum"]
+        )
+        if hasattr(self, "optimizer_state_dict"):
+            optimizer.load_state_dict(self.optimizer_state_dict)
+
+        # training scheduler
+        scheduler = opt.lr_scheduler.ReduceLROnPlateau(optimizer)
+
+        best_loss = -1
+        self.losses = {"train_loss": [], "val_loss": [], "test_loss": []}
+        for epoch in range(
+            self.params.get("epoch", 0), self.params.get("epoch", 0) + self.params["epochs"]
+        ):
+            self._epoch = epoch
+
+            train_loss, optimizer = self.batch_loss(
+                data, train_loader, train=True, verbose=verbose, optimizer=optimizer
+            )
+            val_loss, _ = self.batch_loss(data, val_loader, verbose=verbose)
+            scheduler.step(train_loss)
+
+            print(
+                f"\nEpoch: {self._epoch}, Training loss: {train_loss:4f}, Validation loss: {val_loss:.4f}, lr: {scheduler._last_lr[0]:.4f}",  # noqa, pylint: disable=line-too-long,protected-access
+                end="",
+            )
+
+            if best_loss == -1 or (val_loss < best_loss):
+                outdir = self.save_model(
+                    optimizer, self.losses, outdir=outdir, best=True, timestamp=self.timestamp
+                )
+                best_loss = val_loss
+                print(" *", end="")
+
+            self.losses["train_loss"].append(train_loss)
+            self.losses["val_loss"].append(val_loss)
+
+        test_loss, _ = self.batch_loss(data, test_loader)
+        print(f"\nFinal test loss: {test_loss:.4f}")
+
+        self.losses["test_loss"].append(test_loss)
+
+        self.save_model(optimizer, self.losses, outdir=outdir, best=False, timestamp=self.timestamp)
+        self.load_model(os.path.join(outdir, f"best_model_{self.timestamp}.pth"))
+
+    def load_model(self, loadpath):
+        """Load model.
+
+        Args:
+            loadpath: directory with models to load best model, or specific model path
+        """
+        checkpoint = torch.load(
+            loadpath, map_location=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        )
+        self._epoch = checkpoint["epoch"]
+        self.load_state_dict(checkpoint["model_state_dict"])
+        self.optimizer_state_dict = checkpoint["optimizer_state_dict"]
+        if hasattr(self, "losses"):
+            self.losses = checkpoint["losses"]
+
+    def save_model(self, optimizer, losses, outdir=None, best=False, timestamp=""):
+        """Save model."""
+        if outdir is None:
+            outdir = "./outputs/"
+
+        if not os.path.exists(outdir):
+            os.makedirs(outdir)
+
+        checkpoint = {
+            "epoch": self._epoch,
+            "model_state_dict": self.state_dict(),
+            "optimizer_state_dict": optimizer.state_dict(),
+            "time": timestamp,
+            "params": self.params,
+            "losses": losses,
+        }
+
+        if best:
+            fname = "best_model_"
+        else:
+            fname = "last_model_"
+
+        fname += timestamp
+        fname += ".pth"
+
+        if best:
+            torch.save(checkpoint, os.path.join(outdir, fname))
+        else:
+            torch.save(checkpoint, os.path.join(outdir, fname))
+
+        return outdir
+
+
+class loss_fun(nn.Module):
+    """Loss function."""
+
+    def forward(self, out, mask=None):
+        """forward."""
+        z, z_pos, z_neg = out.split(out.size(0) // 3, dim=0)
+        pos_loss = F.logsigmoid((z * z_pos).sum(-1)).mean()  # pylint: disable=not-callable
+        neg_loss = F.logsigmoid(-(z * z_neg).sum(-1)).mean()  # pylint: disable=not-callable
+
+        coagulation_loss = 0.0
+        if mask is not None:
+            z_mask = out[mask]
+            coagulation_loss = (z_mask - z_mask.mean(dim=0)).norm(dim=1).sum()
+
+        return -pos_loss - neg_loss + torch.sigmoid(coagulation_loss) - 0.5

data/MARBLE/plotting.py

@@ -0,0 +1,751 @@
+"""Plotting module."""
+
+import matplotlib
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import seaborn as sns
+import torch
+from matplotlib import gridspec
+from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.patches import FancyArrowPatch
+from mpl_toolkits.mplot3d import proj3d
+from scipy.spatial import Voronoi
+from scipy.spatial import voronoi_plot_2d
+from torch_geometric.utils.convert import to_networkx
+
+from .geometry import embed
+
+
+def fields(
+    data,
+    titles=None,
+    col=1,
+    figsize=(8, 8),
+    axlim=None,
+    axes_visible=False,
+    color=None,
+    alpha=0.5,
+    node_size=10,
+    plot_gauges=False,
+    width=0.005,
+    edge_width=1.0,
+    scale=5,
+    view=None,
+):
+    """Plot scalar or vector fields
+
+    Args:
+        data: PyG Batch data object class created with utils.construct_dataset
+        titles: list of titles
+        col: int for number of columns to plot
+        figsize: tuple of figure dimensions
+    """
+    if hasattr(data, "gauges"):
+        gauges = data.gauges
+    else:
+        gauges = None
+
+    if not isinstance(data, list):
+        number_of_resamples = data.number_of_resamples
+        data = data.to_data_list()  # split data batch
+
+        if number_of_resamples > 1:
+            print("\nDetected several samples. Taking only first one for visualisation!")
+            data = data[::number_of_resamples]
+
+    dim = data[0].pos.shape[1]
+    vector = data[0].x.shape[1] > 1
+    row = int(np.ceil(len(data) / col))
+
+    fig = plt.figure(figsize=figsize, constrained_layout=True)
+    grid = gridspec.GridSpec(row, col, wspace=0.0, hspace=0.0, figure=fig)
+
+    ax_list, lims = [], None
+    for i, d in enumerate(data):
+        signal = d.x.detach().numpy()
+        _, ax = create_axis(dim, grid[i], fig=fig)
+
+        if view is not None:
+            ax.view_init(elev=view[0], azim=view[1])
+
+        G = to_networkx(
+            d, node_attrs=["pos"], edge_attrs=None, to_undirected=True, remove_self_loops=True
+        )
+
+        if color is None:
+            c = np.linalg.norm(signal, axis=1) if vector else signal
+            c, _ = set_colors(c.squeeze())
+        else:
+            c = color
+
+        graph(
+            G,
+            labels=None if vector else c,
+            ax=ax,
+            node_size=node_size,
+            edge_width=edge_width,
+            edge_alpha=alpha,
+            axes_visible=axes_visible,
+        )
+
+        if vector:
+            pos = d.pos.numpy()
+            plot_arrows(pos, signal, ax, c, scale=scale, width=width)
+
+        if plot_gauges and (gauges is not None):
+            for j in range(gauges.shape[2]):
+                plot_arrows(pos, gauges[..., j], ax, "k", scale=scale)
+
+        if titles is not None:
+            ax.set_title(titles[i])
+
+        fig.add_subplot(ax)
+
+        if axlim is not None:
+            if axlim == "same" and (lims is None):
+                lims = get_limits(ax)
+            elif len(axlim) == len(data):
+                lims = axlim[i]
+            else:
+                raise NotImplementedError
+
+        set_axes(ax, lims=lims, axes_visible=axes_visible)
+
+        ax_list.append(ax)
+
+    return ax_list
+
+
+def histograms(data, titles=None, col=2, figsize=(10, 10)):
+    """Plot histograms of cluster distribution across datasets.
+
+    Args:
+        data: PyG Batch data object class created with utils.construct_dataset
+        clusters: sklearn cluster object
+        titles: list of titles
+        col: int for number of columns to plot
+        figsize: tuple of figure dimensions
+    """
+    assert hasattr(data, "clusters"), "No clusters found. First, run postprocessing.cluster(data)!"
+
+    labels, s = data.clusters["labels"], data.clusters["slices"]
+    n_slices = len(s) - 1
+    labels = [labels[s[i] : s[i + 1]] + 1 for i in range(n_slices)]
+    nc = data.clusters["n_clusters"]
+
+    row = int(np.ceil(n_slices / col))
+
+    fig = plt.figure(figsize=figsize, constrained_layout=True)
+    grid = gridspec.GridSpec(row, col, wspace=0.5, hspace=0.5, figure=fig)
+
+    for i in range(n_slices):
+        ax = plt.Subplot(fig, grid[i])
+
+        ax.hist(labels[i], bins=np.arange(nc + 1) + 0.5, rwidth=0.85, density=True)
+        ax.set_xticks(np.arange(nc) + 1)  # pylint: disable=not-callable
+        ax.set_xlim([0, nc + 1])
+        ax.set_xlabel("Feature number")
+        ax.set_ylabel("Probability density")
+
+        if titles is not None:
+            ax.set_title(titles[i])
+
+        fig.add_subplot(ax)
+
+
+def embedding(
+    data,
+    labels=None,
+    titles=None,
+    mask=None,
+    ax=None,
+    alpha=0.3,
+    s=5,
+    axes_visible=False,
+    cbar_visible=True,
+    clusters_visible=False,
+    cmap="coolwarm",
+    plot_trajectories=False,
+    style="o",
+    lw=1,
+    time_gradient=False,
+):
+    """Plot embeddings.
+
+    Args:
+        data: PyG data object with attribute emb or nxdim matrix of embedded points with dim=2 or 3
+        labels: list of increasing integer node labels
+        clusters: sklearn cluster object
+        titles: list of titles
+    """
+    if hasattr(data, "emb_2D"):
+        emb = data.emb_2D
+    elif isinstance(data, np.ndarray) or torch.is_tensor(data):
+        emb = data
+    else:
+        raise TypeError
+
+    dim = emb.shape[1]
+    assert dim in [2, 3], f"Embedding dimension is {dim} which cannot be displayed."
+
+    if ax is None:
+        _, ax = create_axis(dim)
+
+    if labels is not None:
+        assert emb.shape[0] == len(labels)
+
+    if labels is None:
+        labels = np.ones(emb.shape[0])
+
+    if mask is None:
+        mask = np.ones(len(emb), dtype=bool)
+        labels = labels[mask]
+
+    types = sorted(set(labels))
+
+    color, cbar = set_colors(types, cmap)
+
+    if titles is not None:
+        assert len(titles) == len(types)
+
+    for i, typ in enumerate(types):
+        title = titles[i] if titles is not None else str(typ)
+        c_ = color[i]
+        emb_ = emb[mask * (labels == typ)]
+
+        if isinstance(data, np.ndarray) or torch.is_tensor(data):
+            print("You need to pass a data object to plot trajectories!")
+            plot_trajectories = False
+
+        if plot_trajectories:
+            l_ = data.label[mask * (labels == typ)]
+            if len(l_) == 0:
+                continue
+            end = np.where(np.diff(l_) < 0)[0] + 1
+            start = np.hstack([0, end])
+            end = np.hstack([end, len(emb_)])
+            cmap = LinearSegmentedColormap.from_list("Custom", [(0, 0, 0), c_], N=max(l_))
+
+            for i, (s_, e_) in enumerate(zip(start, end)):
+                t = range(s_, e_)
+                cgrad = cmap(l_[t] / max(l_))
+                if style == "-":
+                    if time_gradient:
+                        trajectories(
+                            emb_[t], style="-", ax=ax, ms=s, node_feature=cgrad, alpha=alpha, lw=lw
+                        )
+                    else:
+                        trajectories(
+                            emb_[t],
+                            style="-",
+                            ax=ax,
+                            ms=s,
+                            node_feature=[c_] * len(t),
+                            alpha=alpha,
+                            lw=lw,
+                        )
+                elif style == "o":
+                    if dim == 2:
+                        ax.scatter(emb_[t, 0], emb_[t, 1], c=cgrad, alpha=alpha, s=s, label=title)
+                    elif dim == 3:
+                        ax.scatter(
+                            emb_[t, 0],
+                            emb_[t, 1],
+                            emb_[t, 2],
+                            c=cgrad,
+                            alpha=alpha,
+                            s=s,
+                            label=title,
+                        )
+        else:
+            if dim == 2:
+                ax.scatter(emb_[:, 0], emb_[:, 1], color=c_, alpha=alpha, s=s, label=title)
+            elif dim == 3:
+                ax.scatter(
+                    emb_[:, 0], emb_[:, 1], emb_[:, 2], color=c_, alpha=alpha, s=s, label=title
+                )
+
+    if dim == 2:
+        if hasattr(data, "clusters") and clusters_visible:
+            voronoi(data.clusters, ax)
+
+    if titles is not None:
+        ax.legend(loc="upper right")
+
+    if not axes_visible:
+        ax.set_axis_off()
+
+    if cbar_visible and cbar is not None:
+        plt.colorbar(cbar, ax=ax)
+
+    return ax
+
+
+def losses(model):
+    """Model losses"""
+
+    plt.plot(model.losses["train_loss"], label="Training loss")
+    plt.plot(model.losses["val_loss"], label="Validation loss")
+    plt.xlabel("Epochs")
+    plt.ylabel("MSE loss")
+    plt.legend()
+
+
+def voronoi(clusters, ax):
+    """Voronoi tesselation of clusters"""
+    vor = Voronoi(clusters["centroids"])
+    voronoi_plot_2d(vor, ax=ax, show_vertices=False)
+    for k in range(clusters["n_clusters"]):
+        ax.annotate(k + 1, clusters["centroids"][k, :])
+
+
+def neighbourhoods(
+    data,
+    hops=1,
+    cols=4,
+    norm=False,
+    color=None,
+    plot_graph=False,
+    figsize=(15, 20),
+    fontsize=20,
+    width=0.025,
+    scale=1,
+):
+    """For each clustered neighbourhood type, draw one sample neighbourhood from each dataset.
+
+    Args:
+        data: postprocessed PyG Batch data object class created with utils.construct_dataset
+        hops: size of neighbourhood in number of hops
+        norm: if True, then normalise values to zero mean within clusters
+        plot_graph: if True, then plot the underlying graph.
+    """
+
+    assert hasattr(data, "clusters"), "No clusters found. First, run postprocessing.cluster(data)!"
+
+    vector = data.x.shape[1] > 1
+    clusters = data.clusters
+    nc = clusters["n_clusters"]
+    fig = plt.figure(figsize=figsize, constrained_layout=True)
+    outer = gridspec.GridSpec(int(np.ceil(nc / cols)), cols, wspace=0.2, hspace=0.2, figure=fig)
+
+    number_of_resamples = data.number_of_resamples
+    data = data.to_data_list()  # split data batch
+
+    if number_of_resamples > 1:
+        print(
+            "\nDetected several samples of the same data. Taking only first one for visualisation!"
+        )
+        data = data[::number_of_resamples]
+
+    graphs = []
+    for d in data:
+        graphs.append(
+            to_networkx(
+                d, node_attrs=["pos"], edge_attrs=None, to_undirected=True, remove_self_loops=True
+            )
+        )
+
+    signals = [d.x for d in data]
+
+    for i in range(nc):
+        col = 2
+        row = int(np.ceil(len(data) / col))
+        inner = gridspec.GridSpecFromSubplotSpec(
+            row, col, subplot_spec=outer[i], wspace=0.0, hspace=0.0
+        )
+
+        ax = plt.Subplot(fig, outer[i])
+        ax.set_title(f"Type {i+1}", fontsize=fontsize)
+        ax.axis("off")
+        fig.add_subplot(ax)
+
+        n_nodes = [0] + [nx.number_of_nodes(g) for g in graphs]
+        n_nodes = np.cumsum(n_nodes)
+
+        for j, G in enumerate(graphs):
+            label_i = clusters["labels"][n_nodes[j] : n_nodes[j + 1]] == i
+            label_i = np.where(label_i)[0]
+            if not list(label_i):
+                continue
+            random_node = np.random.choice(label_i)
+
+            signal = signals[j].numpy()
+            node_ids = nx.ego_graph(G, random_node, radius=hops).nodes
+            node_ids = np.sort(node_ids)  # sort nodes
+
+            # convert node values to colors
+            if color is not None:
+                c = color
+            else:
+                c = signal
+                if vector:
+                    c = np.linalg.norm(signal, axis=1)
+
+            if not norm:  # set colors based on global values
+                c, _ = set_colors(c)
+                c = [c[i] for i in node_ids] if isinstance(c, (list, np.ndarray)) else c
+                signal = signal[node_ids]
+            else:  # first extract subgraph, then compute normalized colors
+                signal = signal[node_ids]
+                signal -= signal.mean()
+                c, _ = set_colors(signal.squeeze())
+
+            ax = plt.Subplot(fig, inner[j])
+
+            # extract subgraph with nodes sorted
+            subgraph = nx.Graph()
+            subgraph.add_nodes_from(sorted(G.subgraph(node_ids).nodes(data=True)))
+            subgraph.add_edges_from(G.subgraph(node_ids).edges(data=True))
+
+            ax.set_aspect("equal", "box")
+            if plot_graph:
+                graph(subgraph, labels=None, ax=ax, node_size=30, edge_width=0.5)
+
+            pos = np.array(list(nx.get_node_attributes(subgraph, name="pos").values()))
+
+            if pos.shape[1] > 2:
+                pos, manifold = embed(pos, embed_typ="PCA")
+                signal = embed(signal, embed_typ="PCA", manifold=manifold)[0]
+            if vector:
+                plot_arrows(pos, signal, ax, c, width=width, scale=scale)
+            else:
+                ax.scatter(pos[:, 0], pos[:, 1], c=c)
+
+            ax.set_frame_on(False)
+            set_axes(ax, axes_visible=False)
+            fig.add_subplot(ax)
+
+
+def graph(
+    G,
+    labels="b",
+    edge_width=1,
+    edge_alpha=1.0,
+    node_size=20,
+    layout=None,
+    ax=None,
+    axes_visible=True,
+):
+    """Plot scalar values on graph nodes embedded in 2D or 3D."""
+
+    G = nx.convert_node_labels_to_integers(G)
+    pos = list(nx.get_node_attributes(G, "pos").values())
+
+    if not pos:
+        if layout == "spectral":
+            pos = nx.spectral_layout(G)
+        else:
+            pos = nx.spring_layout(G)
+
+    dim = len(pos[0])
+    assert dim in (2, 3), "Dimension must be 2 or 3."
+
+    if ax is None:
+        _, ax = create_axis(dim)
+
+    if dim == 2:
+        if labels is not None:
+            nx.draw_networkx_nodes(
+                G, pos=pos, node_size=node_size, node_color=labels, alpha=0.8, ax=ax
+            )
+
+        nx.draw_networkx_edges(G, pos=pos, width=edge_width, alpha=edge_alpha, ax=ax)
+
+    elif dim == 3:
+        node_xyz = np.array([pos[v] for v in sorted(G)])
+        edge_xyz = np.array([(pos[u], pos[v]) for u, v in G.edges()])
+
+        if labels is not None:
+            ax.scatter(*node_xyz.T, s=node_size, c=labels, ec="w")
+
+        for vizedge in edge_xyz:
+            ax.plot(*vizedge.T, color="tab:gray", alpha=edge_alpha, linewidth=edge_width)
+
+    set_axes(ax, axes_visible=axes_visible)
+
+    return ax
+
+
+# def time_series(T, X, style="o", node_feature=None, figsize=(10, 5), lw=1, ms=5):
+#    """Plot time series.
+
+#    Args:
+#        X (np array or list[np array]): Trajectories
+#        style (string): Plotting style. The default is 'o'
+#        color (bool): Color lines. The default is True
+#        lw (int): Line width
+#        ms (int): Marker size.
+
+#    Returns:
+#        matplotlib axes object
+#    """
+#    if not isinstance(X, list):
+#        X = [X]
+
+#    fig = plt.figure(figsize=figsize, constrained_layout=True)
+#    grid = gridspec.GridSpec(len(X), 1, wspace=0.5, hspace=0, figure=fig)
+
+#    for sp, X_ in enumerate(X):
+#        if sp == 0:
+#            ax = plt.Subplot(fig, grid[sp])
+#        else:
+#            ax = plt.Subplot(fig, grid[sp], sharex=ax)
+
+#        ax.spines["top"].set_visible(False)
+#        ax.spines["right"].set_visible(False)
+
+#        if sp < len(X) - 1:
+#            plt.setp(ax.get_xticklabels(), visible=False)  # pylint: disable=not-callable
+#            ax.spines["bottom"].set_visible(False)
+#            ax.xaxis.set_ticks_position("none")
+
+#        colors = set_colors(node_feature)[0]
+
+#        for i in range(len(X_) - 2):
+#            if X_[i] is None:
+#                continue
+
+#            c = colors[i] if len(colors) > 1 and not isinstance(colors, str) else colors
+
+#            ax.plot(T[i : i + 2], X_[i : i + 2], style, c=c, linewidth=lw, markersize=ms)
+
+#            fig.add_subplot(ax)
+
+#    return ax
+
+
+def trajectories(
+    X,
+    V=None,
+    ax=None,
+    style="o",
+    node_feature=None,
+    lw=1,
+    ms=5,
+    scale=1,
+    arrow_spacing=1,
+    axes_visible=True,
+    alpha=1.0,
+):
+    """Plot trajectory in phase space. If multiple trajectories are given, they are plotted with
+    different colors.
+
+    Args:
+        X (np array): Positions
+        V (np array): Velocities
+        ax (matplotlib axes object): If specificed, it will plot on existing axes. Default is None
+        style (string): Plotting style. 'o' for scatter plot or '-' for line plot
+        node_feature: Color lines. The default is None
+        lw (int): Line width
+        ms (int): Marker size
+        scale (float): Scaling of arrows
+        arrow_spacing (int): How many timesteps apart are the arrows spaced.
+        axes_visible (bool): Whether to display axes
+        alpha (float): transparancy of the markers
+
+    Returns:
+        matplotlib axes object.
+    """
+    dim = X.shape[1]
+    assert dim in (2, 3), "Dimension must be 2 or 3."
+
+    if ax is None:
+        _, ax = create_axis(dim)
+
+    c = set_colors(node_feature)[0]
+
+    if dim == 2:
+        if "o" in style:
+            ax.scatter(X[:, 0], X[:, 1], c=c, s=ms, alpha=alpha)
+        if "-" in style:
+            if isinstance(c, (np.ndarray, list, tuple)):
+                for i in range(len(X) - 2):
+                    ax.plot(
+                        X[i : i + 2, 0],
+                        X[i : i + 2, 1],
+                        c=c[i],
+                        linewidth=lw,
+                        markersize=ms,
+                        alpha=alpha,
+                    )
+            else:
+                ax.plot(X[:, 0], X[:, 1], c=c, linewidth=lw, markersize=ms, alpha=alpha)
+        if ">" in style:
+            skip = (slice(None, None, arrow_spacing), slice(None))
+            X, V = X[skip], V[skip]
+            plot_arrows(X, V, ax, c, width=lw, scale=scale)
+
+    elif dim == 3:
+        if "o" in style:
+            ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=c, s=ms, alpha=alpha)
+        if "-" in style:
+            if isinstance(c, (np.ndarray, list, tuple)):
+                for i in range(len(X) - 2):
+                    ax.plot(
+                        X[i : i + 2, 0],
+                        X[i : i + 2, 1],
+                        X[i : i + 2, 2],
+                        c=c[i],
+                        linewidth=lw,
+                        markersize=ms,
+                        alpha=alpha,
+                        zorder=3,
+                    )
+            else:
+                ax.plot(
+                    X[:, 0],
+                    X[:, 1],
+                    X[:, 2],
+                    c=c,
+                    linewidth=lw,
+                    markersize=ms,
+                    alpha=alpha,
+                    zorder=3,
+                )
+        if ">" in style:
+            skip = (slice(None, None, arrow_spacing), slice(None))
+            X, V = X[skip], V[skip]
+            plot_arrows(X, V, ax, c, width=lw, scale=scale)
+    else:
+        raise Exception(f"Data dimension is: {dim}. It needs to be 2 or 3 to allow plotting.")
+
+    set_axes(ax, axes_visible=axes_visible)
+
+    return ax
+
+
+def plot_arrows(pos, signal, ax, c="k", alpha=1.0, width=1.0, scale=1.0):
+    """Plot arrows."""
+    dim = pos.shape[1]
+    if dim == 3:
+        norm = signal.max() - signal.min()
+        norm = norm if norm != 0 else 1
+        scaling = (pos.max() - pos.min()) / norm / scale
+        arrow_prop_dict = {
+            "alpha": alpha,
+            "mutation_scale": width,
+            "arrowstyle": "-|>",
+            "zorder": 3,
+        }
+        for j in range(len(pos)):
+            a = Arrow3D(
+                [pos[j, 0], pos[j, 0] + signal[j, 0] * scaling],
+                [pos[j, 1], pos[j, 1] + signal[j, 1] * scaling],
+                [pos[j, 2], pos[j, 2] + signal[j, 2] * scaling],
+                **arrow_prop_dict,
+                color=c[j] if len(c) > 1 else c,
+            )
+            ax.add_artist(a)
+
+    if dim == 2:
+        arrow_prop_dict = {"alpha": alpha, "zorder": 3, "scale_units": "inches"}
+        ax.quiver(
+            pos[:, 0],
+            pos[:, 1],
+            signal[:, 0],
+            signal[:, 1],
+            color=c if len(c) > 1 else c,
+            scale=scale,
+            width=width,
+            **arrow_prop_dict,
+        )
+
+
+class Arrow3D(FancyArrowPatch):
+    """Arrow 3D."""
+
+    def __init__(self, xs, ys, zs, *args, **kwargs):
+        FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
+        self._verts3d = xs, ys, zs
+
+    def draw(self, renderer):
+        """draw."""
+        xs3d, ys3d, zs3d = self._verts3d
+        xs, ys, _ = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+        self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+        FancyArrowPatch.draw(self, renderer)
+
+    def do_3d_projection(self):
+        """do 3d projection."""
+        xs3d, ys3d, zs3d = self._verts3d
+        xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+        self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+
+        return np.min(zs)
+
+
+def create_axis(*args, fig=None):
+    """Create axis."""
+    dim = args[0]
+    if len(args) > 1:
+        args = [args[i] for i in range(1, len(args))]
+    else:
+        args = (1, 1, 1)
+
+    if fig is None:
+        fig = plt.figure()
+
+    if dim == 2:
+        ax = fig.add_subplot(*args)
+    elif dim == 3:
+        ax = fig.add_subplot(*args, projection="3d")
+    else:
+        raise Exception(f"Data dimension is {dim}. We can only plot 2D or 3D data.")
+
+    return fig, ax
+
+
+def get_limits(ax):
+    """Get limits."""
+    lims = [ax.get_xlim(), ax.get_ylim()]
+    if ax.name == "3d":
+        lims.append(ax.get_zlim())
+
+    return lims
+
+
+def set_axes(ax, lims=None, padding=0.1, axes_visible=True):
+    """Set axes."""
+    if lims is not None:
+        xlim = lims[0]
+        ylim = lims[1]
+        pad = padding * (xlim[1] - xlim[0])
+
+        ax.set_xlim([xlim[0] - pad, xlim[1] + pad])
+        ax.set_ylim([ylim[0] - pad, ylim[1] + pad])
+        if ax.name == "3d":
+            zlim = lims[2]
+            ax.set_zlim([zlim[0] - pad, zlim[1] + pad])
+
+    if not axes_visible:
+        ax.set_yticklabels([])
+        ax.set_xticklabels([])
+        if ax.name == "3d":
+            ax.set_zticklabels([])
+        ax.axis("off")
+
+
+def set_colors(color, cmap="coolwarm"):
+    """Set colors."""
+    if color is None:
+        return "k", None
+
+    if isinstance(color[0], (float, np.floating)):
+        cmap = sns.color_palette(cmap, as_cmap=True)
+        norm = plt.cm.colors.Normalize(0, np.max(np.abs(color)))
+        colors = [cmap(norm(np.array(c).flatten())) for c in color]
+
+    elif isinstance(color[0], (int, np.integer)):
+        cmap = sns.color_palette()
+        colors = [f"C{i}" for i in color]
+        colors = [matplotlib.colors.to_rgba(c) for c in colors]
+        cmap, norm = matplotlib.colors.from_levels_and_colors(np.arange(1, len(color) + 2), colors)
+    elif isinstance(color[0], (np.ndarray, list, tuple)):
+        return color, None
+    else:
+        raise Exception("color must be a list of integers or floats")
+
+    cbar = plt.cm.ScalarMappable(norm=norm, cmap=cmap)
+
+    return colors, cbar

data/MARBLE/postprocessing.py

@@ -0,0 +1,83 @@
+"""Postprocessing module."""
+
+import numpy as np
+
+from MARBLE import geometry as g
+
+
+def cluster(data, cluster_typ="kmeans", n_clusters=15, seed=0):
+    """Cluster data."""
+    clusters = g.cluster(data.emb, cluster_typ, n_clusters, seed)
+    clusters = g.relabel_by_proximity(clusters)
+
+    clusters["slices"] = data._slice_dict["x"]  # pylint: disable=protected-access
+
+    if data.number_of_resamples > 1:
+        clusters["slices"] = clusters["slices"][:: data.number_of_resamples]
+
+    data.clusters = clusters
+
+    return data
+
+
+def distribution_distances(data, cluster_typ="kmeans", n_clusters=None, seed=0):
+    """Return distance between datasets.
+
+    Returns:
+        data: PyG data object containing .out attribute, a nx2 matrix of embedded data
+        clusters: sklearn cluster object
+        dist (cxc matrix): pairwise distances where c is the number of clusters
+
+    """
+
+    emb = data.emb
+
+    if n_clusters is not None:
+        # k-means cluster
+        data = cluster(data, cluster_typ, n_clusters, seed)
+
+        # compute distances between clusters
+        data.dist, data.gamma = g.compute_distribution_distances(
+            clusters=data.clusters, slices=data.clusters["slices"]
+        )
+
+    else:
+        data.emb = emb
+        data.dist, _ = g.compute_distribution_distances(
+            data=data, slices=data._slice_dict["x"]  # pylint: disable=protected-access
+        )
+
+    return data
+
+
+def embed_in_2D(data, embed_typ="umap", manifold=None, seed=0):
+    """Embed into 2D via for visualisation.
+
+    Args:
+        data: PyG input data
+        embed_typl (string, optional): Embedding algorithm to use (tsne, umap, PCA)
+        manifold (sklearn object, optional): Manifold object returned by some embedding algorithms
+            (PCA, umap). Useful when trying to compare datasets.
+        seed (int, optional): Random seed. The default is 0.
+
+    Returns:
+        PyG data object containing emb_2D attribute.
+    """
+    if isinstance(data, list):
+        emb = np.vstack([d.emb for d in data])
+    else:
+        emb = data.emb
+
+    if hasattr(data, "clusters"):
+        clusters = data.clusters
+        emb = np.vstack([emb, clusters["centroids"]])
+        emb_2D, data.manifold = g.embed(emb, embed_typ=embed_typ, manifold=manifold, seed=seed)
+        data.emb_2D, clusters["centroids"] = (
+            emb_2D[: -clusters["n_clusters"]],
+            emb_2D[-clusters["n_clusters"] :],
+        )
+
+    else:
+        data.emb_2D, data.manifold = g.embed(emb, embed_typ=embed_typ, manifold=manifold, seed=seed)
+
+    return data

data/MARBLE/preprocessing.py

@@ -0,0 +1,223 @@
+"""Preprocessing module."""
+
+import torch
+from torch_geometric.data import Batch
+from torch_geometric.data import Data
+from torch_geometric.transforms import RandomNodeSplit
+
+from MARBLE import geometry as g
+from MARBLE import utils
+
+
+def construct_dataset(
+    anchor,
+    vector,
+    label=None,
+    mask=None,
+    graph_type="cknn",
+    k=20,
+    delta=1.0,
+    frac_geodesic_nb=1.5,
+    spacing=0.0,
+    number_of_resamples=1,
+    var_explained=0.9,
+    local_gauges=False,
+    seed=None,
+    metric="euclidean",
+    number_of_eigenvectors=None,
+):
+    """Construct PyG dataset from node positions and features.
+
+    Args:
+        pos: matrix with position of points
+        features: matrix with feature values for each point
+        labels: any additional data labels used for plotting only
+        mask: boolean array, that will be forced to be close (default is None)
+        graph_type: type of nearest-neighbours graph: cknn (default), knn or radius
+        k: number of nearest-neighbours to construct the graph
+        delta: argument for cknn graph construction to decide the radius for each points.
+        frac_geodesic_nb: number of geodesic neighbours to fit the gauges to
+        to map to tangent space k*frac_geodesic_nb
+        stop_crit: stopping criterion for furthest point sampling
+        number_of_resamples: number of furthest point sampling runs to prevent bias (experimental)
+        var_explained: fraction of variance explained by the local gauges
+        local_gauges: is True, it will try to compute local gauges if it can (signal dim is > 2,
+            embedding dimension is > 2 or dim embedding is not dim of manifold)
+        seed: Specify for reproducibility in the furthest point sampling.
+              The default is None, which means a random starting vertex.
+        metric: metric used to fit proximity graph
+        number_of_eigenvectors: int number of eigenvectors to use. Default: None, meaning use all.
+    """
+
+    anchor = [torch.tensor(a).float() for a in utils.to_list(anchor)]
+    vector = [torch.tensor(v).float() for v in utils.to_list(vector)]
+    num_node_features = vector[0].shape[1]
+
+    if label is None:
+        label = [torch.arange(len(a)) for a in utils.to_list(anchor)]
+    else:
+        label = [torch.tensor(lab).float() for lab in utils.to_list(label)]
+
+    if mask is None:
+        mask = [torch.zeros(len(a), dtype=torch.bool) for a in utils.to_list(anchor)]
+    else:
+        mask = [torch.tensor(m) for m in utils.to_list(mask)]
+
+    if spacing == 0.0:
+        number_of_resamples = 1
+
+    data_list = []
+    for i, (a, v, l, m) in enumerate(zip(anchor, vector, label, mask)):
+        for _ in range(number_of_resamples):
+            if len(a) != 0:
+                # even sampling of points
+                if seed is None:
+                    start_idx = torch.randint(low=0, high=len(a), size=(1,))
+                else:
+                    start_idx = 0
+
+                sample_ind, _ = g.furthest_point_sampling(a, spacing=spacing, start_idx=start_idx)
+                sample_ind, _ = torch.sort(sample_ind)  # this will make postprocessing easier
+                a_, v_, l_, m_ = (
+                    a[sample_ind],
+                    v[sample_ind],
+                    l[sample_ind],
+                    m[sample_ind],
+                )
+
+                # fit graph to point cloud
+                edge_index, edge_weight = g.fit_graph(
+                    a_, graph_type=graph_type, par=k, delta=delta, metric=metric
+                )
+
+                # define data object
+                data_ = Data(
+                    pos=a_,
+                    x=v_,
+                    label=l_,
+                    mask=m_,
+                    edge_index=edge_index,
+                    edge_weight=edge_weight,
+                    num_nodes=len(a_),
+                    num_node_features=num_node_features,
+                    y=torch.ones(len(a_), dtype=int) * i,
+                    sample_ind=sample_ind,
+                )
+
+                data_list.append(data_)
+
+    # collate datasets
+    batch = Batch.from_data_list(data_list)
+    batch.degree = k
+    batch.number_of_resamples = number_of_resamples
+
+    # split into training/validation/test datasets
+    split = RandomNodeSplit(split="train_rest", num_val=0.1, num_test=0.1)
+    split(batch)
+
+    return _compute_geometric_objects(
+        batch,
+        local_gauges=local_gauges,
+        n_geodesic_nb=k * frac_geodesic_nb,
+        var_explained=var_explained,
+        number_of_eigenvectors=number_of_eigenvectors,
+    )
+
+
+def _compute_geometric_objects(
+    data,
+    n_geodesic_nb=10,
+    var_explained=0.9,
+    local_gauges=False,
+    number_of_eigenvectors=None,
+):
+    """
+    Compute geometric objects used later: local gauges, Levi-Civita connections
+    gradient kernels, scalar and connection laplacians.
+
+    Args:
+        data: pytorch geometric data object
+        n_geodesic_nb: number of geodesic neighbours to fit the tangent spaces to
+        var_explained: fraction of variance explained by the local gauges
+        local_gauges: whether to use local or global gauges
+        number_of_eigenvectors: int number of eigenvectors to use. Default: None, meaning use all.
+
+    Returns:
+        data: pytorch geometric data object with the following new attributes
+        kernels (list of d (nxn) matrices): directional kernels
+        L (nxn matrix): scalar laplacian
+        Lc (ndxnd matrix): connection laplacian
+        gauges (nxdxd): local gauges at all points
+        par (dict): updated dictionary of parameters
+        local_gauges: whether to use local gauges
+
+    """
+    n, dim_emb = data.pos.shape
+    dim_signal = data.x.shape[1]
+    print(f"\n---- Embedding dimension: {dim_emb}", end="")
+    print(f"\n---- Signal dimension: {dim_signal}", end="")
+
+    # disable vector computations if 1) signal is scalar or 2) embedding dimension
+    # is <= 2. In case 2), either M=R^2 (manifold is whole space) or case 1).
+    if dim_signal == 1:
+        print("\nSignal dimension is 1, so manifold computations are disabled!")
+        local_gauges = False
+    if dim_emb <= 2:
+        print("\nEmbedding dimension <= 2, so manifold computations are disabled!")
+        local_gauges = False
+    if dim_emb != dim_signal:
+        print("\nEmbedding dimension /= signal dimension, so manifold computations are disabled!")
+
+    if local_gauges:
+        try:
+            gauges, Sigma = g.compute_gauges(data, n_geodesic_nb=n_geodesic_nb)
+        except Exception as exc:
+            raise Exception(
+                "\nCould not compute gauges (possibly data is too sparse or the \
+                  number of neighbours is too small)"
+            ) from exc
+    else:
+        gauges = torch.eye(dim_emb).repeat(n, 1, 1)
+
+    L = g.compute_laplacian(data)
+
+    if local_gauges:
+        data.dim_man = g.manifold_dimension(Sigma, frac_explained=var_explained)
+        print(f"---- Manifold dimension: {data.dim_man}")
+
+        gauges = gauges[:, :, : data.dim_man]
+        R = g.compute_connections(data, gauges)
+
+        print("\n---- Computing kernels ... ", end="")
+        kernels = g.gradient_op(data.pos, data.edge_index, gauges)
+        kernels = [utils.tile_tensor(K, data.dim_man) for K in kernels]
+        kernels = [K * R for K in kernels]
+
+        Lc = g.compute_connection_laplacian(data, R)
+
+    else:
+        print("\n---- Computing kernels ... ", end="")
+        kernels = g.gradient_op(data.pos, data.edge_index, gauges)
+        Lc = None
+
+    if number_of_eigenvectors is None:
+        print(
+            """\n---- Computing full spectrum ...
+              (if this takes too long, then run construct_dataset()
+              with number_of_eigenvectors specified) """,
+            end="",
+        )
+    else:
+        print(
+            f"\n---- Computing spectrum with {number_of_eigenvectors} eigenvectors...",
+            end="",
+        )
+    L = g.compute_eigendecomposition(L, k=number_of_eigenvectors)
+    Lc = g.compute_eigendecomposition(Lc, k=number_of_eigenvectors)
+
+    data.kernels = [
+        utils.to_SparseTensor(K.coalesce().indices(), value=K.coalesce().values()) for K in kernels
+    ]
+    data.L, data.Lc, data.gauges, data.local_gauges = L, Lc, gauges, local_gauges
+
+    return data

data/MARBLE/smoothing.py

@@ -0,0 +1,63 @@
+"""Smoothing module."""
+
+import torch
+
+
+def scalar_diffusion(x, t, method="matrix_exp", par=None):
+    """Scalar diffusion."""
+    if len(x.shape) == 1:
+        x = x.unsqueeze(1)
+
+    if method == "matrix_exp":
+        if par.is_sparse:
+            par = par.to_dense()
+        return torch.matrix_exp(-t * par.to_dense()).mm(x)
+
+    if method == "spectral":
+        assert (
+            isinstance(par, (list, tuple)) and len(par) == 2
+        ), "For spectral method, par must be a tuple of \
+            eigenvalues, eigenvectors!"
+        evals, evecs = par
+
+        # Transform to spectral
+        x_spec = torch.mm(evecs.T, x)
+
+        # Diffuse
+        diffusion_coefs = torch.exp(-evals.unsqueeze(-1) * t.unsqueeze(0))
+        x_diffuse_spec = diffusion_coefs * x_spec
+
+        # Transform back to per-vertex
+        return evecs.mm(x_diffuse_spec)
+
+    raise NotImplementedError
+
+
+def vector_diffusion(x, t, Lc, L=None, method="spectral", normalise=True):
+    """Vector diffusion."""
+    n, d = x.shape[0], x.shape[1]
+
+    if method == "spectral":
+        assert len(Lc) == 2, "Lc must be a tuple of eigenvalues, eigenvectors!"
+        nd = Lc[1].shape[0]
+    else:
+        nd = Lc.shape[0]
+
+    assert (
+        n * d % nd
+    ) == 0, "Data dimension must be an integer multiple of the dimensions \
+         of the connection Laplacian!"
+
+    # vector diffusion with connection Laplacian
+    out = x.view(nd, -1)
+    out = scalar_diffusion(out, t, method, Lc)
+    out = out.view(x.shape)
+
+    if normalise:
+        assert L is not None, "Need Laplacian for normalised diffusion!"
+        x_abs = x.norm(dim=-1, p=2, keepdim=True)
+        out_abs = scalar_diffusion(x_abs, t, method, L)
+        ind = scalar_diffusion(torch.ones(x.shape[0], 1).to(x.device), t, method, L)
+        out = out * out_abs / (ind * out.norm(dim=-1, p=2, keepdim=True))
+
+    return out

data/MARBLE/utils.py

@@ -0,0 +1,277 @@
+"""Utils module."""
+
+import multiprocessing
+from functools import partial
+from typing import NamedTuple
+from typing import Optional
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+import torch
+from torch import Tensor
+from torch_sparse import SparseTensor
+from tqdm import tqdm
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+torch.manual_seed(0)
+
+
+def print_settings(model):
+    """Print parameters to screen"""
+
+    print("\n---- Settings: \n")
+
+    for x in model.params:
+        print(x, ":", model.params[x])
+
+    n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    n_features = model.enc.in_channels
+
+    print("\n---- Number of features to pass to the MLP: ", n_features)
+    print("---- Total number of parameters: ", n_parameters)
+    print(f"\nUsing device {device}")
+
+
+def parallel_proc(fun, iterable, inputs, processes=-1, desc=""):
+    """Distribute an iterable function between processes"""
+
+    if processes == -1:
+        processes = multiprocessing.cpu_count()
+
+    if processes > 1 and len(iterable) > 1:
+        with multiprocessing.Pool(processes=processes) as pool:
+            fun = partial(fun, inputs)
+            result = list(tqdm(pool.imap(fun, iterable), total=len(iterable), desc=desc))
+    else:
+        result = [fun(inputs, i) for i in tqdm(iterable, desc=desc)]
+
+    return result
+
+
+def move_to_gpu(model, data, adjs=None):
+    """Move stuff to gpu"""
+
+    assert hasattr(data, "kernels"), "It seems that data is not preprocessed. Run preprocess(data)!"
+
+    model = model.to(device)
+    data.x = data.x.to(device)
+    data.pos = data.pos.to(device)
+    data.mask = data.mask.to(device)
+
+    if hasattr(data, "L"):
+        if len(data.L) == 2:
+            data.L = [_l.to(device) for _l in data.L]
+        else:
+            data.L = data.L.to(device)
+    else:
+        data.L = None
+
+    if hasattr(data, "Lc"):
+        if len(data.Lc) == 2:
+            data.Lc = [_l.to(device) for _l in data.Lc]
+        else:
+            data.Lc = data.Lc.to(device)
+    else:
+        data.Lc = None
+
+    data.kernels = [K.to(device) for K in data.kernels]
+    data.gauges = data.gauges.to(device)
+
+    if adjs is None:
+        return model, data, None
+
+    adjs = [adj.to(device) for adj in adjs]
+    return model, data, adjs
+
+
+def detach_from_gpu(model, data, adjs=None):
+    """detach stuff from gpu"""
+
+    assert hasattr(data, "kernels"), "It seems that data is not preprocessed. Run preprocess(data)!"
+
+    model = model.to(device)
+    data.x = data.x.detach().cpu()
+    data.pos = data.pos.detach().cpu()
+    data.mask = data.mask.detach().cpu()
+
+    if hasattr(data, "L"):
+        data.L = [_l.detach().cpu() for _l in data.L]
+    else:
+        data.L = None
+
+    if hasattr(data, "Lc"):
+        data.Lc = [_l.detach().cpu() for _l in data.Lc]
+    else:
+        data.Lc = None
+
+    data.kernels = [K.detach().cpu() for K in data.kernels]
+    data.gauges = data.gauges.detach().cpu()
+
+    if adjs is None:
+        return model, data, None
+
+    for i, adj in enumerate(adjs):
+        adjs[i] = [adj[0].detach().cpu(), adj[1].detach().cpu(), adj[2]]
+    return model, data, adjs
+
+
+def to_SparseTensor(edge_index, size=None, value=None):
+    """
+    Adjacency matrix as torch_sparse tensor
+
+    Args:
+        edge_index (2xE matrix): edge indices
+        size: pair (rows,cols) giving the size of the matrix.
+            The default is the largest node of the edge_index.
+        value: list of weights. The default is unit values.
+
+    Returns:
+        adjacency matrix in SparseTensor format
+    """
+    if value is None:
+        value = torch.ones(edge_index.shape[1])
+    if size is None:
+        size = (int(edge_index[0].max()) + 1, int(edge_index[1].max()) + 1)
+
+    adj = SparseTensor(
+        row=edge_index[0], col=edge_index[1], value=value, sparse_sizes=(size[0], size[1])
+    )
+
+    return adj
+
+
+def np2torch(x, dtype=None):
+    """Convert numpy to torch"""
+    if dtype is None:
+        return torch.from_numpy(x).float()
+    if dtype == "double":
+        return torch.tensor(x, dtype=torch.int64)
+    raise NotImplementedError
+
+
+def to_list(x):
+    """Convert to list"""
+    if not isinstance(x, list):
+        x = [x]
+
+    return x
+
+
+def to_pandas(x, augment_time=True):
+    """Convert numpy to pandas"""
+    columns = [str(i) for i in range(x.shape[1])]
+
+    if augment_time:
+        xaug = np.hstack([np.arange(len(x))[:, None], x])
+        df = pd.DataFrame(xaug, columns=["Time"] + columns, index=np.arange(len(x)))
+    else:
+        df = pd.DataFrame(xaug, columns=columns, index=np.arange(len(x)))
+
+    return df
+
+
+class EdgeIndex(NamedTuple):
+    """Edge Index."""
+
+    edge_index: Tensor
+    e_id: Optional[Tensor]
+    size: Tuple[int, int]
+
+    def to(self, *args, **kwargs):
+        """to"""
+        edge_index = self.edge_index.to(*args, **kwargs)
+        e_id = self.e_id.to(*args, **kwargs) if self.e_id is not None else None
+        return EdgeIndex(edge_index, e_id, self.size)
+
+
+def expand_index(ind, dim):
+    """Interleave dim incremented copies of ind"""
+
+    n = len(ind)
+    ind = [ind * dim + i for i in range(dim)]
+    ind = torch.hstack(ind).view(dim, n).t().flatten()
+
+    return ind
+
+
+def to_block_diag(sp_tensors):
+    """To block diagonal."""
+    sizes = [torch.tensor(t.size()).unsqueeze(1) for t in sp_tensors]
+    ind = [t.indices() for t in sp_tensors]
+    val = [t.values() for t in sp_tensors]
+
+    for i in range(1, len(sp_tensors)):
+        for j in range(i):
+            ind[i] += sizes[j]
+
+    ind = torch.hstack(ind)
+    val = torch.hstack(val)
+
+    return torch.sparse_coo_tensor(ind, val)
+
+
+def expand_edge_index(edge_index, dim=1):
+    """When using rotations, we replace nodes by vector spaces so
+    need to expand adjacency matrix from nxn -> n*dimxn*dim matrices"""
+
+    if dim == 1:
+        return edge_index
+
+    dev = edge_index.device
+    if dev != "cpu":
+        edge_index = edge_index.to("cpu")
+
+    n = edge_index.shape[1]
+    ind = [torch.tensor([i, j]) for i in range(dim) for j in range(dim)]
+    edge_index = [edge_index * dim + i.unsqueeze(1) for i in ind]
+    edge_index = torch.stack(edge_index, dim=2).view(2, n * len(ind))
+
+    if dev != "cpu":
+        edge_index.to(dev)
+
+    return edge_index
+
+
+def tile_tensor(tensor, dim):
+    """Enlarge nxn tensor to d*dim x n*dim block matrix. Effectively
+    computing a sparse version of torch.kron(K, torch.ones((dim,dim)))"""
+
+    tensor = tensor.coalesce()
+    edge_index = tensor.indices()
+    edge_index = expand_edge_index(edge_index, dim=dim)
+    return torch.sparse_coo_tensor(edge_index, tensor.values().repeat_interleave(dim * dim))
+
+
+def restrict_dimension(sp_tensor, d, m):
+    """Limit the dimension of the tensor"""
+    n = sp_tensor.size(0)
+    idx = torch.ones(n)
+    for _ in range(m, d):
+        idx[m::d] = 0
+    idx = torch.where(idx)[0]
+    sp_tensor = torch.index_select(sp_tensor, 0, idx).coalesce()
+    return torch.index_select(sp_tensor, 1, idx).coalesce()
+
+
+def restrict_to_batch(sp_tensor, idx):
+    """Restrict tensor to current batch"""
+
+    idx = [i.to(sp_tensor.device) for i in idx]
+
+    if len(idx) == 1:
+        return torch.index_select(sp_tensor, 0, idx[0]).coalesce()
+    if len(idx) == 2:
+        sp_tensor = torch.index_select(sp_tensor, 0, idx[0])
+        return torch.index_select(sp_tensor, 1, idx[1]).coalesce()
+
+    raise NotImplementedError
+
+
+def standardize(X):
+    """Standarsise data row-wise"""
+
+    mean = X.mean(axis=0, keepdims=True)
+    std = X.std(axis=0, keepdims=True)
+
+    return (X - mean) / std

data/doc/Makefile

@@ -0,0 +1,26 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    = #-W  # treats warning as srrors
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = MARBLE
+SOURCEDIR     = source
+BUILDDIR      = ../../MARBLE-docs
+PDFBUILDER    = /tmp
+PDF 	      = ../manual.pdf
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+full: html 
+	cd $(BUILDDIR)/html; git add . ; git commit -m "rebuilt docs"; git push origin gh-pages
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

data/doc/index_readme.md

@@ -0,0 +1,272 @@
+# MARBLE - Manifold Representation Basis Learning
+
+MARBLE is a fully unsupervised geometric deep learning method that can 
+
+1. intrincally represent vector fields over manifolds, such as those arising in neural recordings or dissipative dynamical systems, but it is not limited to dynamical systems
+2. perform unbiased comparisons across dynamical systems or parameter conditions by jointly embedded representations
+3. can operate in geometry-aware or geometry-agnostic modes to test the contribution of manifold dynamics and geometry.
+
+The code is built around [PyG (PyTorch Geometric)](https://pytorch-geometric.readthedocs.io/en/latest/notes/installation.html).
+
+## Cite
+
+If you find this package useful or inspirational, please cite our work as follows
+
+```
+@misc{gosztolai2023interpretable,
+      title={Interpretable statistical representations of neural population dynamics and geometry}, 
+      author={Adam Gosztolai and Robert L. Peach and Alexis Arnaudon and Mauricio Barahona and Pierre Vandergheynst},
+      year={2023},
+      eprint={2304.03376},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+```
+
+
+## Installation
+
+The code is tested for both cpu and gpu (CUDA) machines running Linux or OSX. Although smaller examples run fast on cpu, for larger datasets, it is highly recommended that you use a gpu machine.
+
+We recommend you install the code in a fresh Anaconda virtual environment, as follows.
+
+First, clone this repository, 
+
+```
+git clone https://github.com/agosztolai/GeoDySys
+```
+
+Then, create an new anaconda environment using the provided environment file that matches your system.
+
+For Linux machines with CUDA: 
+
+```
+conda env create -f environment.yml
+```
+
+For Mac without CUDA:
+
+```
+conda env create -f environment_cpu_osx.yml
+```
+
+This will install all the requires dependencies. Finally, install by running inside the main folder
+
+```
+pip install . 
+```
+
+## Quick start
+
+We suggest you study at least the example of a [simple vector fields over flat surfaces](https://github.com/agosztolai/MARBLE/blob/main/examples/ex_vector_field_flat_surface.py) to understand what behaviour to expect.
+
+Briefly, MARBLE takes two inputs
+
+1. `pos` - a list of `nxd` arrays, each defining a point cloud describing the geometry of a manifold
+2. `x` - a list of `nxD` arrays, defining a signal over the respective manifolds in 1. For dynamical systems, D=d, but our code can also handle signals of other dimensions. Read more about  [inputs](#inputs) and [different conditions](#conditions).
+
+Using these inputs, you can construct a dataset for MARBLE.
+
+```
+import MARBLE 
+data = MARBLE.construct_dataset(pos, features=x)
+```
+
+The main attributes are `data.pos` - manifold positions concatenated, `data.x` - manifold signals concatenated and `data.y` - identifiers that tell you which manifold the poitn belongs to. Read more about [other usedul data attributed](#construct).
+
+Now you can initialise and train a MARBLE model. Read more about [training parameters](#training).
+
+```
+from MARBLE import net
+model = MARBLE.net(data)
+model.run_training(data)
+```
+
+By default, MARBLE operated in geometry-aware mode. You can enable the geometry-agnostic mode by changing the initalisation step to
+
+```
+model = MARBLE.net(data, params = {'inner_product_features': True})
+```
+
+Read more about the geometry-aware and geometry-agnostic modes [here](#innerproduct)
+
+After you have trained your model, you can evaluate evaluate your model on your dataset, or another dataset to obtain an embedding all manifold points in joint latent space (3-dimensional by default) based on their local vector field features.
+
+```
+data = model.evaluate(data) #adds an attribute `data.emb`
+```
+
+To recover the embeddings of individual vector fields, use `data.emb[data.y==0]`.
+
+You can then compare datasets by running
+
+```
+from MARBLE import postprocessing
+data = postprocessing.distribution_distances(data) #adds an attribute `data.dist` containing a matrix of pairwise distance between vector field representations
+```
+
+Finally, you can perform some visualisation
+
+```
+from MARBLE import plotting
+data = postprocessing.embed_in_2D(data) #adds an attribute `data.emb_2D` containing a 2D embedding of the MARBLE output using UMAP by default
+plotting.fields(data) #visualise the original vector fields over manifolds 
+plotting.embedding(data, data.y.numpy()) #visualise embedding
+```
+
+There are loads of parameters to adjust these plots, so have a look at the respective functions.
+
+## Examples
+
+The folder [/examples](https://github.com/agosztolai/MARBLE/tree/main/examples) contains scripts for some basic examples and other scripts to reproduce the results in our paper.
+
+## Further details
+
+.. _inputs:
+
+### More on inputs 
+
+If you measure time series observables, such as neural firing rates, you can start with a list of variable length time series under a given condition, e.g., `ts_1`, `ts_2`. We assume these are measurements from the same dynamical system, i.e., the sample points making up these trajectories are drawn from the same manifold, defining its shape `pos = np.vstack([ts_1, ts_2])`.
+
+If you do not directly have access to the velocities, you can approximate them as `x = np.vstack([np.diff(ts_1, axis=0), np.diff(ts_2, axis=0)])` and take `pos = np.vstack([ts_1[:-1,:], ts_2[:-1,:]])` to ensure `pos` and `x` have the same length. 
+
+If you just want to play around with dynamical systems, why not try our (experimental) [sister package] DE_library(https://github.com/agosztolai/DE_library).
+
+.. _conditions:
+
+### More on different conditions
+
+Comparing dynamics in a data-driven way is equivalent to comparing the corresponding vector fields based on their respective sample sets. The dynamics to be compared might correspond to different experimental conditions (stimulation conditions, genetic perturbations etc.), dynamical systems (different task, different brain region).
+
+Suppose we have the data pairs `pos1, pos2` and `x1, x2`. Then we may concatenate them as a list to ensure that our pipeline handles them independently (on different manifolds), but embeds them jointly in the same space.
+
+```
+pos_list, x_list = [pos1, pos2], [x1, x2]
+```
+
+Note, it is sometimes useful to consider that two vector fields lie on independent manifolds (providing them as a list) even when we want to *discover* the contrary. However, when we know that two vector fields lie on the same manifold, then it can be advantageous to stack their corresponding samples (stacking them) as this will enforce geometric relationships between them through the proximity graph.
+
+.. _construct:
+
+### More on constructing data object
+
+Our pipleline is build around a Pytorch Geometric data object, which we can obtain by running the following constructor.
+
+```
+import MARBLE 
+data = MARBLE.construct_dataset(pos, features=x, stop_crit=0.03, graph_type='cknn', k=15, local_gauge=False)
+```
+
+This command will do several things.
+
+1. Subsample the point cloud using farthest point sampling to achieve even sampling density. Using `stop_crit=0.03` means the average distance between the subsampled points will equal to 3% of the manifold diameter.
+2. Fit a nearest neighbour graph to each point cloud, here using the `graph_type=cknn` method using `k=15` nearest neighbours. We implemented other graph algorithms, but cknn typically works. Note, `k` should be large enough to approximate the tangent space, but small enough not to connect (geodesically) distant points of the manifold. The more data you have the higher `k` you can use.
+3. Perform operations in local (manifold) gauges or global coordinates. Note that `local_gauge=False` should be used whenever the manifold has negligible curvature on the scale of the local feature. Setting `local_gauge=True` means that the code performs tangent space alignments before computing gradients, however, this will increase the cost of the computations $m^2$-fold, where $m$ is the manifold dimension, because points will be treated as vector spaces. See the example of a [simple vector fields over curved surfaces](https://github.com/agosztolai/MARBLE/blob/main/examples/ex_vector_field_curved_surface.py) for illustration.
+
+
+The final data object contains the following attributes (among others):
+
+```
+data.pos: positions `pos` concatenated across manifolds
+data.x: vectors `x` concatenated across manifolds
+data.y: labels for each points denoting which manifold it belongs to
+data.edge_index: edge list of proximity graph (each manifold gets its own graph, disconnected from others)
+data.gauges: local coordinate bases when `local_gauge=True`
+```
+
+### How to pick good parameters
+
+Choosing good parameters for the description of manifold, in particular `stop_crit` and `k`, can be essential for the success of your analysis. The illustration below shows three different scenarios to give you intuition.
+
+1. (left) **'Optimal' scenario.** Here, the sample spacing along trajectories and between trajectories is comparable and `k` is choosen such that the proximity graph connects to neighbours but no further. At the same time `k` is large enough to have enough neighbours for gradient approximation. Notice the trade-off here.
+2. (middle) **Suboptimal scenario 1.** Here, the sample spacing is much smaller along the trajectory than between trajectories. This is probably frequently encountered when there are few trials relative to the dimension of the manifold and size of basin of attraction. Fitting a proximity graph to this dataset will lead to either a poorly connected manifold or having too many neighbours pointing to consecutive points on the trajectory, leading to poor gradient approximation. Also, too dense discretisation will mean that second-order features will not pick up on second-order features (curvature)of the trajectories. **Fix:** either increase `stop_crit` and/or subsample your trajectories before using `construct_dataset()`.
+3. (right) **Suboptimal scenario 2.** Here, there are too few sample points relative to the curvature of the trajectories. As a result, the gradient approximation will be inaccurate. **Fix:** decrease `stop_crit` or collect more data.
+
+![illustration](../assets/illustration_for_github.png)
+
+
+.. _training:
+
+### Training
+
+You are ready to train! This is straightforward.
+
+You first specify the hyperparameters. The key ones are the following, which will work for many settings, but see [here](https://github.com/agosztolai/MARBLE/blob/main/MARBLE/default_params.yaml) for a complete list.
+
+```
+params = {'epochs': 50, #optimisation epochs
+          'hidden_channels': 32, #number of internal dimensions in MLP
+          'out_channels': 5,
+          'inner_product_features': True,
+         }
+
+```
+
+Then proceed by constructing a network object
+
+```
+model = MARBLE.net(data, params=params)
+```
+
+Finally, launch training. The code will continuously save checkpoints during training with timestamps. 
+
+```
+model.run_training(data, outdir='./outputs')
+```
+
+If you have previously trained a network, or have interrupted training, you can load the network directly as
+
+```
+model = MARBLE.net(data, loadpath=loadpath)
+```
+
+where loadpath can be either a path to the model (with a specific timestamp, or a directory to automatically load the latest model. By running `MARBLE.run_training()`, training will resume from the last ckechpoint.
+
+.. _innerproduct:
+
+### Geometry-aware and geometry-agnostic modes
+
+One of the main features of our method is the ability to run in two different modes
+
+1. Geometry-aware mode - learn manifold geometry and dynamics
+2. Geometry-agnostic mode - learn dynamics only
+
+To enable geometry-agnostic mode, set `inner_product_features=True` in training `params`. This engages an additional layer in the network after the computation of gradients, which makes them rotation invariant.
+
+As a slight cost of expressivity, this feature enables the orientation- and geometry-independent representation of dynamics over the manifolds. Amongst others, this allows one to recognise similar dynamics across different manifolds. See [RNN example](https://github.com/agosztolai/MARBLE/blob/doc/examples/RNN/RNN.ipynb) for an illustration.
+
+
+## Troubleshooting guide
+
+Training is successful when features are recognised to be similar across distinct vector fields, with their own manifolds and independent proximity graphs. To achieve this, follow these useful pieces of advice (mostly general ML practises):
+
+1. Check that traning has converged, i.e., the validation loss is no longer decreasing.
+2. Check that convergence is smooth, i.e., there are no big jumps in the validation loss.
+3. Check that that there is no big gap between training loss and validation loss (generalisation gap). 
+
+Seeing problems with the above would be possible signs your solution will be suboptimal and will likely not generalise well. If you see either of these, try the following
+ * increase training time (increase `epochs`)
+ * increase your data (e.g., decrease `stop_crit` and construct dataset again)
+ * decrease number of parameters (decrease `hidden_channels`, or decrease order, try `order=1`)
+ * improve the gradient approximation (increase `k`, but see above)
+ * disable local gauges (`local_gauge=False`)
+
+If you still do not get good convergence, your data may be very noisy.
+ * Try enabling diffusion (`diffusion=True` in training `params`)
+
+If this still does not work, check if there are very small or very large vector magnitudes in your dataset, filter them out and try again. 
+
+
+## Stay in touch
+
+If all hopes are lost, or if you want to chat about your use case, get in touch or raise an issue! We are happy to help and looking to further develop this package to make it as useful as possible.
+
+
+## References
+
+The following packages were inspirational during the delopment of this code:
+
+* [DiffusionNet](https://github.com/nmwsharp/diffusion-net)
+* [Directional Graph Networks](https://github.com/Saro00/DGN)
+* [pyEDM](https://github.com/SugiharaLab/pyEDM)
+* [Parallel Transport Unfolding](https://github.com/mbudnins/parallel_transport_unfolding)

data/doc/source/conf.py

@@ -0,0 +1,42 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "MARBLE"
+copyright = "2023, Adam Gosztolai"
+author = "Adam Gosztolai"
+
+autodoc_member_order = "bysource"
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.doctest",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.todo",
+    "sphinx.ext.coverage",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.githubpages",
+    "sphinx.ext.napoleon",
+    "alabaster",
+    "sphinx_mdinclude",
+    "nbsphinx",
+]
+
+templates_path = ["_templates"]
+exclude_patterns = ["Thumbs.db", ".DS_Store", "_build", "**.ipynb_checkpoints"]
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "furo"
+autoclass_content = "both"
+#html_static_path = ["_static"]

data/doc/source/dataloader.rst

@@ -0,0 +1,4 @@
+Dataloader module
+=================
+.. automodule:: MARBLE.dataloader
+   :members:

data/doc/source/dynamics.rst

@@ -0,0 +1,4 @@
+Dynamics module
+===============
+.. automodule:: MARBLE.dynamics
+   :members:

data/doc/source/geometry.rst

@@ -0,0 +1,4 @@
+Geometry module
+===============
+.. automodule:: MARBLE.geometry
+   :members:

data/doc/source/index.rst

@@ -0,0 +1,15 @@
+.. mdinclude:: ../index_readme.md
+    :start-line: 0
+
+.. toctree::
+   :maxdepth: 1
+
+   main 
+   postprocessing 
+   preprocessing
+   layers
+   geometry
+   dataloader
+   plotting
+   utils
+   dynamics

data/doc/source/layers.rst

@@ -0,0 +1,4 @@
+Layers module
+=============
+.. automodule:: MARBLE.layers
+   :members:

data/doc/source/main.rst

@@ -0,0 +1,4 @@
+MARBLE module
+=============
+.. automodule:: MARBLE.main
+   :members:

data/doc/source/plotting.rst

@@ -0,0 +1,4 @@
+Plotting module
+===============
+.. automodule:: MARBLE.plotting
+   :members:

data/doc/source/postprocessing.rst

@@ -0,0 +1,4 @@
+Postprocessing module
+=====================
+.. automodule:: MARBLE.postprocessing
+   :members:

data/doc/source/preprocessing.rst

@@ -0,0 +1,4 @@
+Preprocessing module
+====================
+.. automodule:: MARBLE.preprocessing
+   :members:

data/doc/source/utils.rst

@@ -0,0 +1,4 @@
+Utils module
+============
+.. automodule:: MARBLE.utils
+   :members:

data/environment.yml

@@ -0,0 +1,159 @@
+name: MARBLE
+channels:
+  - pyg
+  - conda-forge
+  - pytorch
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - blas=1.0=mkl
+  - bottleneck=1.3.5=py39h7deecbd_0
+  - brotli=1.0.9=h5eee18b_7
+  - brotli-bin=1.0.9=h5eee18b_7
+  - brotlipy=0.7.0=py39h27cfd23_1003
+  - bzip2=1.0.8=h7b6447c_0
+  - ca-certificates=2022.07.19=h06a4308_0
+  - certifi=2022.9.24=py39h06a4308_0
+  - cffi=1.15.1=py39h74dc2b5_0
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - cryptography=37.0.1=py39h9ce1e76_0
+  - cudatoolkit=11.3.1=h2bc3f7f_2
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - cython=0.29.32=py39h6a678d5_0
+  - dbus=1.13.18=hb2f20db_0
+  - expat=2.4.9=h6a678d5_0
+  - ffmpeg=4.3=hf484d3e_0
+  - fftw=3.3.9=h27cfd23_1
+  - fontconfig=2.13.1=h6c09931_0
+  - fonttools=4.25.0=pyhd3eb1b0_0
+  - freetype=2.11.0=h70c0345_0
+  - future=0.18.2=py39h06a4308_1
+  - giflib=5.2.1=h7b6447c_0
+  - glib=2.69.1=h4ff587b_1
+  - gmp=6.2.1=h295c915_3
+  - gnutls=3.6.15=he1e5248_0
+  - gst-plugins-base=1.14.0=h8213a91_2
+  - gstreamer=1.14.0=h28cd5cc_2
+  - icu=58.2=he6710b0_3
+  - idna=3.4=py39h06a4308_0
+  - intel-openmp=2021.4.0=h06a4308_3561
+  - jinja2=3.0.3=pyhd3eb1b0_0
+  - joblib=1.1.0=pyhd3eb1b0_0
+  - jpeg=9e=h7f8727e_0
+  - kiwisolver=1.4.2=py39h295c915_0
+  - krb5=1.19.2=hac12032_0
+  - lame=3.100=h7b6447c_0
+  - lapack=3.9.0=netlib
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - lerc=3.0=h295c915_0
+  - libblas=3.9.0=12_linux64_mkl
+  - libbrotlicommon=1.0.9=h5eee18b_7
+  - libbrotlidec=1.0.9=h5eee18b_7
+  - libbrotlienc=1.0.9=h5eee18b_7
+  - libclang=10.0.1=default_hb85057a_2
+  - libdeflate=1.8=h7f8727e_5
+  - libedit=3.1.20210910=h7f8727e_0
+  - libevent=2.1.12=h8f2d780_0
+  - libffi=3.3=he6710b0_2
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgfortran-ng=11.2.0=h00389a5_1
+  - libgfortran5=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libiconv=1.16=h7f8727e_2
+  - libidn2=2.3.2=h7f8727e_0
+  - liblapack=3.9.0=12_linux64_mkl
+  - libllvm10=10.0.1=hbcb73fb_5
+  - libpng=1.6.37=hbc83047_0
+  - libpq=12.9=h16c4e8d_3
+  - libprotobuf=3.20.1=h4ff587b_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtasn1=4.16.0=h27cfd23_0
+  - libtiff=4.4.0=hecacb30_0
+  - libunistring=0.9.10=h27cfd23_0
+  - libuuid=1.0.3=h7f8727e_2
+  - libwebp=1.2.4=h11a3e52_0
+  - libwebp-base=1.2.4=h5eee18b_0
+  - libxcb=1.15=h7f8727e_0
+  - libxkbcommon=1.0.1=hfa300c1_0
+  - libxml2=2.9.14=h74e7548_0
+  - libxslt=1.1.35=h4e12654_0
+  - lz4-c=1.9.3=h295c915_1
+  - markupsafe=2.1.1=py39h7f8727e_0
+  - matplotlib=3.5.2=py39h06a4308_0
+  - matplotlib-base=3.5.2=py39hf590b9c_0
+  - mkl=2021.4.0=h06a4308_640
+  - mkl-service=2.4.0=py39h7f8727e_0
+  - mkl_fft=1.3.1=py39hd3c417c_0
+  - mkl_random=1.2.2=py39h51133e4_0
+  - munkres=1.1.4=py_0
+  - ncurses=6.3=h5eee18b_3
+  - nettle=3.7.3=hbbd107a_1
+  - networkx=2.8.4=py39h06a4308_0
+  - ninja=1.10.2=h06a4308_5
+  - ninja-base=1.10.2=hd09550d_5
+  - nspr=4.33=h295c915_0
+  - nss=3.74=h0370c37_0
+  - numexpr=2.8.3=py39h807cd23_0
+  - numpy=1.23.3=py39h14f4228_0
+  - numpy-base=1.23.3=py39h31eccc5_0
+  - openh264=2.1.1=h4ff587b_0
+  - openssl=1.1.1q=h7f8727e_0
+  - packaging=21.3=pyhd3eb1b0_0
+  - pandas=1.4.4=py39h6a678d5_0
+  - pcre=8.45=h295c915_0
+  - pillow=9.2.0=py39hace64e9_1
+  - pip=22.2.2=py39h06a4308_0
+  - ply=3.11=py39h06a4308_0
+  - pot=0.8.2=py39h1832856_0
+  - protobuf=3.20.1=py39h295c915_0
+  - pybind11=2.9.2=py39h79cecc1_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyg=2.1.0=py39_torch_1.12.0_cu113
+  - pyopenssl=22.0.0=pyhd3eb1b0_0
+  - pyparsing=3.0.9=py39h06a4308_0
+  - pyqt=5.15.7=py39h6a678d5_1
+  - pyqt5-sip=12.11.0=py39h6a678d5_1
+  - pysocks=1.7.1=py39h06a4308_0
+  - python=3.9.13=haa1d7c7_2
+  - python-dateutil=2.8.2=pyhd3eb1b0_0
+  - python_abi=3.9=2_cp39
+  - pytorch=1.12.1=py3.9_cuda11.3_cudnn8.3.2_0
+  - pytorch-cluster=1.6.0=py39_torch_1.12.0_cu113
+  - pytorch-mutex=1.0=cuda
+  - pytorch-scatter=2.0.9=py39_torch_1.12.0_cu113
+  - pytorch-sparse=0.6.15=py39_torch_1.12.0_cu113
+  - pytz=2022.1=py39h06a4308_0
+  - pyyaml=6.0=py39h7f8727e_1
+  - qt-main=5.15.2=h327a75a_7
+  - qt-webengine=5.15.9=hd2b0992_4
+  - qtwebkit=5.212=h4eab89a_4
+  - readline=8.1.2=h7f8727e_1
+  - requests=2.28.1=py39h06a4308_0
+  - scikit-learn=1.1.2=py39h6a678d5_0
+  - scipy=1.9.1=py39h14f4228_0
+  - seaborn=0.11.2=pyhd3eb1b0_0
+  - setuptools=63.4.1=py39h06a4308_0
+  - sip=6.6.2=py39h6a678d5_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.39.3=h5082296_0
+  - tensorboardx=2.2=pyhd3eb1b0_0
+  - threadpoolctl=2.2.0=pyh0d69192_0
+  - tk=8.6.12=h1ccaba5_0
+  - toml=0.10.2=pyhd3eb1b0_0
+  - torchaudio=0.12.1=py39_cu113
+  - torchvision=0.13.1=py39_cu113
+  - tornado=6.2=py39h5eee18b_0
+  - tqdm=4.64.1=py39h06a4308_0
+  - typing-extensions=4.3.0=py39h06a4308_0
+  - typing_extensions=4.3.0=py39h06a4308_0
+  - tzdata=2022e=h04d1e81_0
+  - urllib3=1.26.11=py39h06a4308_0
+  - wheel=0.37.1=pyhd3eb1b0_0
+  - xz=5.2.6=h5eee18b_0
+  - yaml=0.2.5=h7b6447c_0
+  - zlib=1.2.12=h5eee18b_3
+  - zstd=1.5.2=ha4553b6_0
+  - pip:
+    - teaspoon==1.3.1

data/environment_osx_arm.yml

@@ -0,0 +1,111 @@
+name: MARBLE
+channels:
+  - pytorch
+  - defaults
+dependencies:
+  - blas=1.0=openblas
+  - bottleneck=1.3.5=py39heec5a64_0
+  - brotli=1.0.9=h1a28f6b_7
+  - brotli-bin=1.0.9=h1a28f6b_7
+  - brotlipy=0.7.0=py39h1a28f6b_1002
+  - bzip2=1.0.8=h620ffc9_4
+  - ca-certificates=2023.08.22=hca03da5_0
+  - certifi=2023.7.22=py39hca03da5_0
+  - cffi=1.15.1=py39h80987f9_3
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - contourpy=1.0.5=py39h525c30c_0
+  - cryptography=41.0.3=py39hd4332d6_0
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - ffmpeg=4.2.2=h04105a8_0
+  - fonttools=4.25.0=pyhd3eb1b0_0
+  - freetype=2.12.1=h1192e45_0
+  - gettext=0.21.0=h13f89a0_1
+  - giflib=5.2.1=h80987f9_3
+  - gmp=6.2.1=hc377ac9_3
+  - gnutls=3.6.15=h887c41c_0
+  - icu=73.1=h313beb8_0
+  - idna=3.4=py39hca03da5_0
+  - importlib_resources=5.2.0=pyhd3eb1b0_1
+  - jpeg=9e=h80987f9_1
+  - jupyterlab
+  - kiwisolver=1.4.4=py39h313beb8_0
+  - lame=3.100=h1a28f6b_0
+  - lcms2=2.12=hba8e193_0
+  - lerc=3.0=hc377ac9_0
+  - libbrotlicommon=1.0.9=h1a28f6b_7
+  - libbrotlidec=1.0.9=h1a28f6b_7
+  - libbrotlienc=1.0.9=h1a28f6b_7
+  - libcxx=14.0.6=h848a8c0_0
+  - libdeflate=1.17=h80987f9_1
+  - libffi=3.4.4=hca03da5_0
+  - libgfortran=5.0.0=11_3_0_hca03da5_28
+  - libgfortran5=11.3.0=h009349e_28
+  - libiconv=1.16=h1a28f6b_2
+  - libidn2=2.3.4=h80987f9_0
+  - libopenblas=0.3.21=h269037a_0
+  - libopus=1.3=h1a28f6b_1
+  - libpng=1.6.39=h80987f9_0
+  - libtasn1=4.19.0=h80987f9_0
+  - libtiff=4.5.1=h313beb8_0
+  - libunistring=0.9.10=h1a28f6b_0
+  - libvpx=1.10.0=hc377ac9_0
+  - libwebp=1.3.2=ha3663a8_0
+  - libwebp-base=1.3.2=h80987f9_0
+  - libxml2=2.10.4=h0dcf63f_1
+  - llvm-openmp=14.0.6=hc6e5704_0
+  - lz4-c=1.9.4=h313beb8_0
+  - matplotlib=3.7.2=py39hca03da5_0
+  - matplotlib-base=3.7.2=py39h46d7db6_0
+  - munkres=1.1.4=py_0
+  - ncurses=6.4=h313beb8_0
+  - nettle=3.7.3=h84b5d62_1
+  - networkx=3.1=py39hca03da5_0
+  - numexpr=2.8.7=py39hecc3335_0
+  - numpy=1.26.0=py39h3b2db8e_0
+  - numpy-base=1.26.0=py39ha9811e2_0
+  - openh264=1.8.0=h98b2900_0
+  - openjpeg=2.3.0=h7a6adac_2
+  - openssl=3.0.11=h1a28f6b_2
+  - packaging=23.1=py39hca03da5_0
+  - pandas=2.1.1=py39h46d7db6_0
+  - pillow=10.0.1=py39h3b245a6_0
+  - pip=23.3=py39hca03da5_0
+  - pybind11=2.10.4=py39h48ca7d4_0
+  - pybind11-global=2.10.4=py39h48ca7d4_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyopenssl=23.2.0=py39hca03da5_0
+  - pyparsing=3.0.9=py39hca03da5_0
+  - pysocks=1.7.1=py39hca03da5_0
+  - python=3.9.18=hb885b13_0
+  - python-dateutil=2.8.2=pyhd3eb1b0_0
+  - python-tzdata=2023.3=pyhd3eb1b0_0
+  - pytorch=1.12.1=py3.9_0
+  - pytz=2023.3.post1=py39hca03da5_0
+  - pyyaml=6.0=py39h80987f9_1
+  - readline=8.2=h1a28f6b_0
+  - requests=2.31.0=py39hca03da5_0
+  - scipy=1.11.3=py39h20cbe94_0
+  - seaborn=0.11
+  - setuptools=68.0.0=py39hca03da5_0
+  - scikit-learn=1.3.0=py39h46d7db6_0
+  - statannotations
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.41.2=h80987f9_0
+  - tk=8.6.12=hb8d0fd4_0
+  - torchaudio=0.12.1=py39_cpu
+  - torchvision=0.13.1=py39_cpu
+  - tornado=6.3.3=py39h80987f9_0
+  - tqdm=4.65.0=py39h86d0a89_0
+  - typing_extensions=4.7.1=py39hca03da5_0
+  - tzdata=2023c=h04d1e81_0
+  - urllib3=1.26.16=py39hca03da5_0
+  - wheel=0.41.2=py39hca03da5_0
+  - x264=1!152.20180806=h1a28f6b_0
+  - xz=5.4.2=h80987f9_0
+  - yaml=0.2.5=h1a28f6b_0
+  - zipp=3.11.0=py39hca03da5_0
+  - zlib=1.2.13=h5a0b063_0
+  - zstd=1.5.5=hd90d995_0
+  - pip:
+      - ninja==1.11.1.1
+      - teaspoon==1.3.1

data/environment_osx_intel.yml

@@ -0,0 +1,131 @@
+name: MARBLE
+channels:
+  - pyg
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - blas=2.116=openblas
+  - blas-devel=3.9.0=16_osx64_openblas
+  - bottleneck=1.3.5=py39h67323c0_0
+  - brotli=1.0.9=hca72f7f_7
+  - brotli-bin=1.0.9=hca72f7f_7
+  - brotlipy=0.7.0=py39h9ed2024_1003
+  - bzip2=1.0.8=h1de35cc_0
+  - ca-certificates=2022.9.24=h033912b_0
+  - certifi=2022.9.24=pyhd8ed1ab_0
+  - cffi=1.15.1=py39hc55c11b_0
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - cryptography=37.0.1=py39hf6deb26_0
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - cython=0.29.32=py39he9d5cce_0
+  - ffmpeg=4.3=h0a44026_0
+  - fftw=3.3.9=h9ed2024_1
+  - fonttools=4.25.0=pyhd3eb1b0_0
+  - freetype=2.11.0=hd8bbffd_0
+  - gettext=0.21.0=h7535e17_0
+  - giflib=5.2.1=haf1e3a3_0
+  - gmp=6.2.1=he9d5cce_3
+  - gnutls=3.6.15=hed9c0bf_0
+  - icu=58.2=h0a44026_3
+  - idna=3.4=py39hecd8cb5_0
+  - intel-openmp=2021.4.0=hecd8cb5_3538
+  - jinja2=3.0.3=pyhd3eb1b0_0
+  - joblib=1.1.1=py39hecd8cb5_0
+  - jpeg=9e=hca72f7f_0
+  - kiwisolver=1.4.2=py39he9d5cce_0
+  - lame=3.100=h1de35cc_0
+  - lapack=3.9.0=netlib
+  - lcms2=2.12=hf1fd2bf_0
+  - lerc=3.0=he9d5cce_0
+  - libblas=3.9.0=16_osx64_openblas
+  - libbrotlicommon=1.0.9=hca72f7f_7
+  - libbrotlidec=1.0.9=hca72f7f_7
+  - libbrotlienc=1.0.9=hca72f7f_7
+  - libcblas=3.9.0=16_osx64_openblas
+  - libcxx=14.0.6=h9765a3e_0
+  - libdeflate=1.8=h9ed2024_5
+  - libffi=3.4.2=h0d85af4_5
+  - libgfortran=5.0.0=11_3_0_hecd8cb5_28
+  - libgfortran5=11.3.0=h9dfd629_28
+  - libiconv=1.16=hca72f7f_2
+  - libidn2=2.3.2=h9ed2024_0
+  - liblapack=3.9.0=16_osx64_openblas
+  - liblapacke=3.9.0=16_osx64_openblas
+  - libopenblas=0.3.21=openmp_h429af6e_3
+  - libpng=1.6.37=ha441bb4_0
+  - libprotobuf=3.20.1=h8346a28_0
+  - libtasn1=4.16.0=h9ed2024_0
+  - libtiff=4.4.0=h2ef1027_0
+  - libunistring=0.9.10=h9ed2024_0
+  - libwebp=1.2.4=h56c3ce4_0
+  - libwebp-base=1.2.4=hca72f7f_0
+  - libxml2=2.9.14=hbf8cd5e_0
+  - libzlib=1.2.12=hfd90126_3
+  - llvm-openmp=14.0.6=h0dcd299_0
+  - lz4-c=1.9.3=h23ab428_1
+  - markupsafe=2.1.1=py39hca72f7f_0
+  - matplotlib=3.5.2=py39hecd8cb5_0
+  - matplotlib-base=3.5.2=py39hfb0c5b7_0
+  - mkl=2022.1.0=h860c996_928
+  - mkl-service=2.4.0=py39h9032bd8_0
+  - mkl_fft=1.3.1=py39hbc11c22_3
+  - mkl_random=1.2.2=py39h1833399_1
+  - munkres=1.1.4=py_0
+  - ncurses=6.3=hca72f7f_3
+  - nettle=3.7.3=h230ac6f_1
+  - networkx=2.8.4=py39hecd8cb5_0
+  - ninja=1.11.0=h1b54a9f_0
+  - nomkl=3.0=0
+  - numexpr=2.8.3=py39hf72b562_0
+  - numpy=1.23.3=py39h0f1bd0b_0
+  - numpy-base=1.23.3=py39hbda7086_0
+  - openblas=0.3.21=openmp_hbefa662_3
+  - openh264=2.1.1=h8346a28_0
+  - openssl=3.0.5=hfd90126_2
+  - packaging=21.3=pyhd3eb1b0_0
+  - pandas=1.4.4=py39he9d5cce_0
+  - pillow=9.2.0=py39hde71d04_1
+  - pip=22.2.2=py39hecd8cb5_0
+  - pot=0.8.2=py39hca71b8a_1
+  - protobuf=3.20.1=py39he9d5cce_0
+  - pybind11=2.9.2=py39hc29d2bd_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyg=2.1.0=py39_torch_1.12.0_cpu
+  - pyopenssl=22.0.0=pyhd3eb1b0_0
+  - pyparsing=3.0.9=py39hecd8cb5_0
+  - pysocks=1.7.1=py39hecd8cb5_0
+  - python=3.9.13=hf8d34f4_0_cpython
+  - python-dateutil=2.8.2=pyhd3eb1b0_0
+  - python_abi=3.9=2_cp39
+  - pytorch=1.12.1=cpu_py39h9b0ea23_0
+  - pytorch-cluster=1.6.0=py39_torch_1.12.0_cpu
+  - pytorch-scatter=2.0.9=py39_torch_1.12.0_cpu
+  - pytorch-sparse=0.6.15=py39_torch_1.12.0_cpu
+  - pytz=2022.1=py39hecd8cb5_0
+  - pyyaml=6.0=py39hca72f7f_1
+  - readline=8.1.2=hca72f7f_1
+  - requests=2.28.1=py39hecd8cb5_0
+  - scikit-learn=1.1.2=py39he9d5cce_0
+  - scipy=1.9.3=py39h8a15683_0
+  - seaborn=0.12.0=py39hecd8cb5_0
+  - setuptools=63.4.1=py39hecd8cb5_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sleef=3.5.1=h6db0672_2
+  - sqlite=3.39.3=h707629a_0
+  - tbb=2021.6.0=hb8565cd_0
+  - tensorboardx=2.2=pyhd3eb1b0_0
+  - threadpoolctl=2.2.0=pyh0d69192_0
+  - tk=8.6.12=h5d9f67b_0
+  - torchaudio=0.12.1=py39_cpu
+  - torchvision=0.13.1=py39_cpu
+  - tornado=6.2=py39hca72f7f_0
+  - tqdm=4.64.1=py39hecd8cb5_0
+  - typing_extensions=4.3.0=py39hecd8cb5_0
+  - tzdata=2022e=h04d1e81_0
+  - urllib3=1.26.12=py39hecd8cb5_0
+  - wheel=0.37.1=pyhd3eb1b0_0
+  - xz=5.2.6=hca72f7f_0
+  - yaml=0.2.5=haf1e3a3_0
+  - zlib=1.2.12=h4dc903c_3
+  - zstd=1.5.2=hcb37349_0

data/environment_windows_native.yml

@@ -0,0 +1,119 @@
+name: MARBLE
+channels:
+  - pytorch
+  - pyg
+  - defaults
+dependencies:
+  - blas=1.0=mkl
+  - bottleneck=1.3.5=py39h080aedc_0
+  - brotli=1.0.9=h2bbff1b_7
+  - brotli-bin=1.0.9=h2bbff1b_7
+  - brotlipy=0.7.0=py39h2bbff1b_1003
+  - ca-certificates=2023.08.22=haa95532_0
+  - certifi=2023.7.22=py39haa95532_0
+  - cffi=1.15.1=py39h2bbff1b_3
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - colorama=0.4.6=py39haa95532_0
+  - contourpy=1.0.5=py39h59b6b97_0
+  - cryptography=41.0.3=py39h89fc84f_0
+  - cudatoolkit=11.3.1=h59b6b97_2
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - fonttools=4.25.0=pyhd3eb1b0_0
+  - freetype=2.12.1=ha860e81_0
+  - giflib=5.2.1=h8cc25b3_3
+  - glib=2.69.1=h5dc1a3c_2
+  - icc_rt=2022.1.0=h6049295_2
+  - icu=58.2=ha925a31_3
+  - idna=3.4=py39haa95532_0
+  - importlib_resources=5.2.0=pyhd3eb1b0_1
+  - intel-openmp=2023.1.0=h59b6b97_46319
+  - jinja2=3.1.2=py39haa95532_0
+  - joblib=1.2.0=py39haa95532_0
+  - jpeg=9e=h2bbff1b_1
+  - kiwisolver=1.4.4=py39hd77b12b_0
+  - krb5=1.20.1=h5b6d351_0
+  - lerc=3.0=hd77b12b_0
+  - libbrotlicommon=1.0.9=h2bbff1b_7
+  - libbrotlidec=1.0.9=h2bbff1b_7
+  - libbrotlienc=1.0.9=h2bbff1b_7
+  - libclang=14.0.6=default_hb5a9fac_1
+  - libclang13=14.0.6=default_h8e68704_1
+  - libdeflate=1.17=h2bbff1b_1
+  - libffi=3.4.4=hd77b12b_0
+  - libiconv=1.16=h2bbff1b_2
+  - libpng=1.6.39=h8cc25b3_0
+  - libpq=12.15=h906ac69_1
+  - libtiff=4.5.1=hd77b12b_0
+  - libuv=1.44.2=h2bbff1b_0
+  - libwebp=1.3.2=hbc33d0d_0
+  - libwebp-base=1.3.2=h2bbff1b_0
+  - libxml2=2.10.4=h0ad7f3c_1
+  - libxslt=1.1.37=h2bbff1b_1
+  - lz4-c=1.9.4=h2bbff1b_0
+  - markupsafe=2.1.1=py39h2bbff1b_0
+  - matplotlib=3.7.2=py39haa95532_0
+  - matplotlib-base=3.7.2=py39h4ed8f06_0
+  - mkl=2023.1.0=h6b88ed4_46357
+  - mkl-service=2.4.0=py39h2bbff1b_1
+  - mkl_fft=1.3.8=py39h2bbff1b_0
+  - mkl_random=1.2.4=py39h59b6b97_0
+  - munkres=1.1.4=py_0
+  - networkx=3.1=py39haa95532_0
+  - numexpr=2.8.7=py39h2cd9be0_0
+  - numpy=1.26.0=py39h055cbcc_0
+  - numpy-base=1.26.0=py39h65a83cf_0
+  - openjpeg=2.4.0=h4fc8c34_0
+  - openssl=3.0.11=h2bbff1b_2
+  - packaging=23.1=py39haa95532_0
+  - pandas=2.1.1=py39h4ed8f06_0
+  - pcre=8.45=hd77b12b_0
+  - pillow=10.0.1=py39h045eedc_0
+  - pip=23.3=py39haa95532_0
+  - ply=3.11=py39haa95532_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyg=2.1.0=py39_torch_1.12.0_cu113
+  - pyopenssl=23.2.0=py39haa95532_0
+  - pyparsing=3.0.9=py39haa95532_0
+  - pyqt=5.15.7=py39hd77b12b_0
+  - pyqt5-sip=12.11.0=py39hd77b12b_0
+  - pysocks=1.7.1=py39haa95532_0
+  - python=3.9.18=h1aa4202_0
+  - python-dateutil=2.8.2=pyhd3eb1b0_0
+  - python-tzdata=2023.3=pyhd3eb1b0_0
+  - pytorch=1.12.1=py3.9_cuda11.3_cudnn8_0
+  - pytorch-cluster=1.6.0=py39_torch_1.12.0_cu113
+  - pytorch-mutex=1.0=cuda
+  - pytorch-scatter=2.0.9=py39_torch_1.12.0_cu113
+  - pytorch-sparse=0.6.15=py39_torch_1.12.0_cu113
+  - pytz=2023.3.post1=py39haa95532_0
+  - qt-main=5.15.2=h879a1e9_9
+  - qt-webengine=5.15.9=h5bd16bc_7
+  - qtwebkit=5.212=h2bbfb41_5
+  - requests=2.31.0=py39haa95532_0
+  - scikit-learn=1.3.0=py39h4ed8f06_0
+  - scipy=1.11.3=py39h309d312_0
+  - setuptools=68.0.0=py39haa95532_0
+  - sip=6.6.2=py39hd77b12b_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.41.2=h2bbff1b_0
+  - tbb=2021.8.0=h59b6b97_0
+  - threadpoolctl=2.2.0=pyh0d69192_0
+  - tk=8.6.12=h2bbff1b_0
+  - toml=0.10.2=pyhd3eb1b0_0
+  - torchaudio=0.12.1=py39_cu113
+  - torchvision=0.13.1=py39_cu113
+  - tornado=6.3.3=py39h2bbff1b_0
+  - tqdm=4.65.0=py39hd4e2768_0
+  - typing_extensions=4.7.1=py39haa95532_0
+  - tzdata=2023c=h04d1e81_0
+  - urllib3=1.26.16=py39haa95532_0
+  - vc=14.2=h21ff451_1
+  - vs2015_runtime=14.27.29016=h5e58377_2
+  - wheel=0.41.2=py39haa95532_0
+  - win_inet_pton=1.1.0=py39haa95532_0
+  - xz=5.4.2=h8cc25b3_0
+  - zipp=3.11.0=py39haa95532_0
+  - zlib=1.2.13=h8cc25b3_0
+  - zstd=1.5.5=hd43e919_0
+  - pip:
+      - teaspoon==1.3.1

data/examples/RNN/RNN_scripts/__init__.py

@@ -0,0 +1,10 @@
+"""Code to generate RNN networks following:
+
+A. Dubreuil, A. Valente, M. Beiran, F. Mastrogiuseppe, and S. Ostojic,
+    “The role of population structure in computations through neural dynamics,”
+    Nat. Neurosci., vol. 25, no. 6, pp. 783–794, 2022, doi: 10.1038/s41593-022-01088-4.
+
+with code adapted from available at:
+
+https://github.com/adrian-valente/populations_paper_code/tree/master/figures_notebooks
+"""

data/examples/RNN/RNN_scripts/clustering.py

@@ -0,0 +1,467 @@
+import numpy as np
+from scipy import stats
+from math import sqrt
+import torch
+import multiprocessing as mp
+from itertools import repeat
+from sklearn.mixture import GaussianMixture, BayesianGaussianMixture
+from sklearn.cluster import SpectralClustering
+from sklearn.metrics import adjusted_rand_score
+from sklearn.neighbors import NearestNeighbors
+import matplotlib.pyplot as plt
+
+from .modules import SupportLowRankRNN
+
+
+def phi_prime(x):
+    return 1 - np.tanh(x) ** 2
+
+
+def hard_thresh_linreg(vec1, vec2, inp, thresh=0.5, label1="", label2=""):
+    """
+    plot a scatter of (vec1, vec2) points, separated in 2 populations according to the threshold inp > thresh,
+    with linear regressions
+    :param vec1: array of shape n
+    :param vec2: array of shape n
+    :param inp: array of shape n
+    :param thresh: float
+    :param label1: label for x axis
+    :param label2: label for y axis
+    :return:
+    """
+    idx1 = phi_prime(inp) < thresh
+    idx2 = phi_prime(inp) > thresh
+
+    plt.scatter(vec1[idx1], vec2[idx1], c="orange", label="saturated")
+    plt.scatter(vec1[idx2], vec2[idx2], c="green", label="non saturated")
+
+    xmin, xmax = vec1.min(), vec1.max()
+
+    slope, intercept, r_value, p_value, std_err = stats.linregress(vec1[idx2], vec2[idx2])
+    print("slope: %f    intercept: %f" % (slope, intercept))
+    print("r-squared: %f" % (r_value**2))
+    print("p-value: %f" % p_value)
+    xs = np.linspace(xmin, xmax, 100)
+    plt.plot(xs, slope * xs + intercept, color="green")
+
+    slope2, intercept2, r_value2, p_value2, std_err2 = stats.linregress(vec1[idx1], vec2[idx1])
+    print("slope: %f    intercept: %f" % (slope2, intercept2))
+    print("r-squared: %f" % (r_value2**2))
+    print("p-value: %f" % p_value2)
+    xs = np.linspace(xmin, xmax, 100)
+    plt.plot(xs, slope2 * xs + intercept2, color="orange")
+    plt.legend()
+
+    slope, intercept, r_value, p_value, std_err = stats.linregress(vec1, vec2)
+    print("slope: %f    intercept: %f" % (slope, intercept))
+    print("r-squared: %f" % (r_value**2))
+    print("p-value: %f" % p_value)
+    xs = np.linspace(xmin, xmax, 100)
+    plt.plot(xs, slope * xs + intercept, color="b")
+    plt.xlabel(label1)
+    plt.ylabel(label2)
+    plt.show()
+
+    return idx1, idx2
+
+
+def gmm_fit(
+    net,
+    n_components,
+    algo="bayes",
+    n_init=50,
+    random_state=None,
+    mean_precision_prior=None,
+    weight_concentration_prior_type="dirichlet_process",
+    weight_concentration_prior=None,
+):
+    """
+    fit a mixture of gaussians to a set of vectors
+    :param net
+    :param n_components: int
+    :param algo: 'em' or 'bayes'
+    :param n_init: number of random seeds for the inference algorithm
+    :param random_state: random seed for the rng to eliminate randomness
+    :return: vector of population labels (of shape n), best fitted model
+    """
+    neurons_fs = make_vecs(net)
+
+    if isinstance(neurons_fs, list):
+        X = np.vstack(neurons_fs).transpose()
+    else:
+        X = neurons_fs
+    if algo == "em":
+        model = GaussianMixture(n_components=n_components, n_init=n_init, random_state=random_state)
+    else:
+        model = BayesianGaussianMixture(
+            n_components=n_components,
+            n_init=n_init,
+            random_state=random_state,
+            init_params="random",
+            mean_precision_prior=mean_precision_prior,
+            weight_concentration_prior_type=weight_concentration_prior_type,
+            weight_concentration_prior=weight_concentration_prior,
+        )
+    model.fit(X)
+    z = model.predict(X)
+    return z, model
+
+
+def make_vecs(net):
+    """
+    return a list of vectors (list of numpy arrays of shape n) composing a network
+    """
+    return (
+        [net.m[:, i].detach().cpu().numpy() for i in range(net.rank)]
+        + [net.n[:, i].detach().cpu().numpy() for i in range(net.rank)]
+        + [net.wi[i].detach().cpu().numpy() for i in range(net.input_size)]
+        + [net.wo[:, i].cpu().detach().numpy() for i in range(net.output_size)]
+    )
+
+
+def gram_factorization(G):
+    """
+    The rows of the returned matrix are the basis vectors whose Gramian matrix is G
+    :param G: ndarray representing a symmetric semidefinite positive matrix
+    :return: ndarray
+    """
+    w, v = np.linalg.eigh(G)
+    x = v * np.sqrt(w)
+    return x
+
+
+def to_support_net(net, z, take_means=False):
+    X = np.vstack(make_vecs(net)).transpose()
+    _, counts = np.unique(z, return_counts=True)
+    n_components = counts.shape[0]
+    weights = counts / net.hidden_size
+    if take_means:
+        means = np.vstack([X[z == i].mean(axis=0) for i in range(n_components)])
+    else:
+        means = np.zeros((n_components, X.shape[1]))
+    covariances = [np.cov(X[z == i].transpose()) for i in range(n_components)]
+
+    rank = net.rank
+    basis_dim = 2 * rank + net.input_size + net.output_size
+    m_init = torch.zeros(rank, n_components, basis_dim)
+    n_init = torch.zeros(rank, n_components, basis_dim)
+    wi_init = torch.zeros(net.input_size, n_components, basis_dim)
+    wo_init = torch.zeros(net.output_size, n_components, basis_dim)
+
+    # if new_size is None:
+    new_size = net.hidden_size
+    old_size = net.hidden_size
+    # if scaling:
+    #     old_size = net.hidden_size
+    # else:
+    #     old_size = 1
+    m_means = torch.from_numpy(means[:, :rank]).t() * sqrt(old_size) / sqrt(new_size)
+    n_means = torch.from_numpy(means[:, rank : 2 * rank]).t() * sqrt(old_size) / sqrt(new_size)
+    wi_means = torch.from_numpy(means[:, 2 * rank : 2 * rank + net.input_size]).t()
+
+    for i in range(n_components):
+        # Compute Gramian matrix of the basis we have to build
+        G = covariances[i]
+        X_reduced = gram_factorization(G)
+        for k in range(rank):
+            m_init[k, i] = torch.from_numpy(X_reduced[k]) * sqrt(old_size) / sqrt(new_size)
+            n_init[k, i] = torch.from_numpy(X_reduced[rank + k]) * sqrt(old_size) / sqrt(new_size)
+        for k in range(net.input_size):
+            wi_init[k, i] = torch.from_numpy(X_reduced[2 * rank + k])
+        for k in range(net.output_size):
+            wo_init[k, i] = (
+                torch.from_numpy(X_reduced[2 * rank + net.input_size + k]) * old_size / new_size
+            )
+
+    net2 = SupportLowRankRNN(
+        net.input_size,
+        net.hidden_size,
+        net.output_size,
+        net.noise_std,
+        net.alpha,
+        rank,
+        n_components,
+        weights,
+        basis_dim,
+        m_init,
+        n_init,
+        wi_init,
+        wo_init,
+        m_means,
+        n_means,
+        wi_means,
+    )
+    return net2
+
+
+def to_support_net_old(net, n_components=1, new_size=None):
+    vecs = make_vecs(net)
+    z, model = gmm_fit(vecs, n_components)
+    weights = model.weights_
+
+    rank = net.rank
+    basis_dim = 2 * rank + net.input_size + net.output_size
+    m_init = torch.zeros(rank, n_components, basis_dim)
+    n_init = torch.zeros(rank, n_components, basis_dim)
+    wi_init = torch.zeros(net.input_size, n_components, basis_dim)
+    wo_init = torch.zeros(net.output_size, n_components, basis_dim)
+
+    if new_size is None:
+        new_size = net.hidden_size
+    old_size = net.hidden_size
+    m_means = torch.from_numpy(model.means_[:, :rank]).t() * sqrt(old_size) / sqrt(new_size)
+    n_means = (
+        torch.from_numpy(model.means_[:, rank : 2 * rank]).t() * sqrt(old_size) / sqrt(new_size)
+    )
+    wi_means = torch.from_numpy(model.means_[:, 2 * rank : 2 * rank + net.input_size]).t()
+
+    for i in range(n_components):
+        # Compute Gramian matrix of the basis we have to build
+        G = model.covariances_[i]
+        X_reduced = gram_factorization(G)
+        for k in range(rank):
+            m_init[k, i] = torch.from_numpy(X_reduced[k]) * sqrt(old_size) / sqrt(new_size)
+            n_init[k, i] = torch.from_numpy(X_reduced[rank + k]) * sqrt(old_size) / sqrt(new_size)
+        for k in range(net.input_size):
+            wi_init[k, i] = torch.from_numpy(X_reduced[2 * rank + k])
+        for k in range(net.output_size):
+            wo_init[k, i] = (
+                torch.from_numpy(X_reduced[2 * rank + net.input_size + k]) * old_size / new_size
+            )
+
+    net2 = SupportLowRankRNN(
+        net.input_size,
+        new_size,
+        net.output_size,
+        net.noise_std,
+        net.alpha,
+        rank,
+        n_components,
+        weights,
+        basis_dim,
+        m_init,
+        n_init,
+        wi_init,
+        wo_init,
+        m_means,
+        n_means,
+        wi_means,
+    )
+    return net2
+
+
+def center_axes(ax):
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.spines["bottom"].set_position("zero")
+    ax.spines["left"].set_position("zero")
+    ax.set(xticks=[], yticks=[])
+
+
+def pop_scatter_linreg(
+    vec1,
+    vec2,
+    pops,
+    n_pops=None,
+    linreg=True,
+    colors=("blue", "green", "red", "violet", "gray"),
+    figsize=(5, 5),
+    size=10.0,
+    ax=None,
+):
+    """
+    scatter plot of (vec1, vec2) points separated in populations according to int labels in vector pops, with linear
+    regressions
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+    center_axes(ax)
+
+    # Computing axes limits
+    xmax = max(abs(vec1.min()), vec1.max())
+    xmin = -xmax
+    ax.set_xlim(xmin - 0.1 * (xmax - xmin), xmax + 0.1 * (xmax - xmin))
+    ymax = max(abs(vec2.min()), vec2.min())
+    ymin = -ymax
+    ax.set_ylim(ymin - 0.1 * (ymax - ymin), ymax + 0.1 * (ymax - ymin))
+    xs = np.linspace(xmin - 0.1 * (xmax - xmin), xmax + 0.1 * (xmax - xmin), 100)
+
+    if n_pops is None:
+        n_pops = np.unique(pops).shape[0]
+    for i in range(n_pops):
+        ax.scatter(vec1[pops == i], vec2[pops == i], color=colors[i], s=size)
+        if linreg:
+            slope, intercept, r_value, p_value, std_err = stats.linregress(
+                vec1[pops == i], vec2[pops == i]
+            )
+            print(f"pop {i}: slope={slope:.2f}, intercept={intercept:.2f}")
+            ax.plot(xs, slope * xs + intercept, color=colors[i], zorder=-1)
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+def all_scatter_linreg(
+    vecs,
+    pops,
+    xlabel="",
+    ylabel="",
+    n_pops=None,
+    linreg=False,
+    colors=("blue", "green", "red", "violet", "gray"),
+):
+    fig, ax = plt.subplots(len(vecs), len(vecs), figsize=(6, 8))
+    if n_pops is None:
+        n_pops = np.unique(pops).shape[0]
+    for k in range(len(vecs)):
+        for l in range(len(vecs)):
+            if k is not l:
+                for i in range(n_pops):
+                    ax[k, l].scatter(vecs[k][pops == i], vecs[l][pops == i], color=colors[i])
+                    if linreg:
+                        slope, intercept, r_value, p_value, std_err = stats.linregress(
+                            vecs[k][pops == i], vecs[l][pops == i]
+                        )
+                        print(f"pop {i}: slope={slope:.2f}, intercept={intercept:.2f}")
+                        xs = vecs[k][pops == i]
+                        plt.plot(xs, slope * xs + intercept, color=colors[i])
+
+    return ax
+
+
+### Spectral clustering and stability analysis
+
+
+def generate_subsamples(neurons_fs, fraction=0.8):
+    indexes = np.random.choice(
+        neurons_fs.shape[0], int(fraction * neurons_fs.shape[0]), replace=False
+    )
+    indexes = np.sort(indexes)
+    return neurons_fs[indexes], indexes
+
+
+def spectral_clustering(neurons_fs, n_clusters, metric="euclidean", n_neighbors=10):
+    if metric == "euclidean":
+        model = SpectralClustering(n_clusters, affinity="nearest_neighbors")
+        model.fit(neurons_fs)
+    elif metric == "cosine":
+        model = SpectralClustering(n_clusters, affinity="precomputed")
+        nn = NearestNeighbors(n_neighbors=n_neighbors, algorithm="brute", metric="cosine")
+        nn.fit(neurons_fs)
+        knn_graph = nn.kneighbors_graph()
+        knn_graph = 0.5 * (knn_graph + knn_graph.transpose())
+        model.fit(knn_graph)
+    return model
+
+
+def clustering_stability_task(
+    neurons_fs, algo, n_clusters, metric, n_neighbors, mean_precision_prior=1e5
+):
+    sample, indexes = generate_subsamples(neurons_fs)
+    if algo == "spectral":
+        model = spectral_clustering(sample, n_clusters, metric, n_neighbors)
+        labels = model.labels_
+    else:
+        labels, _ = gmm_fit(
+            sample,
+            n_clusters,
+            mean_precision_prior=mean_precision_prior,
+            weight_concentration_prior_type="dirichlet_distribution",
+        )
+    return labels, indexes
+
+
+def clustering_stability(
+    neurons_fs,
+    n_clusters,
+    n_bootstrap,
+    algo="gmm",
+    metric="cosine",
+    n_neighbors=10,
+    mean_precision_prior=1e5,
+    normalize=None,
+):
+    """
+    :param neurons_fs: numpy array of shape Nxd (neurons embedded in some feature space)
+    :param n_clusters: int
+    :param n_bootstrap: int
+    :param algo: 'spectral' or 'gmm'
+    :param metric: 'euclidean' or 'cosine' for spectral clustering
+    :param n_neighbors: int, for spectral clustering
+    :param mean_precision_prior:
+    :param normalize: None, 'normal' or 'uniform'
+    :return: list of n_bootstrap x (n_bootstrap - 1) / 2 ARI values for bootstrapped clusterings (possibly normalized)
+    """
+
+    with mp.Pool(mp.cpu_count()) as pool:
+        args = repeat(
+            (neurons_fs, algo, n_clusters, metric, n_neighbors, mean_precision_prior), n_bootstrap
+        )
+        res = pool.starmap(clustering_stability_task, args)
+        labels_list, indexings = zip(*res)
+
+    aris = []
+    # Align bootstrap samples and compute pairwise Rand indexes
+    for i in range(n_bootstrap):
+        for j in range(i + 1, n_bootstrap):
+            # build aligned labellings
+            indexes_i = indexings[i]
+            indexes_j = indexings[j]
+            labels_i = []
+            labels_j = []
+            l = 0
+            for k in range(len(indexes_i)):
+                if l > len(indexes_j):
+                    break
+                while l < len(indexes_j) and indexes_j[l] < indexes_i[k]:
+                    l += 1
+                if l < len(indexes_j) and indexes_j[l] == indexes_i[k]:
+                    labels_i.append(labels_list[i][k])
+                    labels_j.append(labels_list[j][l])
+                    l += 1
+            aris.append(adjusted_rand_score(labels_i, labels_j))
+
+    if normalize is not None:
+        if normalize == "normal":
+            X_base = np.random.randn(neurons_fs.shape[0], neurons_fs.shape[1])
+        elif normalize == "uniform":
+            X_base = (np.random.rand(neurons_fs.shape[0], neurons_fs.shape[1]) - 0.5) * 2
+        base_aris = clustering_stability(X_base, n_clusters, n_bootstrap, metric, normalize=None)
+        base_mean, base_std = np.mean(base_aris), np.std(base_aris)
+        aris = [(ari - base_mean) / base_std for ari in aris]
+    return aris
+
+
+def boxplot_clustering_stability(
+    neurons_fs,
+    clusters_nums,
+    aris=None,
+    algo="gmm",
+    n_bootstrap=20,
+    metric="cosine",
+    n_neighbors=10,
+    ax=None,
+):
+    if aris is None:
+        aris = [
+            clustering_stability(neurons_fs, k, n_bootstrap, algo, metric, n_neighbors)
+            for k in clusters_nums
+        ]
+    aris = np.array(aris)
+    if ax is None:
+        fig, ax = plt.subplots()
+    col_lines = "indianred"
+    bp = ax.boxplot(aris.T, patch_artist=True)
+    for box in bp["boxes"]:
+        box.set(color="steelblue", facecolor="steelblue")
+    for med in bp["medians"]:
+        med.set(color=col_lines)
+    for l in bp["whiskers"]:
+        l.set(color=col_lines)
+    for l in bp["caps"]:
+        l.set(color=col_lines)
+    ax.set_xticks(list(range(1, aris.shape[0] + 1)))
+    ax.set_xticklabels(clusters_nums)
+    ax.set(xlabel="number of clusters", ylabel="stability", ylim=(-0.1, 1.1))
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    return ax

data/examples/RNN/RNN_scripts/dms.py

@@ -0,0 +1,270 @@
+"""RNN dms (delayed-match-to-sample)."""
+from math import floor
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+
+from .modules import loss_mse
+from .ranktwo import plot_field, plot_field_noscalings
+
+# task constants
+deltaT = 20.0
+tau = 100
+alpha = deltaT / tau
+std_default = 3e-2
+
+fixation_duration_min = 100
+fixation_duration_max = 500
+stimulus1_duration_min = 500
+stimulus1_duration_max = 500
+delay_duration_min = 500
+delay_duration_max = 3000
+stimulus2_duration_min = 500
+stimulus2_duration_max = 500
+decision_duration = 1000
+
+# Defining some global variables, whoses values can also be set in setup
+min_fixation_duration_discrete = floor(fixation_duration_min / deltaT)
+max_fixation_duration_discrete = floor(fixation_duration_max / deltaT)
+min_stimulus1_duration_discrete = floor(stimulus1_duration_min / deltaT)
+max_stimulus1_duration_discrete = floor(stimulus1_duration_max / deltaT)
+min_stimulus2_duration_discrete = floor(stimulus2_duration_min / deltaT)
+max_stimulus2_duration_discrete = floor(stimulus2_duration_max / deltaT)
+decision_duration_discrete = floor(decision_duration / deltaT)
+min_delay_duration_discrete = floor(delay_duration_min / deltaT)
+max_delay_duration_discrete = floor(delay_duration_max / deltaT)
+total_duration = (
+    max_fixation_duration_discrete
+    + max_stimulus1_duration_discrete
+    + max_delay_duration_discrete
+    + max_stimulus2_duration_discrete
+    + decision_duration_discrete
+)
+
+
+def setup():
+    global min_fixation_duration_discrete
+    global max_fixation_duration_discrete
+    global min_stimulus1_duration_discrete
+    global max_stimulus1_duration_discrete
+    global min_stimulus2_duration_discrete
+    global max_stimulus2_duration_discrete
+    global decision_duration_discrete
+    global min_delay_duration_discrete
+    global max_delay_duration_discrete
+    global total_duration
+    min_fixation_duration_discrete = floor(fixation_duration_min / deltaT)
+    max_fixation_duration_discrete = floor(fixation_duration_max / deltaT)
+    min_stimulus1_duration_discrete = floor(stimulus1_duration_min / deltaT)
+    max_stimulus1_duration_discrete = floor(stimulus1_duration_max / deltaT)
+    min_stimulus2_duration_discrete = floor(stimulus2_duration_min / deltaT)
+    max_stimulus2_duration_discrete = floor(stimulus2_duration_max / deltaT)
+    decision_duration_discrete = floor(decision_duration / deltaT)
+    min_delay_duration_discrete = floor(delay_duration_min / deltaT)
+    max_delay_duration_discrete = floor(delay_duration_max / deltaT)
+
+    total_duration = (
+        max_fixation_duration_discrete
+        + max_stimulus1_duration_discrete
+        + max_delay_duration_discrete
+        + max_stimulus2_duration_discrete
+        + decision_duration_discrete
+    )
+
+
+def generate_dms_data(
+    num_trials,
+    type=None,
+    gain=1.0,
+    fraction_validation_trials=0.2,
+    fraction_catch_trials=0.0,
+    std=std_default,
+):
+    x = std * torch.randn(num_trials, total_duration, 2)
+    y = torch.zeros(num_trials, total_duration, 1)
+    mask = torch.zeros(num_trials, total_duration, 1)
+
+    types = ["A-A", "A-B", "B-A", "B-B"]
+    for i in range(num_trials):
+        if np.random.rand() > fraction_catch_trials:
+            if type is None:
+                cur_type = types[int(np.random.rand() * 4)]
+            else:
+                cur_type = type
+
+            if cur_type == "A-A":
+                input1 = gain
+                input2 = gain
+                choice = 1
+            elif cur_type == "A-B":
+                input1 = gain
+                input2 = 0
+                choice = -1
+            elif cur_type == "B-A":
+                input1 = 0
+                input2 = gain
+                choice = -1
+            elif cur_type == "B-B":
+                input1 = 0
+                input2 = 0
+                choice = 1
+
+            # Sample durations
+            delay_duration = np.random.uniform(delay_duration_min, delay_duration_max)
+            delay_duration_discrete = floor(delay_duration / deltaT)
+            fixation_duration = np.random.uniform(
+                min_fixation_duration_discrete, max_fixation_duration_discrete
+            )
+            fixation_duration_discrete = floor(fixation_duration / deltaT)
+            stimulus1_duration = np.random.uniform(stimulus1_duration_min, stimulus1_duration_max)
+            stimulus1_duration_discrete = floor(stimulus1_duration / deltaT)
+            stimulus2_duration = np.random.uniform(stimulus2_duration_min, stimulus2_duration_max)
+            stimulus2_duration_discrete = floor(stimulus2_duration / deltaT)
+            decision_time_discrete = (
+                fixation_duration_discrete
+                + stimulus1_duration_discrete
+                + delay_duration_discrete
+                + stimulus2_duration_discrete
+            )
+            stim1_begin = fixation_duration_discrete
+            stim1_end = stim1_begin + stimulus1_duration_discrete
+            stim2_begin = stim1_end + delay_duration_discrete
+            stim2_end = stim2_begin + stimulus2_duration_discrete
+
+            x[i, stim1_begin:stim1_end, 0] += input1
+            x[i, stim1_begin:stim1_end, 1] += 1 - input1
+            x[i, stim2_begin:stim2_end, 0] += input2
+            x[i, stim2_begin:stim2_end, 1] += 1 - input2
+            y[
+                i, decision_time_discrete : decision_time_discrete + decision_duration_discrete
+            ] = choice
+            mask[
+                i, decision_time_discrete : decision_time_discrete + decision_duration_discrete
+            ] = 1
+
+    # Split
+    split_at = x.shape[0] - floor(x.shape[0] * fraction_validation_trials)
+    (x_train, x_val) = x[:split_at], x[split_at:]
+    (y_train, y_val) = y[:split_at], y[split_at:]
+    (mask_train, mask_val) = mask[:split_at], mask[split_at:]
+
+    return x_train, y_train, mask_train, x_val, y_val, mask_val
+
+
+def accuracy_dms(output, targets, mask):
+    good_trials = (targets != 0).any(dim=1).squeeze()  # eliminates catch trials
+    mask_bool = mask[good_trials, :, 0] == 1
+    targets_filtered = torch.stack(
+        targets[good_trials].squeeze()[mask_bool].chunk(good_trials.sum())
+    )
+    target_decisions = torch.sign(targets_filtered.mean(dim=1))
+    decisions_filtered = torch.stack(
+        output[good_trials].squeeze()[mask_bool].chunk(good_trials.sum())
+    )
+    decisions = torch.sign(decisions_filtered.mean(dim=1))
+    return (target_decisions == decisions).type(torch.float32).mean()
+
+
+def map_device(tensors, net):
+    """
+    Maps a list of tensors to the device used by the network net
+    :param tensors: list of tensors
+    :param net: nn.Module
+    :return: list of tensors
+    """
+    if net.wi.device != torch.device("cpu"):
+        new_tensors = []
+        for tensor in tensors:
+            new_tensors.append(tensor.to(device=net.wi.device))
+        return new_tensors
+    else:
+        return tensors
+
+
+def test_dms(net, x, y, mask):
+    x, y, mask = map_device([x, y, mask], net)
+    with torch.no_grad():
+        output, _ = net(x)
+        loss = loss_mse(output, y, mask).item()
+        acc = accuracy_dms(output, y, mask).item()
+    return loss, acc
+
+
+def confusion_matrix(net):
+    matrix = np.zeros((4, 2))
+    rows = ["A-A", "B-B", "A-B", "B-A"]
+    for i, type in enumerate(rows):
+        x, y, mask, _, _, _ = generate_dms_data(100, type=type, fraction_validation_trials=0.0)
+        x, y, mask = map_device([x, y, mask], net)
+        output, _ = net(x)
+        mask_bool = mask[:, :, 0] == 1
+        decisions_filtered = torch.stack(output.squeeze()[mask_bool].chunk(output.shape[0]))
+        decisions = torch.sign(decisions_filtered.mean(dim=1))
+        matrix[i, 0] = (decisions < 0).sum().type(torch.float) / decisions.shape[0]
+        matrix[i, 1] = (decisions >= 0).sum().type(torch.float) / decisions.shape[0]
+    cols = ["different", "same"]
+    print("{:^12s}|{:^12s}|{:^12s}".format(" ", cols[0], cols[1]))
+    print("-" * 40)
+    for i, row in enumerate(rows):
+        print("{:^12s}|{:^12.2f}|{:^12.2f}".format(row, matrix[i, 0], matrix[i, 1]))
+        print("-" * 40)
+
+
+def plot_trajectories(net, trajectories, ax, n_traj=2, style="-", c="C0", interval=[None, None]):
+
+    m1 = net.m[:, 0].detach().numpy()
+    m2 = net.m[:, 1].detach().numpy()
+
+    for j in range(n_traj):
+        proj1 = trajectories[j] @ m1 / net.hidden_size
+        proj2 = trajectories[j] @ m2 / net.hidden_size
+
+        if interval[1] != 0:
+            ax.plot(proj1[: interval[0]], proj2[: interval[0]], c=c, lw=4, linestyle=style)
+
+
+def remove_axes(ax):
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.spines["bottom"].set_visible(False)
+    ax.spines["left"].set_visible(False)
+    ax.set(xticks=[], yticks=[])
+
+
+def _plot_field(net, input, ax, sizes=1.0, rect=(-5, 5, -4, 4), scalings=False):
+
+    m1 = net.m[:, 0].detach().numpy()
+    m2 = net.m[:, 1].detach().numpy()
+
+    xmin, xmax, ymin, ymax = rect
+
+    if scalings:
+        plot_field(net, m1, m2, xmin, xmax, ymin, ymax, input=input, ax=ax, sizes=sizes)
+    else:
+        plot_field_noscalings(net, m1, m2, xmin, xmax, ymin, ymax, input=input, ax=ax, sizes=sizes)
+
+    remove_axes(ax)
+
+
+def psychometric_matrix(net, n_trials=10, ax=None):
+    if ax is None:
+        fig, ax = plt.subplots()
+    stim1_begin = max_fixation_duration_discrete
+    stim1_end = max_fixation_duration_discrete + max_stimulus1_duration_discrete
+    stim2_begin = stim1_end + max_delay_duration_discrete
+    stim2_end = stim2_begin + max_stimulus2_duration_discrete
+    decision_end = stim2_end + decision_duration_discrete
+    mean_outputs = np.zeros((2, 2))
+    for inp1 in range(2):
+        for inp2 in range(2):
+            input = torch.zeros(n_trials, decision_end, 2)
+            input[:, stim1_begin:stim1_end, inp1] = 1
+            input[:, stim2_begin:stim2_end, inp2] = 1
+            output = net(input)
+            output = output.squeeze().detach().numpy()
+            mean_output = output[:, stim2_end:decision_end].mean()
+            mean_outputs[inp1, inp2] = mean_output
+    image = ax.matshow(mean_outputs, cmap="gray", vmin=-1, vmax=1)
+    ax.set_xticks([])
+    ax.set_yticks([])
+    return image

data/examples/RNN/RNN_scripts/helpers.py

@@ -0,0 +1,507 @@
+import torch
+import pickle
+import os
+import numpy as np
+from sklearn.decomposition import PCA
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+from matplotlib.patches import Ellipse
+import seaborn as sns
+
+from . import clustering
+from . import modules
+from . import dms
+
+
+def load_network(f):
+    """Load RNN network."""
+    noise_std = 5e-2
+    alpha = 0.2
+    hidden_size = 500
+
+    load = torch.load(f, map_location="cpu")
+
+    if len(load) == 2:
+        z, state = load
+    else:
+        state = load
+        z = None
+
+    net = modules.LowRankRNN(2, hidden_size, 1, noise_std, alpha, rank=2)
+    net.load_state_dict(state)
+    net.svd_reparametrization()
+
+    return z, net
+
+
+def sample_network(net, f, seed=0):
+    
+    if os.path.exists(f):
+        print('Network found with same name. Loading...')
+        return torch.load(open(f, "rb"))
+
+    n_pops = 2
+    z, _ = clustering.gmm_fit(net, n_pops, algo="bayes", random_state=seed)
+    net_sampled = clustering.to_support_net(net, z)
+
+    if os.path.exists(f):
+        z, state = torch.load(f)
+        net_sampled.load_state_dict(state)
+    else:
+        x_train, y_train, mask_train, x_val, y_val, mask_val = dms.generate_dms_data(1000)
+        modules.train(
+            net_sampled,
+            x_train,
+            y_train,
+            mask_train,
+            20,
+            lr=1e-6,
+            resample=True,
+            keep_best=True,
+            clip_gradient=1,
+        )
+        torch.save([z, net_sampled], f)
+
+    return z, net_sampled
+
+
+def generate_trajectories(
+    net, input=None, epochs=None, n_traj=None, fname="./data/RNN_trajectories.pkl"
+):
+
+    if fname is not None:
+        if os.path.exists(fname):
+            print('Trajectory file found with same name. Loading...')
+            return pickle.load(open(fname, "rb"))
+
+    traj = []
+    for i in range(len(input)):
+        conds = []
+        for _ in range(n_traj):
+            _, traj_ = net(input[i].unsqueeze(0))
+            traj_ = traj_.squeeze().detach().numpy()
+            traj_epoch = [traj_[e : epochs[j + 1]] for j, e in enumerate(epochs[:-1])]
+            conds.append(traj_epoch)
+
+        traj.append(conds)
+
+    pickle.dump(traj, open(fname, "wb"))
+
+    return traj
+
+
+def load_trajectories(fname):
+    return pickle.load(open(fname, "rb"))
+
+
+def plot_ellipse(ax, w, color="silver", std_factor=1):
+    X = np.array([w[:, 0], w[:, 1]]).T
+    cov = X.T @ X / X.shape[0]
+    eigvals, eigvecs = np.linalg.eig(cov)
+    v1 = eigvecs[:, 0]
+    angle = np.arctan(v1[1] / v1[0])
+    angle = angle * 180 / np.pi
+    ax.add_artist(
+        Ellipse(
+            xy=[0, 0],
+            angle=angle,
+            width=np.sqrt(eigvals[0]) * 2 * std_factor,
+            height=np.sqrt(eigvals[1]) * 2 * std_factor,
+            fill=True,
+            fc=color,
+            ec=color,
+            lw=1,
+            alpha=0.4,
+        )
+    )
+
+    return ax
+
+
+def plot_coefficients(net, z=None):
+    if z is None:
+        n_pops = 2
+        z, _ = clustering.gmm_fit(net, n_pops, algo="bayes", random_state=0)
+
+    m1 = net.m[:, 0].detach().numpy()
+    n1 = net.n[:, 0].detach().numpy()
+    m2 = net.m[:, 1].detach().numpy()
+    n2 = net.n[:, 1].detach().numpy()
+    wi1 = net.wi[0].detach().numpy()
+    wi2 = net.wi[1].detach().numpy()
+
+    fig, ax = plt.subplots(1, 4, figsize=(12, 2))
+
+    colors = ["#364285", "#E5BA52"]
+    n_pops = 2
+    clustering.pop_scatter_linreg(wi1, wi2, z, n_pops, colors=colors, ax=ax[0])
+    plot_ellipse(
+        ax[0], np.array([wi1[z.astype(bool)], wi2[z.astype(bool)]]).T, std_factor=3, color=colors[1]
+    )
+    plot_ellipse(
+        ax[0],
+        np.array([wi1[~z.astype(bool)], wi2[~z.astype(bool)]]).T,
+        std_factor=3,
+        color=colors[0],
+    )
+
+    clustering.pop_scatter_linreg(m1, m2, z, n_pops, colors=colors, ax=ax[1])
+    clustering.pop_scatter_linreg(n1, n2, z, n_pops, colors=colors, ax=ax[2])
+    clustering.pop_scatter_linreg(m1, n1, z, n_pops, colors=colors, ax=ax[3])
+
+
+def setup_matplotlib():
+    plt.rcParams["axes.titlesize"] = 24
+    plt.rcParams["axes.labelsize"] = 19
+    plt.rcParams["xtick.labelsize"] = 16
+    plt.rcParams["ytick.labelsize"] = 16
+    plt.rcParams["figure.figsize"] = (6, 4)
+    plt.rcParams["axes.titlepad"] = 24
+    plt.rcParams["axes.labelpad"] = 10
+    plt.rcParams["axes.spines.top"] = False
+    plt.rcParams["axes.spines.right"] = False
+    plt.rcParams["font.size"] = 14
+
+
+def get_lower_tri_heatmap(
+    ov, bounds=None, figsize=None, cbar=False, cbar_shrink=0.9, cbar_pad=0.3, ax=None
+):
+    mask = np.zeros_like(ov, dtype=np.bool)
+    mask[np.triu_indices_from(mask)] = True
+    ov[np.diag_indices_from(ov)] = 0
+    # mask[np.diag_indices_from(mask)] = False
+    mask = mask.T
+    print(mask)
+    if figsize is None:
+        figsize = matplotlib.rcParams["figure.figsize"]
+
+    if bounds is None:
+        bound = np.max((np.abs(np.min(ov)), np.abs(np.max(ov))))
+        bounds = [-bound, bound]
+
+    # Set up the matplotlib figure
+    if ax is None:
+        f, ax = plt.subplots(figsize=figsize)
+
+    # Generate a custom diverging colormap
+    cmap = sns.diverging_palette(220, 10, sep=10, as_cmap=True)
+    print(ov)
+    # Draw the heatmap with the mask and correct aspect ratio
+    if not cbar:
+        mesh = sns.heatmap(
+            ov[:-1, 1:],
+            mask=mask[:-1, 1:],
+            cmap=cmap,
+            center=0,
+            square=True,
+            linewidths=0.5,
+            cbar=False,
+            vmin=bounds[0],
+            vmax=bounds[1],
+            ax=ax,
+        )
+    else:
+        mesh = sns.heatmap(
+            ov[:-1, 1:],
+            mask=mask[:-1, 1:],
+            cmap=cmap,
+            center=0,
+            square=True,
+            linewidths=0.5,
+            cbar=True,
+            vmin=bounds[0],
+            vmax=bounds[1],
+            ax=ax,
+            cbar_kws={"shrink": cbar_shrink, "ticks": ticker.MaxNLocator(3), "pad": cbar_pad},
+        )
+    ax.xaxis.tick_top()
+    ax.yaxis.tick_right()
+    return ax, mesh
+
+
+def set_size(size, ax=None):
+    """to force the size of the plot, not of the overall figure, from
+    https://stackoverflow.com/questions/44970010/axes-class-set-explicitly-size-width-height-of-axes-in-given-units"""
+    if not ax:
+        ax = plt.gca()
+    l = ax.figure.subplotpars.left
+    r = ax.figure.subplotpars.right
+    t = ax.figure.subplotpars.top
+    b = ax.figure.subplotpars.bottom
+    w, h = size
+    figw = float(w) / (r - l)
+    figh = float(h) / (t - b)
+    ax.figure.set_size_inches(figw, figh)
+
+
+def center_limits(ax):
+    xmin, xmax = ax.get_xlim()
+    xbound = max(-xmin, xmax)
+    ax.set_xlim(-xbound, xbound)
+    ymin, ymax = ax.get_ylim()
+    ybound = max(-ymin, ymax)
+    ax.set_ylim(-ybound, ybound)
+
+
+def plot_all_scatters(vectors):
+    fig, ax = plt.subplots(len(vectors), len(vectors), figsize=(6, 8))
+    for i in range(len(vectors)):
+        for j in range(len(vectors)):
+            if i is not j:
+                ax[i, j].scatter(vectors[i], vectors[j])
+    return ax
+
+
+def plot_rates_single_neurons(rates, offset=1, colors=None, deltaT=1.0, figsize=(6, 8), ax=None):
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+    cur_max = 0.0
+    for i in range(rates.shape[1]):
+        color = colors[i] if colors is not None else "red"
+        ax.plot(
+            np.arange(rates.shape[0]) * deltaT / 1000,
+            rates[:, i] + cur_max + offset - np.min(rates[:, i]),
+            color=color,
+        )
+        cur_max = cur_max + offset - np.min(rates[:, i]) + np.max(rates[:, i])
+    return ax
+
+
+def bar_plots_vectors(n, wi, wi_ctx1, wi_ctx2, title, xticks):
+    fig, ax = plt.subplots()
+    x = np.arange(3)
+    ctx_derivative1 = phi_prime(wi_ctx1)
+    ctx_derivative2 = phi_prime(wi_ctx2)
+    win = wi
+    Nfull = n.shape[0]
+    neff_ctx1 = n.reshape(Nfull, 1) * ctx_derivative1.reshape(Nfull, 1)
+    neff_ctx2 = n.reshape(Nfull, 1) * ctx_derivative2.reshape(Nfull, 1)
+    ov1 = np.sum(n.reshape(Nfull, 1) * win.reshape(Nfull, 1))
+    ov2 = np.sum(neff_ctx1.reshape(Nfull, 1) * win.reshape(Nfull, 1))
+    ov3 = np.sum(neff_ctx2.reshape(Nfull, 1) * win.reshape(Nfull, 1))
+    y = [ov1, ov2, ov3]
+    ax.bar(x, y)
+    plt.ylabel(title, fontsize=30)
+    plt.xticks(x, xticks, fontsize=25)
+    return ax
+
+
+def radial_distribution_plot(x, N=80, bottom=0.1, cmap_scale=0.05, points=True):
+    """
+    Plot a radial histogram of angles
+    :param x: if points=True, an array of shape nx2 of points in 2d space. if points=False a series of angles
+    :param N: num bins
+    :param bottom: radius of base circle
+    :param cmap_scale: to adjust the colormap
+    :param points: see x
+    :return:
+    """
+    if points:
+        assert len(x.shape) == 2 and x.shape[1] == 2
+        x_cplx = np.array(x[:, 0], dtype=np.complex64)
+        x_cplx.imag = x[:, 1]
+        angles = np.angle(x_cplx)
+    else:
+        angles = x
+    angles = angles % (2 * np.pi)
+    theta = np.linspace(0.0, 2 * np.pi, N, endpoint=False)
+    radii = [
+        np.mean(np.logical_and(angles > theta[i], angles < theta[i + 1]))
+        for i in range(len(theta) - 1)
+    ]
+    radii.append(np.mean(angles > theta[-1]))
+    width = (2 * np.pi) / N
+    offset = np.pi / N
+    ax = plt.subplot(111, polar=True)
+    bars = ax.bar(theta + offset, radii, width=width, bottom=bottom)
+    for r, bar in zip(radii, bars):
+        bar.set_facecolor(plt.cm.jet(r / cmap_scale))
+        bar.set_alpha(0.8)
+    plt.yticks([])
+
+
+def dimensionality_plot(trajectories, vecs, labels, figsize=None):
+    """
+    plot cumulative percentage of variance explained by vectors vecs, while ordering with most explicative vectors first
+    :param trajectories: numpy array of shape #time_points x #neurons (with trials already flattened)
+    :param vecs: list of numpy arrays of shape #neurons
+    :param labels: labels associated with each vector
+    :param figsize:
+    :return: axes
+    """
+    total_var = np.sum(np.var(trajectories, axis=0))
+    print(total_var)
+
+    vars_nonorth = []
+    for v in vecs:
+        proj = trajectories @ v / np.linalg.norm(v)
+        vars_nonorth.append(np.var(proj))
+    indices = np.argsort(vars_nonorth)
+
+    vecs_ordered = [vecs[i] for i in indices[::-1]]
+    labels_ordered = [labels[i] for i in indices[::-1]]
+    vecs_orth = gram_schmidt(vecs_ordered)
+    variances = []
+    for v in vecs_orth:
+        proj = trajectories @ v / np.linalg.norm(v)
+        variances.append(np.var(proj))
+    print(variances)
+    cumvar = np.cumsum(variances).tolist()
+    print(cumvar)
+
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.bar(
+        range(1, len(variances) + 1), cumvar / total_var * 100, color="lightslategray", alpha=0.5
+    )
+    ax.axhline(100, c="r")
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.set(xticks=range(1, len(variances) + 1), xticklabels=labels_ordered, yticks=[0, 100])
+    return ax
+
+
+def phi_prime(x):
+    return 1 - np.tanh(x) ** 2
+
+
+def overlap_matrix(vectors):
+    hidden_size = len(vectors[0])
+    ov = np.zeros((len(vectors), len(vectors)))
+    for i in range(len(vectors)):
+        for j in range(i, len(vectors)):
+            ov[i, j] = 1 / hidden_size * np.sum(vectors[i] * vectors[j])
+    return ov
+
+
+def boxplot_accuracies(accs, figsize=None, labels=None):
+    fig, ax = plt.subplots(1, 1, figsize=figsize)
+    for i, acc in enumerate(accs):
+        if not isinstance(acc, list):
+            plt.scatter(i, acc, marker="*", s=90, c="k")
+        else:
+            bp = ax.boxplot(acc, positions=[i], widths=0.5)
+            ax.scatter([i] * len(acc), acc, c="gray", alpha=0.5, s=5)
+            [l.set_linewidth(2) for l in bp["medians"]]
+    ax.set_xlim(-0.5, len(accs) - 0.5)
+    ax.set_ylim(0, 1.1)
+    ax.set_xticks(list(range(len(accs))))
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.set_xticklabels(labels, rotation=45)
+    ax.set_yticks([0.0, 0.25, 0.5, 0.75, 1.0])
+    ax.set_ylabel("accuracy")
+    ax.axhline(1, c="k", zorder=-10, lw=1, ls="--")
+    return ax
+
+
+def gram_schmidt(vecs):
+    vecs_orth = []
+    vecs_orth.append(vecs[0] / np.linalg.norm(vecs[0]))
+    for i in range(1, len(vecs)):
+        v = vecs[i]
+        for j in range(i):
+            v = v - (v @ vecs_orth[j]) * vecs_orth[j]
+        v = v / np.linalg.norm(v)
+        vecs_orth.append(v)
+    return vecs_orth
+
+
+def gram_factorization(G):
+    """
+    The rows of the returned matrix are the basis vectors whose Gramian matrix is G
+    :param G: ndarray representing a symmetric semidefinite positive matrix
+    :return: ndarray
+    """
+    w, v = np.linalg.eigh(G)
+    x = v * np.sqrt(w)
+    return x
+
+
+def angle(v, w, deg=True):
+    res = np.arccos((v @ w) / (np.linalg.norm(v) * np.linalg.norm(w)))
+    if not deg:
+        return res
+    else:
+        return res * 180 / np.pi
+
+
+def plot_experiment(net, input, traj, epochs, rect=(-8, 8, -6, 6), traj_to_show=1):
+    fig, ax = plt.subplots(4, 5, figsize=(25, 20))
+    idx = np.floor(np.linspace(0, len(input) - 1, 4))
+    for i in range(4):
+        for j, e in enumerate(epochs[:-1]):
+            dms._plot_field(net, input[int(idx[i]), e], ax[i][j], rect=rect, sizes=1.3)
+            epoch = [c[j] for c in traj[i]]
+            dms.plot_trajectories(net, epoch, ax[i][j], c="#C30021", n_traj=traj_to_show)
+            if j > 0:
+                epoch = [c[j - 1] for c in traj[i]]
+                dms.plot_trajectories(
+                    net, epoch, ax[i][j], c="#C30021", style="--", n_traj=traj_to_show
+                )
+
+    ax[0][0].set_title("Fix")
+    ax[0][1].set_title("Stim 1")
+    ax[0][2].set_title("Delay")
+    ax[0][3].set_title("Stim 2")
+    ax[0][4].set_title("Decision")
+
+    for i in range(4):
+        ax[i][0].set_ylabel(r"$\kappa_2$")
+    for i in range(5):
+        ax[3][i].set_xlabel(r"$\kappa_1$")
+
+    fig.subplots_adjust(hspace=0.1, wspace=0.1)
+
+
+def aggregate_data(traj, epochs, transient=10, only_stim=False, pca=True, n_pca=3):
+
+    n_conds = len(traj)
+    n_epochs = len(epochs) - 1
+    n_traj = len(traj[0])
+
+    # fit PCA to all data
+    pos = []
+    for i in range(n_conds):  # conditions
+        for k in range(n_epochs):
+            for j in range(n_traj):  # trajectories
+                pos.append(traj[i][j][k][transient:])
+
+    if pca:
+        pca = PCA(n_components=n_pca)
+        pca.fit(np.vstack(pos))
+        print("Explained variance: ", pca.explained_variance_ratio_)
+
+    # aggregate data under baseline condition (no input)
+    pos, vel = [], []
+    if not only_stim:
+        for i in range(n_conds):  # conditions
+            pos_, vel_ = [], []
+            for k in [0, 2, 4]:
+                for j in range(n_traj):  # trajectories
+                    pos_proj = traj[i][j][k][transient:]
+                    if pca:
+                        pos_proj = pca.transform(pos_proj)
+                    pos_.append(pos_proj[:-1])  # stack trajectories
+                    vel_.append(np.diff(pos_proj, axis=0))  # compute differences
+
+            pos_, vel_ = np.vstack(pos_), np.vstack(vel_)  # stack trajectories
+            pos.append(pos_)
+            vel.append(vel_)
+
+    # aggregate data under stimulated condition
+    for i in range(n_conds):  # conditions
+        pos_, vel_ = [], []
+        for k in [1, 3]:
+            for j in range(n_traj):  # trajectories
+                pos_proj = traj[i][j][k][transient:]
+                if pca:
+                    pos_proj = pca.transform(pos_proj)
+                pos_.append(pos_proj[:-1])
+                vel_.append(np.diff(pos_proj, axis=0))
+
+        pos_, vel_ = np.vstack(pos_), np.vstack(vel_)  # stack trajectories
+        pos.append(pos_)
+        vel.append(vel_)
+
+    return pos, vel

data/examples/RNN/RNN_scripts/modules.py

@@ -0,0 +1,1273 @@
+"""RNN definition of network classes, training functionality."""
+import torch.nn as nn
+from math import sqrt, floor
+import random
+import time
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def gram_schmidt_pt(mat):
+    """
+    Performs INPLACE Gram-Schmidt
+    :param mat:
+    :return:
+    """
+    mat[0] = mat[0] / torch.norm(mat[0])
+    for i in range(1, mat.shape[0]):
+        mat[i] = mat[i] - (mat[:i].t() @ mat[:i] @ mat[i])
+        mat[i] = mat[i] / torch.norm(mat[i])
+
+
+def loss_mse(output, target, mask):
+    """
+    Mean squared error loss
+    :param output: torch tensor of shape (num_trials, num_timesteps, output_dim)
+    :param target: torch tensor of shape (num_trials, num_timesteps, output_dim)
+    :param mask: torch tensor of shape (num_trials, num_timesteps, 1)
+    :return: float
+    """
+    # Compute loss for each (trial, timestep) (average accross output dimensions)
+    loss_tensor = (mask * (target - output)).pow(2).mean(dim=-1)
+    # Account for different number of masked values per trial
+    loss_by_trial = loss_tensor.sum(dim=-1) / mask[:, :, 0].sum(dim=-1)
+    return loss_by_trial.mean()
+
+
+def train(
+    net,
+    _input,
+    _target,
+    _mask,
+    n_epochs,
+    random_ic=False,
+    lr=1e-2,
+    batch_size=32,
+    plot_learning_curve=False,
+    plot_gradient=False,
+    mask_gradients=False,
+    clip_gradient=None,
+    early_stop=None,
+    keep_best=False,
+    cuda=False,
+    resample=False,
+):
+    """
+    Train a network
+    :param net: nn.Module
+    :param _input: torch tensor of shape (num_trials, num_timesteps, input_dim)
+    :param _target: torch tensor of shape (num_trials, num_timesteps, output_dim)
+    :param _mask: torch tensor of shape (num_trials, num_timesteps, 1)
+    :param n_epochs: int
+    :param lr: float, learning rate
+    :param batch_size: int
+    :param plot_learning_curve: bool
+    :param plot_gradient: bool
+    :param mask_gradients: bool, set to True if training the SupportLowRankRNN_withMask for reduced models
+    :param clip_gradient: None or float, if not None the value at which gradient norm is clipped
+    :param early_stop: None or float, set to target loss value after which to immediately stop if attained
+    :param keep_best: bool, if True, model with lower loss from training process will be kept (for this option, the
+        network has to implement a method clone())
+    :param resample: for SupportLowRankRNNs, set True
+    :return: nothing
+    """
+    print("Training...")
+    optimizer = torch.optim.Adam(net.parameters(), lr=lr)
+    num_examples = _input.shape[0]
+    all_losses = []
+    if plot_gradient:
+        gradient_norms = []
+
+    # CUDA management
+    if cuda:
+        if not torch.cuda.is_available():
+            print("Warning: CUDA not available on this machine, switching to CPU")
+            device = torch.device("cpu")
+        else:
+            device = torch.device("cuda")
+    else:
+        device = torch.device("cpu")
+    net.to(device=device)
+    input = _input.to(device=device)
+    target = _target.to(device=device)
+    mask = _mask.to(device=device)
+
+    # Initialize setup to keep best network
+    with torch.no_grad():
+        output, _ = net(input)
+        initial_loss = loss_mse(output, target, mask)
+        print("initial loss: %.3f" % (initial_loss.item()))
+        if keep_best:
+            best = net.clone()
+            best_loss = initial_loss.item()
+
+    if random_ic:
+        print("training with random initial conditions")
+
+    # Training loop
+    for epoch in range(n_epochs):
+        begin = time.time()
+        losses = []  # losses over the whole epoch
+        for i in range(num_examples // batch_size):
+            optimizer.zero_grad()
+            random_batch_idx = random.sample(range(num_examples), batch_size)
+            batch = input[random_batch_idx]
+
+            # set initial condition
+            if random_ic:
+                # norm = net.m.norm(dim=0)
+                h0 = torch.rand(net.hidden_size).to(device) * net.hidden_size / 300
+                net.h0.data = h0
+
+            output, _ = net(batch)
+            loss = loss_mse(output, target[random_batch_idx], mask[random_batch_idx])
+            losses.append(loss.item())
+            all_losses.append(loss.item())
+            loss.backward()
+            if mask_gradients:
+                net.m.grad = net.m.grad * net.m_mask
+                net.n.grad = net.n.grad * net.n_mask
+                net.wi.grad = net.wi.grad * net.wi_mask
+                net.wo.grad = net.wo.grad * net.wo_mask
+                net.unitn.grad = net.unitn.grad * net.unitn_mask
+                net.unitm.grad = net.unitm.grad * net.unitm_mask
+                net.unitwi.grad = net.unitwi.grad * net.unitwi_mask
+            if clip_gradient is not None:
+                torch.nn.utils.clip_grad_norm_(net.parameters(), clip_gradient)
+            if plot_gradient:
+                tot = 0
+                for param in [p for p in net.parameters() if p.requires_grad]:
+                    tot += (param.grad**2).sum()
+                gradient_norms.append(sqrt(tot))
+            optimizer.step()
+            # These 2 lines important to prevent memory leaks
+            loss.detach_()
+            output.detach_()
+            if resample:
+                net.resample_basis()
+        if keep_best and np.mean(losses) < best_loss:
+            best = net.clone()
+            best_loss = np.mean(losses)
+            print(
+                "epoch %d:  loss=%.3f  (took %.2f s) *"
+                % (epoch, np.mean(losses), time.time() - begin)
+            )
+        else:
+            print(
+                "epoch %d:  loss=%.3f  (took %.2f s)"
+                % (epoch, np.mean(losses), time.time() - begin)
+            )
+        if early_stop is not None and np.mean(losses) < early_stop:
+            break
+
+    if plot_learning_curve:
+        plt.plot(all_losses)
+        plt.title("Learning curve")
+        plt.show()
+
+    if plot_gradient:
+        plt.plot(gradient_norms)
+        plt.title("Gradient norm")
+        plt.show()
+
+    if keep_best:
+        net.load_state_dict(best.state_dict())
+
+
+class FullRankRNN(nn.Module):
+    def __init__(
+        self,
+        input_size,
+        hidden_size,
+        output_size,
+        noise_std,
+        alpha=0.2,
+        rho=1,
+        train_wi=False,
+        train_wo=False,
+        train_wrec=True,
+        train_h0=False,
+        wi_init=None,
+        wo_init=None,
+        wrec_init=None,
+        si_init=None,
+        so_init=None,
+    ):
+        """
+        :param input_size: int
+        :param hidden_size: int
+        :param output_size: int
+        :param noise_std: float
+        :param alpha: float, value of dt/tau
+        :param rho: float, std of gaussian distribution for initialization
+        :param train_wi: bool
+        :param train_wo: bool
+        :param train_wrec: bool
+        :param train_h0: bool
+        :param wi_init: torch tensor of shape (input_dim, hidden_size)
+        :param wo_init: torch tensor of shape (hidden_size, output_dim)
+        :param wrec_init: torch tensor of shape (hidden_size, hidden_size)
+        :param si_init: input scaling, torch tensor of shape (input_dim)
+        :param so_init: output scaling, torch tensor of shape (output_dim)
+        """
+        super(FullRankRNN, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.noise_std = noise_std
+        self.alpha = alpha
+        self.rho = rho
+        self.train_wi = train_wi
+        self.train_wo = train_wo
+        self.train_wrec = train_wrec
+        self.train_h0 = train_h0
+        self.non_linearity = torch.tanh
+
+        # Define parameters
+        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
+        self.si = nn.Parameter(torch.Tensor(input_size))
+        if train_wi:
+            self.si.requires_grad = False
+        else:
+            self.wi.requires_grad = False
+        self.wrec = nn.Parameter(torch.Tensor(hidden_size, hidden_size))
+        if not train_wrec:
+            self.wrec.requires_grad = False
+        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
+        self.so = nn.Parameter(torch.Tensor(output_size))
+        if train_wo:
+            self.so.requires_grad = False
+        if not train_wo:
+            self.wo.requires_grad = False
+        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
+        if not train_h0:
+            self.h0.requires_grad = False
+
+        # Initialize parameters
+        with torch.no_grad():
+            if wi_init is None:
+                self.wi.normal_()
+            else:
+                self.wi.copy_(wi_init)
+            if si_init is None:
+                self.si.set_(torch.ones_like(self.si))
+            else:
+                self.si.copy_(si_init)
+            if wrec_init is None:
+                self.wrec.normal_(std=rho / sqrt(hidden_size))
+            else:
+                self.wrec.copy_(wrec_init)
+            if wo_init is None:
+                self.wo.normal_(std=1 / hidden_size)
+            else:
+                self.wo.copy_(wo_init)
+            if so_init is None:
+                self.so.set_(torch.ones_like(self.so))
+            else:
+                self.so.copy_(so_init)
+            self.h0.zero_()
+        self.wi_full, self.wo_full = [None] * 2
+        self._define_proxy_parameters()
+
+    def _define_proxy_parameters(self):
+        self.wi_full = (self.wi.t() * self.si).t()
+        self.wo_full = self.wo * self.so
+
+    def forward(self, input):
+        """
+        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
+        Important: the 3 dimensions need to be present, even if they are of size 1.
+        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
+        """
+        batch_size = input.shape[0]
+        seq_len = input.shape[1]
+        h = self.h0
+        r = self.non_linearity(h)
+        self._define_proxy_parameters()
+        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.wrec.device)
+        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.wrec.device)
+        trajectories = torch.zeros(batch_size, seq_len, self.hidden_size, device=self.wrec.device)
+
+        # simulation loop
+        for i in range(seq_len):
+            h = (
+                h
+                + self.noise_std * noise[:, i, :]
+                + self.alpha * (-h + r.matmul(self.wrec.t()) + input[:, i, :].matmul(self.wi_full))
+            )
+
+            r = self.non_linearity(h)
+            output[:, i, :] = r.matmul(self.wo_full)
+            trajectories[:, i, :] = h
+
+        return output, trajectories
+
+    def clone(self):
+        new_net = FullRankRNN(
+            self.input_size,
+            self.hidden_size,
+            self.output_size,
+            self.noise_std,
+            self.alpha,
+            self.rho,
+            self.train_wi,
+            self.train_wo,
+            self.train_wrec,
+            self.train_h0,
+            self.wi,
+            self.wo,
+            self.wrec,
+            self.si,
+            self.so,
+        )
+        return new_net
+
+
+def simulation_loop(model, input):
+    batch_size = input.shape[0]
+    seq_len = input.shape[1]
+    h = model.h0
+    r = model.non_linearity(h)
+
+    noise = torch.randn(batch_size, seq_len, model.hidden_size, device=model.m.device)
+    output = torch.zeros(batch_size, seq_len, model.output_size, device=model.m.device)
+    trajectories = torch.zeros(batch_size, seq_len, model.hidden_size, device=model.m.device)
+
+    for i in range(seq_len):
+        h = (
+            h
+            + model.noise_std * noise[:, i, :]
+            + model.alpha
+            * (
+                -h
+                + r.matmul(model.n).matmul(model.m.t()) / model.hidden_size
+                + input[:, i, :].matmul(model.wi_full)
+            )
+        )
+
+        r = model.non_linearity(h)
+        output[:, i, :] = r.matmul(model.wo_full) / model.hidden_size
+        trajectories[:, i, :] = h
+
+    return output, trajectories
+
+
+class LowRankRNN(nn.Module):
+    """
+    This class implements the low-rank RNN. Instead of being parametrized by an NxN connectivity matrix, it is
+    parametrized by two Nxr matrices m and n such that the connectivity is m * n^T
+    """
+
+    def __init__(
+        self,
+        input_size,
+        hidden_size,
+        output_size,
+        noise_std,
+        alpha,
+        rank=1,
+        train_wi=False,
+        train_wo=False,
+        train_wrec=True,
+        train_h0=False,
+        train_si=True,
+        train_so=True,
+        wi_init=None,
+        wo_init=None,
+        m_init=None,
+        n_init=None,
+        si_init=None,
+        so_init=None,
+        h0_init=None,
+    ):
+        """
+        :param input_size: int
+        :param hidden_size: int
+        :param output_size: int
+        :param noise_std: float
+        :param alpha: float, value of dt/tau
+        :param rank: int
+        :param train_wi: bool
+        :param train_wo: bool
+        :param train_wrec: bool
+        :param train_h0: bool
+        :param train_si: bool
+        :param train_so: bool
+        :param wi_init: torch tensor of shape (input_dim, hidden_size)
+        :param wo_init: torch tensor of shape (hidden_size, output_dim)
+        :param m_init: torch tensor of shape (hidden_size, rank)
+        :param n_init: torch tensor of shape (hidden_size, rank)
+        :param si_init: torch tensor of shape (input_size)
+        :param so_init: torch tensor of shape (output_size)
+        :param h0_init: torch tensor of shape (hidden_size)
+        """
+        super(LowRankRNN, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.noise_std = noise_std
+        self.alpha = alpha
+        self.rank = rank
+        self.train_wi = train_wi
+        self.train_wo = train_wo
+        self.train_wrec = train_wrec
+        self.train_h0 = train_h0
+        self.train_si = train_si
+        self.train_so = train_so
+        self.non_linearity = torch.tanh
+
+        # Define parameters
+        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
+        self.si = nn.Parameter(torch.Tensor(input_size))
+        if train_wi:
+            self.si.requires_grad = False
+        else:
+            self.wi.requires_grad = False
+        if not train_si:
+            self.si.requires_grad = False
+        self.m = nn.Parameter(torch.Tensor(hidden_size, rank))
+        self.n = nn.Parameter(torch.Tensor(hidden_size, rank))
+        if not train_wrec:
+            self.m.requires_grad = False
+            self.n.requires_grad = False
+        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
+        self.so = nn.Parameter(torch.Tensor(output_size))
+        if train_wo:
+            self.so.requires_grad = False
+        if not train_wo:
+            self.wo.requires_grad = False
+        if not train_so:
+            self.so.requires_grad = False
+        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
+        if not train_h0:
+            self.h0.requires_grad = False
+
+        # Initialize parameters
+        with torch.no_grad():
+            if wi_init is None:
+                self.wi.normal_()
+            else:
+                self.wi.copy_(wi_init)
+            if si_init is None:
+                self.si.set_(torch.ones_like(self.si))
+            else:
+                self.si.copy_(si_init)
+            if m_init is None:
+                self.m.normal_()
+            else:
+                self.m.copy_(m_init)
+            if n_init is None:
+                self.n.normal_()
+            else:
+                self.n.copy_(n_init)
+            if wo_init is None:
+                self.wo.normal_(std=4.0)
+            else:
+                self.wo.copy_(wo_init)
+            if so_init is None:
+                self.so.set_(torch.ones_like(self.so))
+            else:
+                self.so.copy_(so_init)
+            if h0_init is None:
+                self.h0.zero_()
+            else:
+                self.h0.copy_(h0_init)
+        self.wrec, self.wi_full, self.wo_full = [None] * 3
+        self._define_proxy_parameters()
+
+    def _define_proxy_parameters(self):
+        self.wrec = None
+        self.wi_full = (self.wi.t() * self.si).t()
+        self.wo_full = self.wo * self.so
+
+    def forward(self, input):
+        """
+        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
+        Important: the 3 dimensions need to be present, even if they are of size 1.
+        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
+        """
+        return simulation_loop(self, input)
+
+    def clone(self):
+        new_net = LowRankRNN(
+            self.input_size,
+            self.hidden_size,
+            self.output_size,
+            self.noise_std,
+            self.alpha,
+            self.rank,
+            self.train_wi,
+            self.train_wo,
+            self.train_wrec,
+            self.train_h0,
+            self.train_si,
+            self.train_so,
+            self.wi,
+            self.wo,
+            self.m,
+            self.n,
+            self.si,
+            self.so,
+        )
+        new_net._define_proxy_parameters()
+        return new_net
+
+    def load_state_dict(self, state_dict, strict=True):
+        """
+        override
+        """
+        if "rec_noise" in state_dict:
+            del state_dict["rec_noise"]
+        super().load_state_dict(state_dict, strict)
+        self._define_proxy_parameters()
+
+    def svd_reparametrization(self):
+        """
+        Orthogonalize m and n via SVD
+        """
+        with torch.no_grad():
+            structure = (self.m @ self.n.t()).numpy()
+            m, s, n = np.linalg.svd(structure, full_matrices=False)
+            m, s, n = m[:, : self.rank], s[: self.rank], n[: self.rank, :]
+            self.m.set_(torch.from_numpy(m * np.sqrt(s)))
+            self.n.set_(torch.from_numpy(n.transpose() * np.sqrt(s)))
+            self._define_proxy_parameters()
+
+
+class SupportLowRankRNN(nn.Module):
+    """
+    This class implements the mixture-of-gaussians, low-rank RNN. The difference with the low-rank RNN is that
+    all vectors are defined as transformation of a gaussian basis of dimensionality b for each population.
+
+    For example the matrix m, instead of having Nxr free parameters, is parametrized by a tensor
+    m_weights of shape (r, p, b) (where r is the rank, p is the number of populations). A gaussian basis of
+    shape Nxb is sampled, and m is then computed from the basis and the weights, by assigning each neuron to a
+    population monotonically.
+
+    The weights defined above correspond to a linear transformation of the gaussian basis (ie the expectancy
+    of the final distribution obtained is always zero). Affine transforms can be defined by setting biases.
+    """
+
+    def __init__(
+        self,
+        input_size,
+        hidden_size,
+        output_size,
+        noise_std,
+        alpha,
+        rank=1,
+        n_supports=1,
+        weights=None,
+        gaussian_basis_dim=None,
+        m_weights_init=None,
+        n_weights_init=None,
+        wi_weights_init=None,
+        wo_weights_init=None,
+        m_biases_init=None,
+        n_biases_init=None,
+        wi_biases_init=None,
+        train_biases=False,
+    ):
+        """
+        :param input_size: int
+        :param hidden_size: int
+        :param output_size: int
+        :param noise_std: float
+        :param alpha: float
+        :param rank: int
+        :param n_supports: int, number of cell classes used
+        :param weights: list, proportion of total population for each cell class (GMM components weights)
+        :param gaussian_basis_dim: dimensionality of the gaussian basis on which weights are learned
+        :param m_weights_init: torch tensor of shape (rank, n_supports, gaussian_basis_dim)
+        :param n_weights_init: torch tensor of shape (rank, n_supports, gaussian_basis_dim)
+        :param wi_weights_init: torch tensor of shape (input_size, n_supports, self.gaussian_basis_dim)
+        :param wo_weights_init: torch tensor of shape (output_size, n_supports, self.gaussian_basis_dim)
+        :param m_biases_init: torch tensor of shape (rank, n_supports)
+        :param n_biases_init: torch tensor of shape (rank, n_supports)
+        :param wi_biases_init: torch tensor of shape (input_size, n_supports)
+        :param train_biases: bool
+        """
+        super(SupportLowRankRNN, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.noise_std = noise_std
+        self.alpha = alpha
+        self.rank = rank
+        self.n_supports = n_supports
+        self.gaussian_basis_dim = (
+            2 * rank + input_size if gaussian_basis_dim is None else gaussian_basis_dim
+        )
+        self.non_linearity = torch.tanh
+
+        self.gaussian_basis = nn.Parameter(
+            torch.randn((self.gaussian_basis_dim, hidden_size)), requires_grad=False
+        )
+        self.supports = nn.Parameter(torch.zeros((n_supports, hidden_size)), requires_grad=False)
+        if weights is None:
+            self.weights = nn.Parameter(torch.tensor([1 / hidden_size]))
+            l_support = hidden_size // n_supports
+            for i in range(n_supports):
+                self.supports[i, l_support * i : l_support * (i + 1)] = 1
+            self.weights = [l_support / hidden_size] * n_supports
+        else:
+            k = 0
+            self.weights = nn.Parameter(torch.tensor(weights), requires_grad=False)
+            for i in range(n_supports):
+                self.supports[i, k : k + floor(weights[i] * hidden_size)] = 1
+                k += floor(weights[i] * hidden_size)
+
+        # Define parameters
+        self.wi_weights = nn.Parameter(
+            torch.Tensor(input_size, n_supports, self.gaussian_basis_dim)
+        )
+        self.m_weights = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
+        self.n_weights = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
+        self.wo_weights = nn.Parameter(
+            torch.Tensor(output_size, n_supports, self.gaussian_basis_dim)
+        )
+        self.wi_biases = nn.Parameter(
+            torch.Tensor(input_size, n_supports), requires_grad=train_biases
+        )
+        self.m_biases = nn.Parameter(torch.Tensor(rank, n_supports), requires_grad=train_biases)
+        self.n_biases = nn.Parameter(torch.Tensor(rank, n_supports), requires_grad=train_biases)
+        self.h0_weights = nn.Parameter(torch.Tensor(n_supports, self.gaussian_basis_dim))
+        self.h0_weights.requires_grad = False
+
+        # Initialize parameters
+        with torch.no_grad():
+            if wi_weights_init is not None:
+                self.wi_weights.copy_(wi_weights_init)
+            else:
+                self.wi_weights.normal_()
+            if m_weights_init is not None:
+                self.m_weights.copy_(m_weights_init)
+            else:
+                self.m_weights.normal_(std=1 / sqrt(hidden_size))
+            if n_weights_init is not None:
+                self.n_weights.copy_(n_weights_init)
+            else:
+                self.n_weights.normal_(std=1 / sqrt(hidden_size))
+            if wo_weights_init is not None:
+                self.wo_weights.copy_(wo_weights_init)
+            else:
+                self.wo_weights.normal_(std=1 / hidden_size)
+            if wi_biases_init is not None:
+                self.wi_biases.copy_(wi_biases_init)
+            else:
+                self.wi_biases.zero_()
+            if m_biases_init is not None:
+                self.m_biases.copy_(m_biases_init)
+            else:
+                self.m_biases.zero_()
+            if n_biases_init is not None:
+                self.n_biases.copy_(n_biases_init)
+            else:
+                self.n_biases.zero_()
+            self.h0_weights.zero_()
+        self.wi, self.m, self.n, self.wo, self.h0, self.wi_full, self.wo_full = [None] * 7
+        self._define_proxy_parameters()
+
+    def _define_proxy_parameters(self):
+        self.wi = (
+            torch.sum((self.wi_weights @ self.gaussian_basis) * self.supports, dim=(1,))
+            + self.wi_biases @ self.supports
+        )
+        self.wi_full = self.wi
+        self.m = (
+            torch.sum((self.m_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+            + (self.m_biases @ self.supports).t()
+        )
+        self.n = (
+            torch.sum((self.n_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+            + (self.n_biases @ self.supports).t()
+        )
+        self.wo = torch.sum((self.wo_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+        self.wo_full = self.wo
+        self.h0 = torch.sum((self.h0_weights @ self.gaussian_basis) * self.supports, dim=(0,))
+
+    def forward(self, input):
+        return simulation_loop(self, input)
+
+    def clone(self):
+        new_net = SupportLowRankRNN(
+            self.input_size,
+            self.hidden_size,
+            self.output_size,
+            self.noise_std,
+            self.alpha,
+            self.rank,
+            self.n_supports,
+            self.weights.tolist(),
+            self.gaussian_basis_dim,
+            self.m_weights,
+            self.n_weights,
+            self.wi_weights,
+            self.wo_weights,
+            self.m_biases,
+            self.n_biases,
+            self.wi_biases,
+        )
+        new_net.gaussian_basis.copy_(self.gaussian_basis)
+        new_net._define_proxy_parameters()
+        return new_net
+
+    def load_state_dict(self, state_dict, strict=True):
+        """
+        override to recompute w_rec on loading
+        """
+        super().load_state_dict(state_dict, strict)
+        self._define_proxy_parameters()
+
+    def resample_basis(self):
+        self.gaussian_basis.normal_()
+        self._define_proxy_parameters()
+
+
+class SupportLowRankRNN_withMask(nn.Module):
+    """
+    This network has been defined to train an arbitrary subset of the parameters offered by the SupportLowRankRNN
+    by adding a mask.
+    """
+
+    def __init__(
+        self,
+        input_size,
+        hidden_size,
+        output_size,
+        noise_std,
+        alpha,
+        rank=1,
+        n_supports=1,
+        gaussian_basis_dim=None,
+        initial_m=None,
+        initial_n=None,
+        initial_unitm=None,
+        initial_unitn=None,
+        initial_wi=None,
+        initial_unitwi=None,
+        initial_wo=None,
+        initial_h0=None,
+        initial_unith0=None,
+        initial_bias=None,
+        train_h0=False,
+        train_bias=False,
+        initial_wi_mask=None,
+        initial_wo_mask=None,
+        initial_m_mask=None,
+        initial_n_mask=None,
+    ):
+        super(SupportLowRankRNN_withMask, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.noise_std = noise_std
+        self.alpha = alpha
+        self.rank = rank
+        self.n_supports = n_supports
+        self.gaussian_basis_dim = (
+            2 * rank + input_size if gaussian_basis_dim is None else gaussian_basis_dim
+        )
+        self.non_linearity = torch.tanh
+
+        self.gaussian_basis = nn.Parameter(
+            torch.randn((self.gaussian_basis_dim, hidden_size)), requires_grad=False
+        )
+        self.unit_vector = nn.Parameter(torch.ones((1, hidden_size)), requires_grad=False)
+        self.supports = nn.Parameter(torch.zeros((n_supports, hidden_size)), requires_grad=False)
+        l_support = hidden_size // n_supports
+        for i in range(n_supports):
+            self.supports[i, l_support * i : l_support * (i + 1)] = 1
+
+        # Define parameters
+        self.wi = nn.Parameter(torch.Tensor(input_size, n_supports, self.gaussian_basis_dim))
+        self.unitwi = nn.Parameter(torch.Tensor(input_size, n_supports, 1))
+        self.m = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
+        self.n = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
+        self.unitm = nn.Parameter(torch.Tensor(rank, n_supports, 1))
+        self.unitn = nn.Parameter(torch.Tensor(rank, n_supports, 1))
+        self.wo = nn.Parameter(torch.Tensor(output_size, n_supports, self.gaussian_basis_dim))
+        self.h0 = nn.Parameter(torch.Tensor(n_supports, self.gaussian_basis_dim))
+        self.unith0 = nn.Parameter(torch.Tensor(n_supports, 1))
+        self.bias = nn.Parameter(torch.Tensor(n_supports, 1))
+
+        self.wi_mask = nn.Parameter(
+            torch.Tensor(input_size, n_supports, self.gaussian_basis_dim), requires_grad=False
+        )
+        self.unitwi_mask = nn.Parameter(
+            torch.Tensor(input_size, n_supports, 1), requires_grad=False
+        )
+        self.m_mask = nn.Parameter(
+            torch.Tensor(rank, n_supports, self.gaussian_basis_dim), requires_grad=False
+        )
+        self.n_mask = nn.Parameter(
+            torch.Tensor(rank, n_supports, self.gaussian_basis_dim), requires_grad=False
+        )
+        self.unitm_mask = nn.Parameter(torch.Tensor(rank, n_supports, 1), requires_grad=False)
+        self.unitn_mask = nn.Parameter(torch.Tensor(rank, n_supports, 1), requires_grad=False)
+        self.wo_mask = nn.Parameter(
+            torch.Tensor(output_size, n_supports, self.gaussian_basis_dim), requires_grad=False
+        )
+        self.h0_mask = nn.Parameter(
+            torch.Tensor(n_supports, self.gaussian_basis_dim), requires_grad=False
+        )
+        self.unith0_mask = nn.Parameter(torch.Tensor(n_supports, 1), requires_grad=False)
+        self.bias_mask = nn.Parameter(torch.Tensor(n_supports, 1), requires_grad=False)
+
+        if not train_h0:
+            self.h0.requires_grad = False
+            self.unith0.requires_grad = False
+        if not train_bias:
+            self.bias.requires_grad = False
+
+        # Initialize parameters
+        with torch.no_grad():
+            if initial_wi is not None:
+                self.wi.copy_(initial_wi)
+                if initial_wi_mask is not None:
+                    maskc = initial_wi_mask
+                else:
+                    maskc = torch.where(
+                        initial_wi != 0, torch.ones_like(initial_wi), torch.zeros_like(initial_wi)
+                    )
+                self.wi_mask.copy_(maskc)
+            else:
+                self.wi.zero_()
+                self.wi_mask.zero_()
+            if initial_unitwi is not None:
+                self.unitwi.copy_(initial_unitwi)
+                maskc = torch.where(
+                    initial_unitwi != 0,
+                    torch.ones_like(initial_unitwi),
+                    torch.zeros_like(initial_unitwi),
+                )
+                self.unitwi_mask.copy_(maskc)
+            else:
+                self.unitwi.zero_()
+                self.unitwi_mask.zero_()
+            if initial_m is not None:
+                self.m.copy_(initial_m)
+                if initial_m_mask is not None:
+                    maskc = initial_m_mask
+                else:
+                    maskc = torch.where(
+                        initial_m != 0, torch.ones_like(initial_m), torch.zeros_like(initial_m)
+                    )
+                self.m_mask.copy_(maskc)
+            else:
+                self.m.zero_()
+                self.m_mask.zero_()
+            if initial_n is not None:
+                self.n.copy_(initial_n)
+                if initial_n_mask is not None:
+                    maskc = initial_n_mask
+                else:
+                    maskc = torch.where(
+                        initial_n != 0, torch.ones_like(initial_n), torch.zeros_like(initial_n)
+                    )
+                self.n_mask.copy_(maskc)
+            else:
+                self.n.zero_()
+                self.n_mask.zero_()
+            if initial_unitm is not None:
+                self.unitm.copy_(initial_unitm)
+                maskc = torch.where(
+                    initial_unitm != 0,
+                    torch.ones_like(initial_unitm),
+                    torch.zeros_like(initial_unitm),
+                )
+                self.unitm_mask.copy_(maskc)
+            else:
+                self.unitm.zero_()
+                self.unitm_mask.zero_()
+            if initial_unitn is not None:
+                self.unitn.copy_(initial_unitn)
+                maskc = torch.where(
+                    initial_unitn != 0,
+                    torch.ones_like(initial_unitn),
+                    torch.zeros_like(initial_unitn),
+                )
+                self.unitn_mask.copy_(maskc)
+            else:
+                self.unitn.zero_()
+                self.unitn_mask.zero_()
+            if initial_wo is not None:
+                self.wo.copy_(initial_wo)
+                if initial_wo_mask is not None:
+                    maskc = initial_wo_mask
+                else:
+                    maskc = torch.where(
+                        initial_wo != 0, torch.ones_like(initial_wo), torch.zeros_like(initial_wo)
+                    )
+                self.wo_mask.copy_(maskc)
+            else:
+                self.wo.zero_()
+                self.wo_mask.zero_()
+            if initial_h0 is not None:
+                self.h0.copy_(initial_h0)
+                maskc = torch.where(
+                    initial_h0 != 0, torch.ones_like(initial_h0), torch.zeros_like(initial_h0)
+                )
+                self.h0_mask.copy_(maskc)
+            else:
+                self.h0.zero_()
+                self.h0_mask.zero_()
+            if initial_unith0 is not None:
+                self.unith0.copy_(initial_unith0)
+                maskc = torch.where(
+                    initial_unith0 != 0,
+                    torch.ones_like(initial_unith0),
+                    torch.zeros_like(initial_unith0),
+                )
+                self.unith0_mask.copy_(maskc)
+            else:
+                self.unith0.zero_()
+                self.unith0_mask.zero_()
+            if initial_bias is not None:
+                self.bias.copy_(initial_bias)
+                maskc = torch.where(
+                    initial_bias != 0, torch.ones_like(initial_bias), torch.zeros_like(initial_bias)
+                )
+                self.bias_mask.copy_(maskc)
+            else:
+                self.bias.zero_()
+                self.bias_mask.zero_()
+
+        (
+            self.wi_full,
+            self.m_rec,
+            self.n_rec,
+            self.wo_full,
+            self.w_rec,
+            self.h0_full,
+            self.bias_full,
+        ) = [None] * 7
+        self.define_proxy_parameters()
+
+    def define_proxy_parameters(self):
+        self.wi_full = torch.sum(
+            (self.wi @ self.gaussian_basis) * self.supports, dim=(1,)
+        ) + torch.sum((self.unitwi @ self.unit_vector) * self.supports, dim=(1,))
+        self.m_rec = (
+            torch.sum((self.m @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+            + torch.sum((self.unitm @ self.unit_vector) * self.supports, dim=(1,)).t()
+        )
+        self.n_rec = (
+            torch.sum((self.n @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+            + torch.sum((self.unitn @ self.unit_vector) * self.supports, dim=(1,)).t()
+        )
+        self.wo_full = torch.sum((self.wo @ self.gaussian_basis) * self.supports, dim=(1,)).t()
+        self.w_rec = self.m_rec.matmul(self.n_rec.t())
+        self.h0_full = torch.sum(
+            (self.h0 @ self.gaussian_basis) * self.supports, dim=(0,)
+        ) + torch.sum((self.unith0 @ self.unit_vector) * self.supports, dim=(0,))
+        self.bias_full = torch.sum((self.bias @ self.unit_vector) * self.supports, dim=(0,))
+
+    def forward(self, input):
+        batch_size = input.shape[0]
+        seq_len = input.shape[1]
+        self.define_proxy_parameters()
+        h = self.h0_full
+        r = self.non_linearity(h)
+        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.m_rec.device)
+        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.m_rec.device)
+        trajectories = torch.zeros(batch_size, seq_len, self.hidden_size, device=self.m_rec.device)
+
+        # simulation loop
+        for i in range(seq_len):
+            h = (
+                h
+                + self.bias_full
+                + self.noise_std * noise[:, i, :]
+                + self.alpha * (-h + r.matmul(self.w_rec.t()) + input[:, i, :].matmul(self.wi_full))
+            )
+
+            r = self.non_linearity(h)
+            output[:, i, :] = r.matmul(self.wo_full)
+            trajectories[:, i, :] = h
+
+        return output, trajectories
+
+    def clone(self):
+        new_net = SupportLowRankRNN_withMask(
+            self.input_size,
+            self.hidden_size,
+            self.output_size,
+            self.noise_std,
+            self.alpha,
+            self.rank,
+            self.n_supports,
+            self.gaussian_basis_dim,
+            self.m,
+            self.n,
+            self.unitm,
+            self.unitn,
+            self.wi,
+            self.unitwi,
+            self.wo,
+            self.h0,
+            self.unith0,
+            self.bias,
+        )
+        new_net.gaussian_basis.copy_(self.gaussian_basis)
+        new_net.define_proxy_parameters()
+        return new_net
+
+    def load_state_dict(self, state_dict, strict=True):
+        """
+        override to recompute w_rec on loading
+        """
+        super().load_state_dict(state_dict, strict)
+        self.define_proxy_parameters()
+
+    def resample_basis(self):
+        self.gaussian_basis.normal_()
+        self.define_proxy_parameters()
+
+    def orthogonalize_basis(self):
+        for i in range(self.n_supports):
+            gaussian_chunk = self.gaussian_basis[:, self.supports[i] == 1].view(
+                self.gaussian_basis_dim, -1
+            )
+            gram_schmidt_pt(gaussian_chunk)
+            self.gaussian_basis[:, self.supports[i] == 1] = gaussian_chunk
+        self.gaussian_basis *= sqrt(self.hidden_size // self.n_supports)
+        self.define_proxy_parameters()
+
+
+def simulation_loop(model, input):
+    batch_size = input.shape[0]
+    seq_len = input.shape[1]
+    h = model.h0
+    r = model.non_linearity(h)
+
+    noise = torch.randn(batch_size, seq_len, model.hidden_size, device=model.m.device)
+    output = torch.zeros(batch_size, seq_len, model.output_size, device=model.m.device)
+    trajectories = torch.zeros(batch_size, seq_len, model.hidden_size, device=model.m.device)
+
+    for i in range(seq_len):
+        h = (
+            h
+            + model.noise_std * noise[:, i, :]
+            + model.alpha
+            * (
+                -h
+                + r.matmul(model.n).matmul(model.m.t()) / model.hidden_size
+                + input[:, i, :].matmul(model.wi_full)
+            )
+        )
+
+        r = model.non_linearity(h)
+        output[:, i, :] = r.matmul(model.wo_full) / model.hidden_size
+        trajectories[:, i, :] = h
+
+    return output, trajectories
+
+
+class OptimizedLowRankRNN(nn.Module):
+    """
+    LowRankRNN class with a different definition of scalings (see caption of SI Fig. about the 3-population Ctx net)
+    """
+
+    def __init__(
+        self,
+        input_size,
+        hidden_size,
+        output_size,
+        noise_std,
+        alpha,
+        rho=0.0,
+        rank=1,
+        train_wi=False,
+        train_wo=False,
+        train_wrec=True,
+        train_h0=False,
+        train_si=True,
+        train_so=True,
+        wi_init=None,
+        wo_init=None,
+        m_init=None,
+        n_init=None,
+        si_init=None,
+        so_init=None,
+        h0_init=None,
+    ):
+        """
+        :param input_size: int
+        :param hidden_size: int
+        :param output_size: int
+        :param noise_std: float
+        :param alpha: float
+        :param rho: float, std of quenched noise matrix
+        :param rank: int
+        :param train_wi: bool
+        :param train_wo: bool
+        :param train_wrec: bool
+        :param train_h0: bool
+        :param train_si: bool (can't be True if train_wi is already True)
+        :param train_so: bool (can't be True if train_wo is already True)
+        :param wi_init: torch tensor of shape (input_dim, hidden_size)
+        :param wo_init: torch tensor of shape (hidden_size, output_dim)
+        :param m_init: torch tensor of shape (hidden_size, rank)
+        :param n_init: torch tensor of shape (hidden_size, rank)
+        :param si_init: input scaling, torch tensor of shape (input_dim)
+        :param so_init: output scaling, torch tensor of shape (output_dim)
+        :param h0_init: torch tensor of shape (hidden_size)
+        """
+        super(OptimizedLowRankRNN, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.noise_std = noise_std
+        self.alpha = alpha
+        self.rho = rho
+        self.rank = rank
+        self.train_wi = train_wi
+        self.train_wo = train_wo
+        self.train_wrec = train_wrec
+        self.train_h0 = train_h0
+        self.train_si = train_si
+        self.train_so = train_so
+        self.non_linearity = torch.tanh
+
+        # Define parameters
+        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
+        self.si = nn.Parameter(torch.Tensor(input_size))
+        if train_wi:
+            self.si.requires_grad = False
+        else:
+            self.wi.requires_grad = False
+        if not train_si:
+            self.si.requires_grad = False
+        self.m = nn.Parameter(torch.Tensor(hidden_size, rank))
+        self.n = nn.Parameter(torch.Tensor(hidden_size, rank))
+        if not train_wrec:
+            self.m.requires_grad = False
+            self.n.requires_grad = False
+        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
+        self.so = nn.Parameter(torch.Tensor(output_size))
+        if train_wo:
+            self.so.requires_grad = False
+        else:
+            self.wo.requires_grad = False
+        if not train_so:
+            self.so.requires_grad = False
+        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
+        if not train_h0:
+            self.h0.requires_grad = False
+
+        # Initialize parameters
+        with torch.no_grad():
+            if wi_init is None:
+                self.wi.normal_()
+            else:
+                self.wi.copy_(wi_init)
+            if si_init is None:
+                self.si.set_(torch.ones_like(self.si))
+            else:
+                self.si.copy_(si_init)
+            if m_init is None:
+                self.m.normal_(std=1 / sqrt(hidden_size))
+            else:
+                self.m.copy_(m_init)
+            if n_init is None:
+                self.n.normal_(std=1 / sqrt(hidden_size))
+            else:
+                self.n.copy_(n_init)
+            if wo_init is None:
+                self.wo.normal_(std=2 / hidden_size)
+            else:
+                self.wo.copy_(wo_init)
+            if so_init is None:
+                self.so.set_(torch.ones_like(self.so))
+            else:
+                self.so.copy_(so_init)
+            if h0_init is None:
+                self.h0.zero_()
+            else:
+                self.h0.copy_(h0_init)
+        self.wrec, self.wi_full, self.wo_full = [None] * 3
+        self.define_proxy_parameters()
+
+    def define_proxy_parameters(self):
+        self.wi_full = (self.wi.t() * self.si).t()
+        self.wo_full = self.wo * self.so
+
+    def forward(self, input):
+        """
+        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
+        Important: the 3 dimensions need to be present, even if they are of size 1.
+        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
+        """
+        batch_size = input.shape[0]
+        seq_len = input.shape[1]
+        h = self.h0
+        r = self.non_linearity(h)
+        self.define_proxy_parameters()
+        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.m.device)
+        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.m.device)
+        trajectories = torch.zeros(batch_size, seq_len + 1, self.hidden_size, device=self.m.device)
+        trajectories[:, 0, :] = h
+
+        # simulation loop
+        for i in range(seq_len):
+            h = (
+                h
+                + self.noise_std * noise[:, i, :]
+                + self.alpha
+                * (-h + r.matmul(self.n).matmul(self.m.t()) + input[:, i, :].matmul(self.wi_full))
+            )
+
+            r = self.non_linearity(h)
+            output[:, i, :] = r.matmul(self.wo_full)
+            trajectories[:, i + 1, :] = h
+
+        return output, trajectories
+
+    def clone(self):
+        new_net = OptimizedLowRankRNN(
+            self.input_size,
+            self.hidden_size,
+            self.output_size,
+            self.noise_std,
+            self.alpha,
+            self.rho,
+            self.rank,
+            self.train_wi,
+            self.train_wo,
+            self.train_wrec,
+            self.train_h0,
+            self.train_si,
+            self.train_so,
+            self.wi,
+            self.wo,
+            self.m,
+            self.n,
+            self.si,
+            self.so,
+        )
+        new_net.define_proxy_parameters()
+        return new_net
+
+    def resample_connectivity_noise(self):
+        self.define_proxy_parameters()
+
+    def load_state_dict(self, state_dict, strict=True):
+        """
+        override to recompute w_rec on loading
+        """
+        super().load_state_dict(state_dict, strict)
+        self.define_proxy_parameters()
+
+    def svd_reparametrization(self):
+        """
+        Orthogonalize m and n via SVD
+        """
+        with torch.no_grad():
+            structure = (self.m @ self.n.t()).numpy()
+            m, s, n = np.linalg.svd(structure, full_matrices=False)
+            m, s, n = m[:, : self.rank], s[: self.rank], n[: self.rank, :]
+            self.m.set_(torch.from_numpy(m * np.sqrt(s)))
+            self.n.set_(torch.from_numpy(n.transpose() * np.sqrt(s)))
+            self.define_proxy_parameters()

data/examples/RNN/RNN_scripts/ranktwo.py

@@ -0,0 +1,538 @@
+from math import sqrt
+import numpy as np
+import matplotlib.pyplot as plt
+import multiprocessing as mp
+from scipy.optimize import root
+from .helpers import phi_prime
+
+
+def adjust_plot(ax, xmin, xmax, ymin, ymax):
+    ax.set_xlim(xmin - 0.05 * (xmax - xmin), xmax + 0.05 * (xmax - xmin))
+    ax.set_ylim(ymin - 0.05 * (ymax - ymin), ymax + 0.05 * (ymax - ymin))
+
+
+def plot_field(
+    net,
+    vec1=None,
+    vec2=None,
+    xmin=-3,
+    xmax=3,
+    ymin=-3,
+    ymax=3,
+    input=None,
+    res=50,
+    ax=None,
+    add_fixed_points=False,
+    fixed_points_trials=10,
+    fp_save=None,
+    fp_load=None,
+    nojac=False,
+    orth=False,
+    alt_naming=True,
+    sizes=1,
+):
+    """
+    Plot the flow field of a rank 2 network in its (m1, m2) plane (eventually affine if there is an input)
+    Note: assumes the net uses tanh non-linearity
+    Note 2: if plotting fixed points, stability calculations only make sense in the case of a rank2 net in plane
+    (m1, m2)
+    :param net:
+    :param vec1: numpy array, if None, the m1 vector of the network is selected
+    :param vec2: numpy array, if None, the m2 vector of the net is selected
+    :param xmin: float
+    :param xmax: float
+    :param ymin: float
+    :param ymax: float
+    :param input: tensor of shape (dim_input) that is used to compute input vector
+    :param res: int, resolution of flow field
+    :param ax: matplotlib.Axes, plot on it if given
+    :param add_fixed_points: bool
+    :param fixed_points_trials: int, number of trials for fixed points search
+    :param nojac: if True, do not use the jacobian for the fixed points finder
+    :param orth: bool, True to orthogonalize vec2 with vec1
+    :param alt_naming: set True for SupportLowRankRNN_withMask
+    :return: matplotlib.Axes
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    adjust_plot(ax, xmin, xmax, ymin, ymax)
+    if vec1 is None:
+        vec1 = net.m[:, 0].squeeze().detach().numpy()
+    if vec2 is None:
+        vec2 = net.m[:, 1].squeeze().detach().numpy()
+    if add_fixed_points:
+        n1 = net.n[:, 0].squeeze().detach().numpy()
+        n2 = net.n[:, 1].squeeze().detach().numpy()
+    if hasattr(net, "wrec") and net.wrec is not None:
+        w_rec = net.wrec.detach().numpy()
+    else:
+        w_rec = None
+        m = net.m.detach().numpy()
+        n = net.n.detach().numpy().T
+        if alt_naming:
+            m = net.m_rec.detach().numpy()
+            n = net.n_rec.detach().numpy().T
+
+    # Plotting constants
+    marker_size = 50 * sizes
+    nx, ny = res, res
+
+    # Orthogonalization of the basis vec1, vec2, I
+    if orth:
+        vec2 = vec2 - (vec2 @ vec1) * vec1 / (vec1 @ vec1)
+    if input is not None:
+        I = (input @ net.wi_full).detach().numpy()
+        I_orth = I - (I @ vec1) * vec1 / (vec1 @ vec1) - (I @ vec2) * vec2 / (vec2 @ vec2)
+    else:
+        I = np.zeros(net.hidden_size)
+        I_orth = np.zeros(net.hidden_size)
+
+    # rescaling factors (for transformation euclidean space / overlap space)
+    # here, if one wants x s.t. overlap(x, vec1) = alpha, x should be r1 * alpha * vec1
+    # with the overlap being defined as overlap(u, v) = u.dot(v) / sqrt(hidden_size)
+    r1 = sqrt(net.hidden_size) / (vec1 @ vec1)
+    r2 = sqrt(net.hidden_size) / (vec2 @ vec2)
+
+    # Defining the grid
+    xs_grid = np.linspace(xmin, xmax, nx + 1)
+    ys_grid = np.linspace(ymin, ymax, ny + 1)
+    xs = (xs_grid[1:] + xs_grid[:-1]) / 2
+    ys = (ys_grid[1:] + ys_grid[:-1]) / 2
+    field = np.zeros((nx, ny, 2))
+    X, Y = np.meshgrid(xs, ys)
+
+    # Recurrent function of dx/dt = F(x, I)
+    if w_rec is not None:
+
+        def F(x, I):
+            return -x + w_rec @ np.tanh(x) + I
+
+    else:
+
+        def F(x, I):
+            return -x + m @ (n @ np.tanh(x)) + I
+
+    # Derivative of tanh
+    def phiPrime(x):
+        return 1 - np.tanh(x) ** 2
+
+    # Jacobian of F, assuming F is rank 2
+    def FJac(x, I=None):
+        phiPr = phiPrime(x)
+        n1_eff = n1 * phiPr
+        n2_eff = n2 * phiPr
+        return np.outer(vec1, n1_eff) + np.outer(vec2, n2_eff) - np.identity(net.hidden_size)
+
+    # Compute flow in each point of the grid
+    for i, x in enumerate(xs):
+        for j, y in enumerate(ys):
+            h = r1 * x * vec1 + r2 * y * vec2 + I_orth
+            delta = F(h, I)
+            field[j, i, 0] = delta @ vec1 / sqrt(net.hidden_size)
+            field[j, i, 1] = delta @ vec2 / sqrt(net.hidden_size)
+
+    ax.streamplot(
+        xs,
+        ys,
+        field[:, :, 0],
+        field[:, :, 1],
+        color="white",
+        density=0.5,
+        arrowsize=sizes,
+        linewidth=sizes * 0.8,
+    )
+
+    norm_field = np.sqrt(field[:, :, 0] ** 2 + field[:, :, 1] ** 2)
+    mappable = ax.pcolor(X, Y, norm_field)
+
+    # Look for fixed points
+    if add_fixed_points:
+        if fp_load is None:
+            stable_sols = []
+            saddles = []
+            sources = []
+
+            # initial conditions are dispersed over a grid
+            X_grid, Y_grid = np.meshgrid(
+                np.linspace(xmin, xmax, int(sqrt(fixed_points_trials))),
+                np.linspace(ymin, ymax, int(sqrt(fixed_points_trials))),
+            )
+
+            for i in range(X_grid.size):
+                xy = X_grid.ravel()[i], Y_grid.ravel()[i]
+                x0 = r1 * xy[0] * vec1 + r2 * xy[1] * vec2 + I_orth
+                sol = root(F, x0, args=I, jac=None if nojac else FJac)
+
+                # if solution found
+                if sol.success == 1:
+                    kappa_sol = [
+                        (sol.x @ vec1) / sqrt(net.hidden_size),
+                        (sol.x @ vec2) / sqrt(net.hidden_size),
+                    ]
+                    # Computing stability
+                    pseudoJac = np.zeros((2, 2))
+                    phiPr = phiPrime(sol.x)
+                    n1_eff = n1 * phiPr
+                    n2_eff = n2 * phiPr
+                    pseudoJac[0, 0] = vec1 @ n1_eff
+                    pseudoJac[0, 1] = vec2 @ n1_eff
+                    pseudoJac[1, 0] = vec1 @ n2_eff
+                    pseudoJac[1, 1] = vec2 @ n2_eff
+                    eigvals = np.linalg.eigvals(pseudoJac)
+                    if np.all(np.real(eigvals) <= 1):
+                        stable_sols.append(kappa_sol)
+                    elif np.any(np.real(eigvals) <= 1):
+                        saddles.append(kappa_sol)
+                    else:
+                        sources.append(kappa_sol)
+        # Load fixed points stored in a file
+        else:
+            arrays = np.load(fp_load)
+            arr = arrays["arr_0"]
+            stable_sols = [arr[i] for i in range(arr.shape[0])]
+            arr = arrays["arr_1"]
+            saddles = [arr[i] for i in range(arr.shape[0])]
+            arr = arrays["arr_2"]
+            sources = [arr[i] for i in range(arr.shape[0])]
+            print(saddles)
+        if fp_save is not None:
+            np.savez(fp_save, np.array(stable_sols), np.array(saddles), np.array(sources))
+        else:
+            ax.scatter(
+                [x[0] for x in stable_sols],
+                [x[1] for x in stable_sols],
+                facecolors="white",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+            ax.scatter(
+                [x[0] for x in saddles],
+                [x[1] for x in saddles],
+                facecolors="black",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+            ax.scatter(
+                [x[0] for x in sources],
+                [x[1] for x in sources],
+                facecolors="black",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+    return ax, mappable
+
+
+#
+# def plot_field2(net, vec1=None, vec2=None, xmin=-3, xmax=3, ymin=-3, ymax=3, input=None, res=50,
+#                ax=None, add_fixed_points=False, fixed_points_trials=10, nojac=False, orth=False):
+#     if ax is None:
+#         fig, ax = plt.subplots()
+#     adjust_plot(ax, xmin, xmax, ymin, ymax)
+#     if net.wrec is not None:
+#         w_rec = net.wrec.detach().numpy()
+#     else:
+#         w_rec = None
+#         m = net.m.detach().numpy()
+#         n = net.n.detach().numpy().T
+#
+#     # Plotting constants
+#     marker_size = 90
+#     nx, ny = res, res
+#
+#     # Orthogonalization of the basis vec1, vec2, I
+#     if orth:
+#         vec2 = vec2 - (vec2 @ vec1) * vec1 / (vec1 @ vec1)
+#     if input is not None:
+#         I = (input @ net.wi_full).detach().numpy()
+#         I_orth = I - (I @ vec1) * vec1 / (vec1 @ vec1) - (I @ vec2) * vec2 / (vec2 @ vec2)
+#     else:
+#         I = np.zeros(net.hidden_size)
+#         I_orth = np.zeros(net.hidden_size)
+#
+#     # rescaling factors (for transformation euclidean space / overlap space)
+#     # here, if one wants x s.t. overlap(x, vec1) = alpha, x should be r1 * alpha * vec1
+#     # with the overlap being defined as overlap(u, v) = u.dot(v) / sqrt(hidden_size)
+#     r1 = 1. / (vec1 @ vec1)
+#     r2 = 1. / (vec2 @ vec2)
+#
+#     # Defining the grid
+#     xs_grid = np.linspace(xmin, xmax, nx + 1)
+#     ys_grid = np.linspace(ymin, ymax, ny + 1)
+#     xs = (xs_grid[1:] + xs_grid[:-1]) / 2
+#     ys = (ys_grid[1:] + ys_grid[:-1]) / 2
+#     field = np.zeros((nx, ny, 2))
+#     X, Y = np.meshgrid(xs, ys)
+#
+#     # Recurrent function of dx/dt = F(x, I)
+#     if w_rec is not None:
+#         def F(x, I):
+#             return -x + w_rec @ np.tanh(x) + I
+#     else:
+#         def F(x, I):
+#             return -x + m @ (n @ np.tanh(x)) + I
+#
+#     # Compute flow in each point of the grid
+#     for i, x in enumerate(xs):
+#         for j, y in enumerate(ys):
+#             h = r1 * x * vec1 + r2 * y * vec2 + I_orth
+#             delta = F(h, I)
+#             field[j, i, 0] = delta @ vec1
+#             field[j, i, 1] = delta @ vec2
+#     ax.streamplot(xs, ys, field[:, :, 0], field[:, :, 1], color='white', density=0.5, arrowsize=1.8, linewidth=1.5)
+#     norm_field = np.sqrt(field[:, :, 0] ** 2 + field[:, :, 1] ** 2)
+#     ax.pcolor(X, Y, norm_field)
+#     return ax
+
+
+def fixedpoint_task(x0, m, n, hidden_size, I, nojac):
+    """
+    Task for the root solver to find fixed points, for parallelization
+    """
+    # Redefining functions for pickle issues
+    def F(x, I):
+        return -x + m @ (n.T @ np.tanh(x)) / hidden_size + I
+
+    m1 = m[:, 0]
+    m2 = m[:, 1]
+    n1 = n[:, 0]
+    n2 = n[:, 1]
+    # Jacobian of F assuming Wrec is rank 2
+    def FJac(x, I=None):
+        phiPr = phi_prime(x)
+        n1_eff = n1 * phiPr
+        n2_eff = n2 * phiPr
+        return (np.outer(m1, n1_eff) + np.outer(m2, n2_eff)) / hidden_size - np.identity(
+            hidden_size
+        )
+
+    return root(F, x0, args=I, jac=None if nojac else FJac)
+
+
+def plot_field_noscalings(
+    net,
+    vec1=None,
+    vec2=None,
+    xmin=-3,
+    xmax=3,
+    ymin=-3,
+    ymax=3,
+    input=None,
+    res=50,
+    ax=None,
+    add_fixed_points=False,
+    fixed_points_trials=10,
+    fp_save=None,
+    fp_load=None,
+    nojac=False,
+    orth=False,
+    sizes=1.0,
+):
+    """
+    Plot 2d flow field and eventually fixed points for a rank 2 network without scaled vectors (ie defined as in
+    Francesca's paper). Can plot the affine flow field in presence of a constant input with argument input.
+    :param net: a LowRankRNN
+    :param vec1: None or a numpy array of shape (hidden_size). If None, will be taken as vector m1 of the network
+    :param vec2: same with m2
+    :param xmin: float
+    :param xmax: float
+    :param ymin: float
+    :param ymax: float
+    :param input: None or torch tensor of shape (n_inputs), provides constant input for plotting affine flow field
+    :param res: int, grid resolution
+    :param ax: None or matplotlib axes
+    :param add_fixed_points: bool
+    :param fixed_points_trials: int, number of simulations to launch to find fixed points
+    :param fp_save: None or filename, to save found fixed points instead of plotting them
+    :param fp_load: None or filename, to load fixed points instead of recomputing them
+    :param nojac: bool, if True, use root solver without jacobian matrix
+    :param orth: bool, if True, start by orthogonalizing (vec1, vec2)
+    :return: axes
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    adjust_plot(ax, xmin, xmax, ymin, ymax)
+    if vec1 is None:
+        vec1 = net.m[:, 0].squeeze().detach().numpy()
+    if vec2 is None:
+        vec2 = net.m[:, 1].squeeze().detach().numpy()
+    if add_fixed_points:
+        n1 = net.n[:, 0].squeeze().detach().numpy()
+        n2 = net.n[:, 1].squeeze().detach().numpy()
+    m = net.m.detach().numpy()
+    n = net.n.detach().numpy()
+
+    # Plotting constants
+    nx, ny = res, res
+    marker_size = 50 * sizes
+
+    # Orthogonalization of the basis vec1, vec2, I
+    if orth:
+        vec2 = vec2 - (vec2 @ vec1) * vec1 / (vec1 @ vec1)
+    if input is not None:
+        I = (input @ net.wi_full).detach().numpy()
+        I_orth = I - (I @ vec1) * vec1 / (vec1 @ vec1) - (I @ vec2) * vec2 / (vec2 @ vec2)
+    else:
+        I = np.zeros(net.hidden_size)
+        I_orth = np.zeros(net.hidden_size)
+
+    # rescaling factors (for transformation euclidean space / overlap space)
+    # here, if one wants x s.t. overlap(x, vec1) = alpha, x should be r1 * alpha * vec1
+    # with the overlap being defined as overlap(u, v) = u.dot(v) / sqrt(hidden_size)
+    r1 = net.hidden_size / (vec1 @ vec1)
+    r2 = net.hidden_size / (vec2 @ vec2)
+
+    # Defining the grid
+    xs_grid = np.linspace(xmin, xmax, nx + 1)
+    ys_grid = np.linspace(ymin, ymax, ny + 1)
+    xs = (xs_grid[1:] + xs_grid[:-1]) / 2
+    ys = (ys_grid[1:] + ys_grid[:-1]) / 2
+    field = np.zeros((nx, ny, 2))
+    X, Y = np.meshgrid(xs, ys)
+
+    # Recurrent function of dx/dt = F(x, I)
+    def F(x, I):
+        return -x + m @ (n.T @ np.tanh(x)) / net.hidden_size + I
+
+    # Compute flow in each point of the grid
+    for i, x in enumerate(xs):
+        for j, y in enumerate(ys):
+            h = r1 * x * vec1 + r2 * y * vec2 + I_orth
+            delta = F(h, I)
+            field[j, i, 0] = delta @ vec1 / (vec1 @ vec1)
+            field[j, i, 1] = delta @ vec2 / (vec2 @ vec2)
+    ax.streamplot(
+        xs,
+        ys,
+        field[:, :, 0],
+        field[:, :, 1],
+        color="white",
+        density=0.5,
+        arrowsize=sizes,
+        linewidth=sizes * 0.8,
+    )
+    norm_field = np.sqrt(field[:, :, 0] ** 2 + field[:, :, 1] ** 2)
+    mappable = ax.pcolor(X, Y, norm_field)
+
+    # Look for fixed points
+    if add_fixed_points:
+        if fp_load is None:
+            stable_sols = []
+            saddles = []
+            sources = []
+
+            # initial conditions are dispersed over a grid
+            X_grid, Y_grid = np.meshgrid(
+                np.linspace(xmin, xmax, int(sqrt(fixed_points_trials))),
+                np.linspace(ymin, ymax, int(sqrt(fixed_points_trials))),
+            )
+
+            # Parallelized root solver
+            x0s = [
+                r1 * X_grid.ravel()[i] * vec1 + r2 * Y_grid.ravel()[i] * vec2 + I_orth
+                for i in range(X_grid.size)
+            ]
+            with mp.Pool(mp.cpu_count()) as pool:
+                args = [(x0, m, n, net.hidden_size, I, nojac) for x0 in x0s]
+                sols = pool.starmap(fixedpoint_task, args)
+
+            for sol in sols:
+                # if solution found
+                if sol.success == 1:
+                    kappa_sol = [(sol.x @ vec1) / net.hidden_size, (sol.x @ vec2) / net.hidden_size]
+                    # Computing stability
+                    pseudoJac = np.zeros((2, 2))
+                    phiPr = phi_prime(sol.x)
+                    n1_eff = n1 * phiPr
+                    n2_eff = n2 * phiPr
+                    pseudoJac[0, 0] = vec1 @ n1_eff / net.hidden_size
+                    pseudoJac[0, 1] = vec2 @ n1_eff / net.hidden_size
+                    pseudoJac[1, 0] = vec1 @ n2_eff / net.hidden_size
+                    pseudoJac[1, 1] = vec2 @ n2_eff / net.hidden_size
+                    eigvals = np.linalg.eigvals(pseudoJac)
+                    if np.all(np.real(eigvals) <= 1):
+                        stable_sols.append(kappa_sol)
+                    elif np.any(np.real(eigvals) <= 1):
+                        saddles.append(kappa_sol)
+                    else:
+                        sources.append(kappa_sol)
+        # Load fixed points stored in a file
+        else:
+            arrays = np.load(fp_load)
+            arr = arrays["arr_0"]
+            stable_sols = [arr[i] for i in range(arr.shape[0])]
+            arr = arrays["arr_1"]
+            saddles = [arr[i] for i in range(arr.shape[0])]
+            arr = arrays["arr_2"]
+            sources = [arr[i] for i in range(arr.shape[0])]
+        if fp_save is not None:
+            np.savez(fp_save, np.array(stable_sols), np.array(saddles), np.array(sources))
+        else:
+            ax.scatter(
+                [x[0] for x in stable_sols],
+                [x[1] for x in stable_sols],
+                facecolors="white",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+            ax.scatter(
+                [x[0] for x in saddles],
+                [x[1] for x in saddles],
+                facecolors="black",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+            ax.scatter(
+                [x[0] for x in sources],
+                [x[1] for x in sources],
+                facecolors="black",
+                edgecolors="white",
+                s=marker_size,
+                zorder=1000,
+            )
+    return ax, mappable
+
+
+def plot_readout_map(vec1, vec2, wo, rect=(-10, 10, -10, 10), scale=0.5, scalings=True, cmap="jet"):
+    """
+    Plot the map from the 2D space spanned by (vec1, vec2) to a scalar defined by wo.T @ phi(x)
+    :param vec1: numpy array
+    :param vec2: numpy array
+    :param wo: numpy array
+    :param rect: 4-tuple, x and y axis limits
+    :param scale: scale of vector readout for plotting
+    :param scalings: bool, False for no scalings networks
+    :param cmap:
+    :return:
+    """
+    xmin, xmax, ymin, ymax = rect
+    hidden_size = vec1.shape[0]
+    xs = np.linspace(xmin, xmax, 100)
+    ys = np.linspace(ymin, ymax, 100)
+    if scalings:
+        r1 = 1.0 / (vec1 @ vec1)
+        r2 = 1.0 / (vec2 @ vec2)
+    else:
+        r1 = hidden_size / (vec1 @ vec1)
+        r2 = hidden_size / (vec2 @ vec2)
+    X, Y = np.meshgrid(xs, ys)
+    z = np.zeros((100, 100))
+    for i, x in enumerate(xs):
+        for j, y in enumerate(ys):
+            h = r1 * x * vec1 + r2 * y * vec2
+            z[i, j] = wo @ np.tanh(h)
+    plt.pcolor(X, Y, z, cmap=cmap)
+    plt.colorbar()
+    if scalings:
+        readout1, readout2 = wo @ vec1, wo @ vec2
+    else:
+        readout1, readout2 = wo @ vec1 / hidden_size, wo @ vec2 / hidden_size
+    plt.quiver(0, 0, readout1, readout2, color="k", scale=scale)
+    plt.xticks([])
+    plt.yticks([])
+    plt.xlabel("$\kappa_1$")
+    plt.ylabel("$\kappa_2$")

data/examples/macaque_reaching/convert_spikes_to_firing_rates.py

@@ -0,0 +1,150 @@
+"""Convert spiking and kinematics data into instantaneous rates for MARBLE analysis.
+
+It needs neo and elephant packages in addition to MARBLE.
+"""
+import os
+import sys
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from scipy.io import loadmat
+from elephant.statistics import instantaneous_rate
+import neo
+from elephant.kernels import GaussianKernel
+from quantities import ms
+from MARBLE import utils
+import mat73
+import pickle
+
+
+def spikes_to_rates(data, d, sampling_period=20):
+    """
+    Converts matlab spiking data into instantaneous rates in a suitable format for further analysis
+    """
+
+    # defining conditions by their ordering (this was how it was ordered in matlab script)
+    conditions = ["DownLeft", "Left", "UpLeft", "Up", "UpRight", "Right", "DownRight"]
+
+    data_day = data[d]  # daily session
+
+    gk = GaussianKernel(100 * ms)  # increase this for smoother signals (previously used auto)
+
+    # define empty dictionary for each day
+    rates = {}
+
+    # loop over the 7 conditions
+    for c, cond in enumerate(conditions):
+
+        # define empty list for each condition during each session
+        trial_data = []
+
+        # extracting data for a single condition on a single day (composed of t trials)
+        data_day_cond = data_day[c]
+
+        # loop over trials
+        for t, trial in enumerate(data_day_cond):
+
+            # if the trial exists (sometimes there is None)
+            if trial:
+                trial = trial[0]  # it was a single element list
+
+                # loop over neurons
+                inst_rates = []
+                for ch in range(trial.shape[0]):
+
+                    # extract spikes for a given channel (neuron)
+                    spikes = np.where(trial[ch, :])[0]
+
+                    # get spike train (1200 milliseconds)
+                    st = neo.SpikeTrain(spikes, units="ms", t_stop=1200)
+
+                    # get rates
+                    inst_rate = instantaneous_rate(st, kernel=gk, sampling_period=sampling_period*ms).magnitude
+
+                    # append into list
+                    inst_rates.append(inst_rate.flatten())
+
+                # stack rates back together and transpose = (channels by time)
+                inst_rates = np.stack(inst_rates, axis=1)
+
+                # append rates from one trial into trial data
+                trial_data.append(inst_rates)
+
+        # stack into an array of trial x channels x time
+        rates[cond] = np.dstack(trial_data).transpose(2, 1, 0)
+
+    return rates
+
+
+def convert_spiking_rates(sampling_period=20):
+
+    data_file = "data/conditions_spiking_data.mat"
+    Path("data").mkdir(exist_ok=True)
+    os.system(f"wget -nc https://dataverse.harvard.edu/api/access/datafile/6963157 -O {data_file}")
+
+    # load data compiled into matlab cell array
+    data = mat73.loadmat(data_file)["all_results"]
+
+    rates = utils.parallel_proc(
+        spikes_to_rates, range(len(data)), data, processes=-1, desc="Converting spikes to rates..."
+    )
+
+    all_rates = {}
+    for i, rates_day in enumerate(rates):
+        all_rates[i] = rates_day
+
+    with open(f"data/rate_data_{sampling_period}ms.pkl", "wb") as handle:
+        pickle.dump(all_rates, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+def find_condition(val, trials, conditions):
+    for cond in conditions:
+        if val in trials[cond]:
+            return cond
+
+
+def convert_kinematics():
+    """Extracting kinematic data from matlab into format for decoding"""
+
+    data_file = "data/kinematics_lfadsSingleFromFactors.mat"
+    os.system(f"wget -nc  https://dataverse.harvard.edu/api/access/datafile/7062085 -O {data_file}")
+    kinematic_data = loadmat(data_file)["Tin_single"]
+
+    data_file = "data/trial_ids.pkl"
+    os.system(f"wget -nc  https://dataverse.harvard.edu/api/access/datafile/6963200  -O {data_file}")    
+    trial_ids = pickle.load(open("./data/trial_ids.pkl", "rb"))
+
+    kinematics = {}
+    conditions = ["DownLeft", "Left", "UpLeft", "Up", "UpRight", "Right", "DownRight"]
+
+    for d, day in enumerate(kinematic_data):
+        day = day[0]
+        kinematics_conds = defaultdict(list)
+
+        for i in range(day.shape[0]):
+            X = day[i].tolist()[0][1]  # kinematics x,y posiution and x,y velocity
+            Z = day[i].tolist()[0][2]  # lfads factors
+            T = day[i].tolist()[0][3]  # time
+
+            cond = find_condition(i, trial_ids[d], conditions)
+
+            kinematics_conds[i] = {
+                "kinematics": X,
+                "lfads_factors": Z,
+                "time": T,
+                "condition": cond,
+            }
+
+        kinematics[d] = kinematics_conds
+
+    with open("data/kinematics.pkl", "wb") as handle:
+        pickle.dump(kinematics, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+def main():
+    convert_spiking_rates()
+    #convert_kinematics()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

data/examples/macaque_reaching/kinematic_decoding.ipynb

@@ -0,0 +1,657 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1c2478f9",
+   "metadata": {},
+   "source": [
+    "# Kinematic decoding\n",
+    "\n",
+    "This notebook compares the decoding performance of MARBLE with CEBRA and TDR on a macaque centre-out reaching task. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cae68224-84f6-43fd-82f4-bba80b806780",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib widget\n",
+    "\n",
+    "!pip install statannotations ipympl\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "import seaborn as sns\n",
+    "from statannotations.Annotator import Annotator\n",
+    "from sklearn.model_selection import KFold\n",
+    "from macaque_reaching_helpers import *\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1d50682-1117-4481-854d-76d2563a200b",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "Load firing rate and kinematics data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2883f5a-4789-49e2-8d43-1b3946c3a4fd",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!mkdir data\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6969885 -O data/kinematics.pkl\n",
+    "\n",
+    "with open('data/kinematics.pkl', 'rb') as handle:\n",
+    "    data = pickle.load(handle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "94051207",
+   "metadata": {},
+   "source": [
+    "# Load MARBLE and CEBRA embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9bc422a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7062022 -O data/marble_embeddings_out20_pca5_100ms.pkl\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7509031 -O data/cebra_embeddings_out20_pca5_100ms.pkl\n",
+    "\n",
+    "with open('data/marble_embeddings_out20_pca5_100ms.pkl', 'rb') as handle:\n",
+    "    _, marble_embeddings, _, _, trial_ids, _  = pickle.load(handle)\n",
+    "\n",
+    "with open('data/cebra_embeddings_out20_pca5_100ms.pkl', 'rb') as handle:\n",
+    "    _, cebra_embeddings, _, _, _, _ = pickle.load(handle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a66b1c78-ebdc-44d7-a249-ba39659538e3",
+   "metadata": {},
+   "source": [
+    "# Load raw firing rates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d25686c-08c0-40d1-8528-61056a3bc9c6",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "pca_n = 5\n",
+    "filter_data = True\n",
+    "conditions=['DownLeft','Left','UpLeft','Up','UpRight','Right','DownRight']  \n",
+    "\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6969883 -O data/rate_data_20ms_100ms.pkl\n",
+    "\n",
+    "with open('data/rate_data_20ms_100ms.pkl', 'rb') as handle:\n",
+    "    rates = pickle.load(handle)\n",
+    "\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6963200 -O data/trial_ids.pkl\n",
+    "\n",
+    "with open('data/trial_ids.pkl', 'rb') as handle:\n",
+    "    trials = pickle.load(handle)\n",
+    "    \n",
+    "pos, pos_raw = [], []\n",
+    "for day in rates.keys():\n",
+    "    #preprocess by PCA dimensionality reduction and smoothing\n",
+    "    pca = fit_pca(rates, day, conditions, filter_data=filter_data, pca_n=pca_n)\n",
+    "    pos_, _, _, _, _ = format_data(rates, \n",
+    "                                   trials,\n",
+    "                                   day, \n",
+    "                                   conditions, \n",
+    "                                   pca=pca,\n",
+    "                                   filter_data=filter_data,\n",
+    "                                  )\n",
+    "\n",
+    "    #no preprocessing for comparison\n",
+    "    pos_raw_, _, _, _, _ = format_data(rates, \n",
+    "                                   trials,\n",
+    "                                   day, \n",
+    "                                   conditions,\n",
+    "                                  )\n",
+    "    \n",
+    "    pos.append(np.vstack(pos_))\n",
+    "    pos_raw.append(np.vstack(pos_raw_))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2c473e3-48e8-403a-8384-b98541a6535c",
+   "metadata": {},
+   "source": [
+    "### Targeted Dimensionality Reduction (TDR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d41142bd-2b2e-4d74-8808-e7aac0b5b66b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "condition_labels = {'DownLeft': [1,[-1, -1]], \n",
+    "                    'Left': [2, [-1, 0]], \n",
+    "                    'UpLeft': [3,[-1, 1]], \n",
+    "                    'Up': [4,[0, 1]], \n",
+    "                    'UpRight': [5,[1, 1]], \n",
+    "                    'Right': [6,[1, 0]], \n",
+    "                    'DownRight': [7,[1, -1]]} \n",
+    "\n",
+    "TDR_embeddings = {}\n",
+    "for day in tqdm(rates.keys()):\n",
+    "    unique_trial_ids = np.unique(trial_ids[day])\n",
+    "    Z, X, cond = [], [], []\n",
+    "    for t in unique_trial_ids:\n",
+    "        c_l = data[day][t]['condition']\n",
+    "        firing_rates = pos_raw[day][trial_ids[day]==t,:].T\n",
+    "        c = np.tile(condition_labels[c_l][1], (firing_rates.shape[1],1))\n",
+    "        regressors = np.hstack([c, np.ones([firing_rates.shape[1], 1])])\n",
+    "        \n",
+    "        Z.append(firing_rates)\n",
+    "        X.append(regressors)\n",
+    "        cond.append(condition_labels[c_l][0])\n",
+    "    \n",
+    "    Z = np.stack(Z, axis=2)\n",
+    "    X = np.stack(X, axis=2)\n",
+    "    cond = np.hstack(cond)\n",
+    "    \n",
+    "    #standardise per neuron\n",
+    "    Z -= Z.mean(axis=(1,2), keepdims=True)\n",
+    "    Z /= Z.std(axis=(1,2), keepdims=True)\n",
+    "    \n",
+    "    [n, T, tr] = Z.shape\n",
+    "    n_reg = X.shape[1]\n",
+    "    \n",
+    "    #compute TDR regression coefficients\n",
+    "    betaBehav2Neural = np.zeros([T,n,n_reg-1])\n",
+    "    for i in range(T):\n",
+    "        Ztrain = Z[:,i,:].T\n",
+    "        Xtrain = X[i,:,:].T\n",
+    "    \n",
+    "        reg = np.linalg.lstsq(Xtrain, Ztrain, rcond=None)[0]\n",
+    "        reg = np.linalg.pinv(reg) # Compute the TDR axes.\n",
+    "        reg = reg[:,:-1] # remove last regressor (bias)\n",
+    "    \n",
+    "        betaBehav2Neural[i,:,:] = reg\n",
+    "    \n",
+    "    #project data to TDR subspace\n",
+    "    Zproj = np.zeros([n_reg-1,T,tr])\n",
+    "    for i in range(T):\n",
+    "        Zt = Z[:,i,:].T \n",
+    "        regt = betaBehav2Neural[i,:,:]\n",
+    "        Zproj[:,i,:] = (Zt @ regt).T\n",
+    "\n",
+    "    TDR_embeddings[day] = Zproj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f9c6226-2c82-4177-bf85-4a6ed75ee47a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#plot\n",
+    "plt.figure()\n",
+    "colors = plt.cm.viridis(np.linspace(0,1,7))\n",
+    "for j in range(tr):\n",
+    "    c = cond[j]-1\n",
+    "    plt.plot(Zproj[0,:,j], Zproj[1,:,j], c = colors[c])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1638c8f-f4b7-450b-a16c-981a74353417",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# match the neural representations to the kinematics\n",
+    "for day in data.keys():\n",
+    "    unique_trial_ids = np.unique(trial_ids[day])\n",
+    "    for i, t in enumerate(unique_trial_ids):\n",
+    "        data[day][t]['kinematics'] = data[day][t]['kinematics'][:,:-1] #remove last point because\n",
+    "        data[day][t]['lfads_factors'] = data[day][t]['lfads_factors'][:,:-1] \n",
+    "        data[day][t]['marble_emb'] = marble_embeddings[day][trial_ids[day]==t,:].T\n",
+    "        data[day][t]['firing_rates'] = pos[day][trial_ids[day]==t,:].T\n",
+    "        data[day][t]['cebra_emb'] = cebra_embeddings[day][trial_ids[day]==t,:].T\n",
+    "        data[day][t]['raw_firing_rates'] = pos_raw[day][trial_ids[day]==t,:].T\n",
+    "        data[day][t]['TDR_emb'] = TDR_embeddings[day][:,:,i]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49b9822e-5817-4022-a5f9-3d5962877b60",
+   "metadata": {},
+   "source": [
+    "# Visualise kinematics for a single session"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22176228-1e45-445f-acd7-180c4b5c22b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "session = 0\n",
+    "\n",
+    "colors = plt.cm.viridis(np.linspace(0,1,7))\n",
+    "\n",
+    "# plot average kinematic position across trials for a given session\n",
+    "plt.figure()\n",
+    "for c,cond in enumerate(conditions):   \n",
+    "    meh = np.dstack([data[session][t]['kinematics'] for t in data[session].keys() if data[session][t]['condition']==cond]).mean(2)        \n",
+    "    plt.plot(meh[0,:],meh[1,:],c=colors[c])\n",
+    "plt.title('average kinematic hand position across trials')\n",
+    "\n",
+    "# plot kinematic position for each trials in a given session\n",
+    "plt.figure()\n",
+    "for c,cond in enumerate(conditions):   \n",
+    "    for t in data[session].keys():\n",
+    "        if data[session][t]['condition']==cond:\n",
+    "            meh = data[session][t]['kinematics']\n",
+    "            plt.plot(meh[0,:],meh[1,:],c=colors[c])\n",
+    "plt.title('per trial kinematic hand position')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76a52b47",
+   "metadata": {},
+   "source": [
+    "# Decoding single session"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e70f5fe-6cd8-46dd-ae95-269f5b449bd8",
+   "metadata": {},
+   "source": [
+    "### Optimal linear decoding via LFADS, MARBLE and CEBRA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1cb13479",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "session = 0\n",
+    "\n",
+    "unique_trial_ids = np.unique(trial_ids[session])\n",
+    "\n",
+    "L_lfads = train_OLE(data[session], trial_ids[session], representation='lfads_factors')\n",
+    "\n",
+    "# loop over test trials\n",
+    "for tr in unique_trial_ids:\n",
+    "    trial_pred = decode_kinematics(data[session][tr], L_lfads, dt=20, representation='lfads_factors')\n",
+    "    data[session][tr]['lfads_decoded'] = trial_pred\n",
+    "\n",
+    "L_firing_rates = train_OLE(data[session], trial_ids[session], representation='firing_rates')\n",
+    "\n",
+    "# loop over test trials\n",
+    "for tr in unique_trial_ids:\n",
+    "    trial_pred = decode_kinematics(data[session][tr], L_firing_rates, dt=20, representation='firing_rates')\n",
+    "    data[session][tr]['firing_rates_decoded'] = trial_pred\n",
+    "\n",
+    "L_marble = train_OLE(data[session], trial_ids[session], representation='marble_emb')\n",
+    "\n",
+    "# loop over test trials\n",
+    "for tr in unique_trial_ids:\n",
+    "    trial_pred = decode_kinematics(data[session][tr], L_marble, dt=20, representation='marble_emb')\n",
+    "    data[session][tr]['marble_decoded'] = trial_pred\n",
+    "    \n",
+    "L_cebra = train_OLE(data[session], trial_ids[session], representation='cebra_emb')\n",
+    "\n",
+    "# loop over test trials\n",
+    "for tr in unique_trial_ids:\n",
+    "    trial_pred = decode_kinematics(data[session][tr], L_cebra, dt=20, representation='cebra_emb')\n",
+    "    data[session][tr]['cebra_decoded'] = trial_pred\n",
+    "\n",
+    "L_TDR = train_OLE(data[session], trial_ids[session], representation='TDR_emb')\n",
+    "\n",
+    "# loop over test trials\n",
+    "for tr in unique_trial_ids:\n",
+    "    trial_pred = decode_kinematics(data[session][tr], L_TDR, dt=20, representation='TDR_emb')\n",
+    "    data[session][tr]['TDR_decoded'] = trial_pred"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a0a408b",
+   "metadata": {},
+   "source": [
+    "### Comparison of decoding with ground truth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4bfea1d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(2,3,figsize=(10,4))\n",
+    "\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='kinematics', ax=ax[0,0])\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='firing_rates_decoded', ax=ax[0,1])\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='marble_decoded', ax=ax[0,2])\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='lfads_decoded', ax=ax[1,0])\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='cebra_decoded', ax=ax[1,1])\n",
+    "plot_kinematics(data, session, unique_trial_ids, representation='TDR_decoded', ax=ax[1,2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea829c14",
+   "metadata": {},
+   "source": [
+    "# Decode across all sessions\n",
+    "\n",
+    "Above we decoded for a single session. Lets now loop over every session and compute some quantitative comparisons with the ground truth kinematics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b77a49a6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "kf = KFold(n_splits=5, shuffle=True) # use 5-fold split of the data \n",
+    "\n",
+    "r2_lfads_vel = []; r2_lfads_pos = []\n",
+    "r2_cebra_vel = []; r2_cebra_pos = []\n",
+    "r2_marble_vel = []; r2_marble_pos = []\n",
+    "r2_TDR_vel = []; r2_TDR_pos = []\n",
+    "r2_firing_rates_vel = []; r2_firing_rates_pos = []\n",
+    "\n",
+    "# loop over seessions\n",
+    "for d in tqdm(data.keys()):\n",
+    "    unique_trial_ids = np.unique(trial_ids[d])\n",
+    "    \n",
+    "    # cross validation\n",
+    "    for i, (train_index, test_index) in enumerate(kf.split(unique_trial_ids)):\n",
+    "\n",
+    "        train_data = {key: data[d][key] for key in train_index if key in data[d]}\n",
+    "\n",
+    "        #LFADS\n",
+    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='lfads_factors')\n",
+    "        \n",
+    "        for tr in unique_trial_ids[test_index]:\n",
+    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='lfads_factors')\n",
+    "            data[d][tr]['lfads_decoded'] = trial_pred\n",
+    "           \n",
+    "        #CEBRA\n",
+    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='cebra_emb')\n",
+    "        \n",
+    "        for tr in unique_trial_ids[test_index]:\n",
+    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='cebra_emb')\n",
+    "            data[d][tr]['cebra_decoded'] = trial_pred\n",
+    "            \n",
+    "        #MARBLE\n",
+    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='marble_emb')\n",
+    "        \n",
+    "        for tr in unique_trial_ids[test_index]:\n",
+    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='marble_emb')\n",
+    "            data[d][tr]['marble_decoded'] = trial_pred\n",
+    "\n",
+    "        #TDR\n",
+    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='TDR_emb')\n",
+    "        \n",
+    "        for tr in unique_trial_ids[test_index]:\n",
+    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='TDR_emb')\n",
+    "            data[d][tr]['TDR_decoded'] = trial_pred\n",
+    "\n",
+    "        #Firing rates\n",
+    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='firing_rates')\n",
+    "        \n",
+    "        for tr in unique_trial_ids[test_index]:\n",
+    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='firing_rates')\n",
+    "            data[d][tr]['firing_rates_decoded'] = trial_pred\n",
+    "            \n",
+    "    # r-squared velocity\n",
+    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='lfads_decoded')   \n",
+    "    r2_lfads_pos.append(r2_pos)\n",
+    "    r2_lfads_vel.append(r2_vel)\n",
+    "    \n",
+    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='cebra_decoded')   \n",
+    "    r2_cebra_pos.append(r2_pos)\n",
+    "    r2_cebra_vel.append(r2_vel)\n",
+    "    \n",
+    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='marble_decoded')   \n",
+    "    r2_marble_pos.append(r2_pos)\n",
+    "    r2_marble_vel.append(r2_vel)\n",
+    "\n",
+    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='TDR_decoded')   \n",
+    "    r2_TDR_pos.append(r2_pos)\n",
+    "    r2_TDR_vel.append(r2_vel)\n",
+    "\n",
+    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='firing_rates_decoded')   \n",
+    "    r2_firing_rates_pos.append(r2_pos)\n",
+    "    r2_firing_rates_vel.append(r2_vel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4aaba62",
+   "metadata": {},
+   "source": [
+    "Lets now visualise the decoded kinematics for the same set of example sessions (Fig S7)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e2ba8691",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# chosen example sessions\n",
+    "examples = [5,6,8,11,14,15,18,23,26,32]\n",
+    "\n",
+    "fig, ax = plt.subplots(4,len(examples),figsize=(15,5))\n",
+    "\n",
+    "for i,d in enumerate(examples):\n",
+    "    \n",
+    "    unique_trial_ids = np.unique(trial_ids[d])\n",
+    "\n",
+    "    ax[0,i] = plot_kinematics(data, d, unique_trial_ids, representation='kinematics', ax=ax[0,i])\n",
+    "    ax[1,i] = plot_kinematics(data, d, unique_trial_ids, representation='marble_decoded', ax=ax[1,i])\n",
+    "    ax[2,i] = plot_kinematics(data, d, unique_trial_ids, representation='cebra_decoded', ax=ax[2,i])\n",
+    "    ax[3,i] = plot_kinematics(data, d, unique_trial_ids, representation='lfads_decoded', ax=ax[3,i])\n",
+    "    ax[3,i] = plot_kinematics(data, d, unique_trial_ids, representation='firing_rates_decoded', ax=ax[3,i])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a20a9cb0",
+   "metadata": {},
+   "source": [
+    "## Instantaneous velocity decoding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75da5f8b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "results = pd.DataFrame(data=np.vstack([ r2_marble_vel, r2_cebra_vel, r2_lfads_vel, r2_TDR_vel, r2_firing_rates_vel]).T,columns=['marble', 'CEBRA', 'LFADS', 'TDR', 'firing_rates'])\n",
+    "results = results.melt()\n",
+    "results.columns = ['model','accuracy']\n",
+    "\n",
+    "f, ax = plt.subplots(figsize=(4,5))\n",
+    "sns.despine(bottom=True, left=True)\n",
+    "\n",
+    "sns.stripplot(\n",
+    "    data=results, x=\"model\", y=\"accuracy\",\n",
+    "    dodge=True, alpha=.5, zorder=1,\n",
+    ")\n",
+    "\n",
+    "sns.pointplot(\n",
+    "    data=results, x=\"model\", y=\"accuracy\",\n",
+    "    join=False, dodge=.8 - .8 / 3, palette=\"dark\",\n",
+    "    markers=\"d\", scale=.75, errorbar=None\n",
+    ")\n",
+    "\n",
+    "pairs=[(\"LFADS\", \"marble\"), (\"CEBRA\",\"marble\"), (\"firing_rates\",\"marble\"), (\"TDR\",\"marble\")]\n",
+    "\n",
+    "annotator = Annotator(ax, pairs, data=results, x=\"model\", y=\"accuracy\",)\n",
+    "annotator.configure(test='Wilcoxon', text_format='star', loc='outside')\n",
+    "annotator.apply_and_annotate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "379d1077",
+   "metadata": {},
+   "source": [
+    "## Decoding final reach direction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91f2c2a7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "marble_model_acc = []\n",
+    "cebra_model_acc = []\n",
+    "lfads_model_acc = []\n",
+    "TDR_model_acc = []\n",
+    "firing_rates_model_acc = []\n",
+    "\n",
+    "for d in tqdm(data.keys()):           \n",
+    "\n",
+    "    unique_trial_ids = np.unique(trial_ids[d])\n",
+    "    \n",
+    "    # fit classifier to kinematics\n",
+    "    clf = fit_classifier(data[d], conditions, unique_trial_ids, representation='kinematics')\n",
+    "    \n",
+    "    # evaluate classifier on marble decoded\n",
+    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='marble_decoded')\n",
+    "    marble_model_acc.append(score)\n",
+    "    \n",
+    "    # evaluate classifier on cebra decoded\n",
+    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='cebra_decoded')\n",
+    "    cebra_model_acc.append(score)\n",
+    "    \n",
+    "    # evaluate classifier on lfads decoded\n",
+    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='lfads_decoded')\n",
+    "    lfads_model_acc.append(score)\n",
+    "\n",
+    "    # evaluate classifier on lfads decoded\n",
+    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='TDR_decoded')\n",
+    "    TDR_model_acc.append(score)\n",
+    "\n",
+    "    # evaluate classifier on firing_rates\n",
+    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='firing_rates_decoded')\n",
+    "    firing_rates_model_acc.append(score)\n",
+    "\n",
+    "results = pd.DataFrame(data=np.vstack([ marble_model_acc, cebra_model_acc, lfads_model_acc, TDR_model_acc, firing_rates_model_acc]).T,columns=['marble', 'cebra', 'LFADS', 'TDR', 'firing_rates'])\n",
+    "\n",
+    "results = results.melt()\n",
+    "results.columns = ['model','accuracy']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90c62030",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "f, ax = plt.subplots(figsize=(4,4))\n",
+    "sns.despine(bottom=True, left=True)\n",
+    "\n",
+    "sns.stripplot(\n",
+    "    data=results, x=\"model\", y=\"accuracy\",\n",
+    "    dodge=True, alpha=.5, zorder=1,\n",
+    ")\n",
+    "\n",
+    "sns.pointplot(\n",
+    "    data=results, x=\"model\", y=\"accuracy\",\n",
+    "    join=False, dodge=.8 - .8 / 3, palette=\"dark\",\n",
+    "    markers=\"d\", scale=.75, errorbar=None\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78d726e8-3a27-4e5e-b959-199d2de8199a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

data/examples/macaque_reaching/macaque_reaching_helpers.py

@@ -0,0 +1,218 @@
+import os
+from scipy.signal import savgol_filter
+from sklearn.decomposition import PCA
+from sklearn.svm import SVC
+import pickle
+import numpy as np
+import matplotlib.pyplot as plt
+
+conditions=['DownLeft','Left','UpLeft','Up','UpRight','Right','DownRight']
+
+def get_vector_array(coords):
+    """function for defining the vector features from each array of coordinates"""
+    diff = np.diff(coords, axis=0)
+    return diff
+
+
+def fit_pca(rates, day, conditions, filter_data=True, pca_n=5):
+    pos = []
+    # loop over each condition on that day
+    for c, cond in enumerate(conditions):
+
+        # go cue at 500ms (500ms / 20ms bin = 250)
+        # only take rates from bin 10 onwards
+        data = rates[day][cond][:, :, 25:]
+
+        # loop over all trials
+        for t in range(data.shape[0]):
+
+            # extract trial
+            trial = data[t, :, :]
+
+            # smooth trial over time
+            if filter_data:
+                trial = savgol_filter(trial, 9, 2)
+
+            # store each trial as time x channels
+            pos.append(trial.T)
+
+    # stacking all trials into a single array (time x channels)
+    pos = np.vstack(pos)
+
+    # fit PCA to all data across all conditions on a given day simultaneously
+    pca = PCA(n_components=pca_n)
+    pca.fit(pos)
+    
+    return pca
+
+
+def format_data(rates, trial_ids, day, conditions, pca=None, filter_data=True, go_cue=25, stack=True):
+    # create empty list of lists for each condition
+    pos = [[] for u in range(len(conditions))]
+    vel = [[] for u in range(len(conditions))]
+    timepoints = [[] for u in range(len(conditions))]
+    condition_labels = [[] for u in range(len(conditions))]
+    trial_indexes = [[] for u in range(len(conditions))]
+
+    # loop over conditions
+    for c, cond in enumerate(conditions):
+
+        # go cue at 500ms (500ms / 50ms bin = 10)
+        data = rates[day][cond][:, :, go_cue:]
+
+        # loop over all trials
+        for t in range(data.shape[0]):
+
+            # extract trial
+            trial = data[t, :, :]
+
+            # smooth trial over time
+            if filter_data:
+                trial = savgol_filter(trial, 9, 2)
+
+            # apply the transformation to a single trial
+            if pca is not None:
+                trial = pca.transform(trial.T)
+            else:
+                trial = trial.T
+
+            # take all points except last
+            pos[c].append(trial[:-1, :])
+
+            # extract vectors between coordinates
+            vel[c].append(get_vector_array(trial))
+            timepoints[c].append(np.linspace(0, trial.shape[0] - 2, trial.shape[0] - 1))
+            condition_labels[c].append(np.repeat(c, trial.shape[0] - 1))
+
+            # adding trial id info (to match with kinematics decoding later)
+            ind = np.repeat(trial_ids[day][cond][t], trial.shape[0] - 1)
+            trial_indexes[c].append(ind)
+
+    # stack the trials within each condition
+    if stack:
+        pos = [np.vstack(u) for u in pos]  # trials x time x channels
+        vel = [np.vstack(u) for u in vel]  # trials x time x channels
+        timepoints = [np.hstack(u) for u in timepoints]
+        condition_labels = [np.hstack(u) for u in condition_labels]
+        trial_indexes = [np.hstack(u) for u in trial_indexes]
+        
+    return pos, vel, timepoints, condition_labels, trial_indexes
+
+
+def train_OLE(data, trial_ids, representation='lfads_factors'):
+    
+    X, Z = [], []
+    unique_trial_ids = np.unique(trial_ids)
+    for tr in unique_trial_ids:
+        X.append(data[tr]['kinematics'])
+        Z.append(data[tr][representation])
+
+    X, Z = np.hstack(X), np.hstack(Z)
+
+    X = X[:4,:] # take first four rows of kinematics (pos_x, pos_y, vel_x, vel_y)
+    Z = np.vstack([Z,np.ones(Z.shape[1])])
+    
+    out  = np.linalg.lstsq(Z.T, X.T, rcond=None)
+    Lw = out[0].T
+    
+    return Lw
+    
+    
+def decode_kinematics(data, L, dt=20, representation='lfads_factors'):
+    
+    trial_emb = data[representation] # get trial embedding
+    trial_kinematics = data['kinematics'] # get kinematics associated with trial
+
+    trial_emb = np.vstack([trial_emb, np.ones(trial_emb.shape[1])])
+
+    # empty array for decoding predictions
+    trial_pred = np.empty([4, trial_kinematics.shape[1]])
+    trial_pred[:] = np.nan
+
+    trial_pred[:2,0] = trial_kinematics[:2,0] #first two entries are the x,y coordinates
+
+    # predict velocity 
+    z = np.matmul(L, trial_emb[:,0]); # decode
+    trial_pred[[2,3],0] = z[[2,3]] #velocities
+
+    # loop over each time point in trial
+    for nt in range(1,trial_kinematics.shape[1]):
+
+        neural = trial_emb[:,nt] # next point of embedding
+        z = np.matmul(L, neural) # decode
+
+        #trial_pred[:2,nt] = (1-alpha) * z[:2] + alpha * (trial_pred[:2,nt-1] + z[[2,3]]*dt/1000)
+        trial_pred[:2,nt] = trial_pred[:2,nt-1] + z[[2,3]]*dt/1000
+        trial_pred[[2,3],nt] = z[[2,3]]
+
+    return trial_pred
+
+# define a function for computing R-squared of kinematics
+def correlation(data, trial_ids, representation='lfads_factors'):
+    
+    X, Z = [], []
+    for tr in trial_ids:
+        X.append(data[tr]['kinematics'])
+        Z.append(data[tr][representation][:,:])
+
+    X, Z = np.hstack(X), np.hstack(Z)
+
+    r2_vel = np.mean([calcR2(X[2,:], Z[2,:]), calcR2(X[3,:], Z[3,:])])
+    r2_pos = np.mean([calcR2(X[0,:], Z[0,:]), calcR2(X[1,:], Z[1,:])])
+   
+    return r2_pos, r2_vel
+
+def calcR2(data, model):
+    
+    datavar = sum((data-np.mean(data))**2);
+    errorvar = sum((model-data)**2);
+    r2 = 1-errorvar/datavar   
+    
+    return r2
+
+def plot_kinematics(data, session, trial_ids, representation='lfads_factors', ax=None, sz = 140):
+    colors = plt.cm.viridis(np.linspace(0,1,7))        
+    
+    if ax is None:
+        fig, ax = plt.subplots(1,1)
+    
+    for c,cond in enumerate(conditions):   
+        for t in trial_ids:
+            if data[session][t]['condition']==cond:
+                meh = data[session][t][representation]
+                ax.plot(meh[0,:],meh[1,:],c=colors[c])
+                
+    ax.set_title(representation)
+    ax.set_xlim([-sz, sz])
+    ax.set_ylim([-sz, sz])
+    ax.set_axis_off()
+    
+    return ax
+
+def fit_classifier(data, conditions, trials, representation):
+    samples = []; labels = [];
+    for c,cond in enumerate(conditions):   
+        for t in trials:
+            if data[t]['condition']==cond:
+                sample = data[t][representation][:2,:].flatten()
+                samples.append(sample)
+                labels.append(c)
+
+    X = np.vstack(samples)
+    y = np.array(labels)
+    clf = SVC().fit(X, y)
+
+    return clf
+
+def transform_classifier(clf, data, conditions, trials, representation):
+    samples = []; labels = [];
+    for c,cond in enumerate(conditions):   
+        for t in trials:
+            if data[t]['condition']==cond:
+                sample = data[t][representation][:2,:].flatten()
+                samples.append(sample)
+                labels.append(c)
+
+    X = np.vstack(samples)
+    y = np.array(labels)
+    return clf.score(X, y)

data/examples/macaque_reaching/plot_MARBLE_representations.ipynb

@@ -0,0 +1,390 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "713d155f",
+   "metadata": {},
+   "source": [
+    "# Visualisations of MARBLE embeddings\n",
+    "\n",
+    "This notebook visualises the MARBLE latent representations of the macaque arm-reaching data obtained from binned spike counts with 20ms bin size.\n",
+    "\n",
+    "We would like to thank the authors of LFADS for making this data accessible and answering our questions about the data!\n",
+    "\n",
+    "### Note: the notebook relies on plotly, which may not work on all browsers. If you encounter issues on one browser (e.g., Chrome), just change to another (e.g., Firefox)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f439545",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "    \n",
+    "!pip install plotly\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import matplotlib.pylab as pl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import plotly\n",
+    "import plotly.graph_objs as go\n",
+    "from sklearn.decomposition import PCA\n",
+    "\n",
+    "import pickle\n",
+    "\n",
+    "from sklearn.metrics import pairwise_distances\n",
+    "import torch.nn as nn\n",
+    "import torch\n",
+    "\n",
+    "from MARBLE import geometry "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78f3d637",
+   "metadata": {},
+   "source": [
+    "## Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed5d3773",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# insert the pickle file of results that you want to visualise\n",
+    "!mkdir data\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7062022 -O data/marble_embeddings_out3_pca10_100ms.pkl\n",
+    "\n",
+    "with open('./data/marble_embeddings_out3_pca10_100ms.pkl', 'rb') as handle:\n",
+    "    data = pickle.load(handle)\n",
+    "    \n",
+    "distance_matrices = data[0]\n",
+    "embeddings = data[1]\n",
+    "timepoints = data[2]\n",
+    "labels = data[3]\n",
+    "sample_inds = data[4]\n",
+    "trial_ids = data[5]\n",
+    "\n",
+    "# condition labels\n",
+    "conditions=['DownLeft','Left','UpLeft','Up','UpRight','Right','DownRight']\n",
+    "\n",
+    "# load kinematics\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6969885 -O data/kinematics.pkl\n",
+    "\n",
+    "with open('data/kinematics.pkl', 'rb') as handle:\n",
+    "    kinematic_data =  pickle.load(handle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e1ed943",
+   "metadata": {},
+   "source": [
+    "# Generate 3D plots for a selection of sessions\n",
+    "\n",
+    "Lets first do this for the MARBLE data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ce5b649",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = pl.cm.viridis(np.linspace(0,1,7))\n",
+    "\n",
+    "# Configure Plotly to be rendered inline in the notebook.\n",
+    "plotly.offline.init_notebook_mode()\n",
+    "\n",
+    "# looping over 10 different sessions\n",
+    "examples = [5,6,8,11,14,15,18,23,26,32] # these sessions were used in Figure S7\n",
+    "for d, i in enumerate(examples):\n",
+    "    emb = embeddings[d]\n",
+    "    label = labels[d]\n",
+    "    time = np.hstack(timepoints[d])\n",
+    "    # Configure the trace.\n",
+    "    data = []\n",
+    "\n",
+    "    for i in range(7):\n",
+    "        trace = go.Scatter3d(\n",
+    "            x=emb[label==i,0],  \n",
+    "            y=emb[label==i,1],  \n",
+    "            z=emb[label==i,2],  \n",
+    "            mode='markers',\n",
+    "            marker={\n",
+    "                'size': 1,\n",
+    "                'opacity': 1,\n",
+    "                'color':'rgb({},{},{})'.format(colors[i,0],colors[i,1],colors[i,2]),  # set color to an array/list of desired values\n",
+    "            },\n",
+    "        )\n",
+    "        data.append(trace)\n",
+    "\n",
+    "    # Configure the layout.\n",
+    "    layout = go.Layout(\n",
+    "        paper_bgcolor='rgba(0,0,0,0)',\n",
+    "        plot_bgcolor='rgba(0,0,0,0)',\n",
+    "        xaxis=dict(showgrid=False,showline=False),\n",
+    "        yaxis=dict(showgrid=False,showline=False)\n",
+    "    )\n",
+    "\n",
+    "    plot_figure = go.Figure(data=data, layout=layout)\n",
+    "    plot_figure.update_scenes(xaxis_visible=False, yaxis_visible=False,zaxis_visible=False )\n",
+    "\n",
+    "    # Render the plot.\n",
+    "    plot_figure.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aded605d",
+   "metadata": {},
+   "source": [
+    "Lets now compare this with the LFADS embeddings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "633c32e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = pl.cm.viridis(np.linspace(0,1,7))\n",
+    "\n",
+    "# Configure Plotly to be rendered inline in the notebook.\n",
+    "plotly.offline.init_notebook_mode()\n",
+    "\n",
+    "for i in range(len(examples)):\n",
+    "    d = examples[i]\n",
+    "    \n",
+    "    \n",
+    "    lfads_data = [[] for cond in conditions]\n",
+    "    all_data = []\n",
+    "    for c,cond in enumerate(conditions):   \n",
+    "        for t in kinematic_data[d].keys():\n",
+    "            if kinematic_data[d][t]['condition']==cond:\n",
+    "                meh = kinematic_data[d][t]['lfads_factors']\n",
+    "                lfads_data[c].append(meh)\n",
+    "                all_data.append(meh)\n",
+    "\n",
+    "    lfads_data = [np.hstack(u) for u in lfads_data]\n",
+    "    all_data = np.hstack(all_data)            \n",
+    "\n",
+    "    # need to PCA high dimension lfads data\n",
+    "    pca = PCA(n_components=3)\n",
+    "    pca.fit(all_data.T)  \n",
+    "    \n",
+    "    \n",
+    "    # Configure the trace.\n",
+    "    data = []\n",
+    "\n",
+    "    for i in range(7):\n",
+    "        emb = pca.transform(lfads_data[i].T)\n",
+    "        trace = go.Scatter3d(\n",
+    "            x=emb[:,0],  \n",
+    "            y=emb[:,1],  \n",
+    "            z=emb[:,2],  \n",
+    "            mode='markers',\n",
+    "            marker={\n",
+    "                'size': 1,\n",
+    "                'opacity': 1,\n",
+    "                'color':'rgb({},{},{})'.format(colors[i,0],colors[i,1],colors[i,2]),  # set color to an array/list of desired values\n",
+    "            },\n",
+    "        )\n",
+    "        data.append(trace)\n",
+    "\n",
+    "    # Configure the layout.\n",
+    "    layout = go.Layout(\n",
+    "        paper_bgcolor='rgba(0,0,0,0)',\n",
+    "        plot_bgcolor='rgba(0,0,0,0)',\n",
+    "        xaxis=dict(showgrid=False,showline=False),\n",
+    "        yaxis=dict(showgrid=False,showline=False)\n",
+    "    )\n",
+    "\n",
+    "    plot_figure = go.Figure(data=data, layout=layout)\n",
+    "    plot_figure.update_scenes(xaxis_visible=False, yaxis_visible=False,zaxis_visible=False )\n",
+    "    \n",
+    "    # Render the plot.\n",
+    "    plot_figure.show()\n",
+    "    #plotly.offline.iplot(plot_figure)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a6bd5db",
+   "metadata": {},
+   "source": [
+    "# Average distance matrix across sessions "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92385113",
+   "metadata": {},
+   "source": [
+    "Lets see what the average distance matrix looks like across sessions for MARBLE."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7901f815",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plot average distance matrix based on clustering\n",
+    "plt.figure()\n",
+    "plt.imshow(np.mean(np.dstack(distance_matrices),2)); plt.colorbar()  \n",
+    "\n",
+    "emb_MDS, _ = geometry.embed(np.mean(np.dstack(distance_matrices),2), embed_typ = 'MDS')\n",
+    "plt.figure()\n",
+    "plt.scatter(emb_MDS[:,0],emb_MDS[:,1],c=np.linspace(0,6,7))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24ee2248",
+   "metadata": {},
+   "source": [
+    "how does this compare with LFADS?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "506ec87d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# we first need to compute distance matrices for lfads \n",
+    "\n",
+    "distance_matrices_lfads = []\n",
+    "\n",
+    "# loop over sessions and compute distance matrices\n",
+    "for d in range(len(embeddings)):\n",
+    "    \n",
+    "    lfads_data = [[] for cond in conditions]\n",
+    "    for t in kinematic_data[d].keys():\n",
+    "        for c,cond in enumerate(conditions):   \n",
+    "            if kinematic_data[d][t]['condition'] == cond:\n",
+    "                meh = kinematic_data[d][t]['lfads_factors']\n",
+    "                lfads_data[c].append(meh)\n",
+    "    \n",
+    "    lfads_data = [np.hstack(u).T for u in lfads_data]\n",
+    "    \n",
+    "    distances = np.zeros([len(conditions), len(conditions)])\n",
+    "    for i in range(len(conditions)):\n",
+    "        for j in range(len(conditions)):\n",
+    "            if i == j:\n",
+    "                distances[i,j] = 0\n",
+    "            else:\n",
+    "                distances[i,j] = pairwise_distances(lfads_data[i], lfads_data[j]).mean()\n",
+    "                \n",
+    "    distances = distances/np.std(distances)\n",
+    "    distance_matrices_lfads.append(distances)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8afa280",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plot average distance matrix based on clustering\n",
+    "plt.figure()\n",
+    "plt.imshow(np.mean(np.dstack(distance_matrices_lfads),2))\n",
+    "plt.colorbar()  \n",
+    "\n",
+    "emb_MDS, _ = geometry.embed(np.mean(np.dstack(distance_matrices_lfads),2), embed_typ='MDS')\n",
+    "plt.figure()\n",
+    "plt.scatter(emb_MDS[:,0], emb_MDS[:,1], c=np.linspace(0,6,7))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc8ab5d4",
+   "metadata": {},
+   "source": [
+    "Both are pretty good in terms of their average embeddings!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4bd33cf",
+   "metadata": {},
+   "source": [
+    "# Plotting individual session embeddings\n",
+    "\n",
+    "Here we just want to plot the distance matrix for individual sessions (Fig S7)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad42d324",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "fig, axs = plt.subplots(4,len(examples),figsize=(15,5))\n",
+    "\n",
+    "# loop over example sessions\n",
+    "for i,idx in enumerate(examples):\n",
+    "    \n",
+    "    # plot distance matrix for marble\n",
+    "    axs[0, i].imshow(distance_matrices[idx])\n",
+    "    \n",
+    "    # plot distance matrix for LFADS\n",
+    "    axs[1, i].imshow(distance_matrices_lfads[idx])    \n",
+    "\n",
+    "    # plot MDS embedding of MARBLE distance matrix\n",
+    "    emb_MDS, _ = geometry.embed(distance_matrices[idx], embed_typ = 'MDS')\n",
+    "    axs[2, i].scatter(emb_MDS[:,0],emb_MDS[:,1],c=np.linspace(0,6,7))\n",
+    "    \n",
+    "    # plot MDS embedding of LFADS distance matrix\n",
+    "    emb_MDS, _ = geometry.embed(distance_matrices_lfads[idx], embed_typ = 'MDS')\n",
+    "    axs[3, i].scatter(emb_MDS[:,0],emb_MDS[:,1],c=np.linspace(0,6,7))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bf65406-eeef-4c64-9786-1b54993caf45",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

data/examples/macaque_reaching/plot_vector_fields.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9dbe513",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib widget\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.cm as cm\n",
+    "import mat73\n",
+    "import pickle\n",
+    "\n",
+    "import MARBLE\n",
+    "from MARBLE import plotting\n",
+    "\n",
+    "from sklearn.decomposition import PCA\n",
+    "\n",
+    "import neo\n",
+    "from elephant.statistics import instantaneous_rate\n",
+    "from elephant.kernels import GaussianKernel\n",
+    "from quantities import ms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fd6f954",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load data compiled into matlab cell array\n",
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6963157 -O data/conditions_spiking_data.mat\n",
+    "spiking_data = mat73.loadmat('data/conditions_spiking_data.mat')['all_results']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c578b742",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trial = 1\n",
+    "session = 9\n",
+    "\n",
+    "spikes, colors = [], []\n",
+    "for cond in range(7):\n",
+    "    st = spiking_data[session][cond][trial][0][:,:]\n",
+    "    spikes += [np.where(st[ch,:])[0] for ch in range(24)]\n",
+    "    colors += [cm.viridis(cond / 6) for _ in range(24)]\n",
+    "\n",
+    "_, ax = plt.subplots(figsize=(5,4))\n",
+    "ax.eventplot(spikes, color=colors)\n",
+    "\n",
+    "_, ax = plt.subplots(figsize=(5,4))\n",
+    "gk = GaussianKernel(100 * ms) # increase this for smoother signals (previously used auto)\n",
+    "\n",
+    "for sp in spikes[:24]:\n",
+    "    st = neo.SpikeTrain(sp, units='ms', t_stop=1200)\n",
+    "                        \n",
+    "    inst_rate = instantaneous_rate(st, kernel=gk, sampling_period=1 * ms).magnitude\n",
+    "    ax.plot(inst_rate, 'C0')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4424eb17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7062086 -O data/raw_data_session_9_3D.pkl\n",
+    "pos, vel, time, _ = pickle.load(open('data/raw_data_session_9_3D.pkl','rb'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d8a958a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = plt.figure(figsize=(10,5))\n",
+    "n_traj=10\n",
+    "from matplotlib.colors import LinearSegmentedColormap\n",
+    "from mpl_toolkits.mplot3d.art3d import Line3DCollection\n",
+    "\n",
+    "for i,cond in enumerate([1,4,6]):\n",
+    "    ax = fig.add_subplot(int('13{}'.format(i+1)), projection='3d')\n",
+    "    ax.view_init(elev=10., azim=90)\n",
+    "    starts = np.where(time[cond]==0)[0]\n",
+    "    for j in range(n_traj):\n",
+    "        t = range(starts[j], starts[j+1]-1)\n",
+    "        p = pos[cond][t]\n",
+    "        segments = np.stack([p[:-1], p[1:]], axis=1)\n",
+    "        \n",
+    "        colors = [(0, 0, 0), cm.viridis(cond/6)] # first color is black, last is red\n",
+    "        cmap = LinearSegmentedColormap.from_list(\"Custom\", colors, N=len(time[cond][t]))\n",
+    "        r = cmap(np.linspace(0,1,len(time[cond][t])))\n",
+    "        \n",
+    "        ax.add_collection(Line3DCollection(segments,colors=list(r)))\n",
+    "        ax.set_xlim([min(pos[cond][:,0]), max(pos[cond][:,0])])\n",
+    "        ax.set_ylim([min(pos[cond][:,1]), max(pos[cond][:,1])])\n",
+    "        ax.set_zlim([min(pos[cond][:,2]), max(pos[cond][:,2])])\n",
+    "        \n",
+    "        ax.scatter(pos[cond][starts[j],0],pos[cond][starts[j],1],pos[cond][starts[j],2],color=colors[0])\n",
+    "        ax.scatter(pos[cond][starts[j+1]-1,0],pos[cond][starts[j+1]-1,1],pos[cond][starts[j+1]-1,2],color=colors[1])\n",
+    "        ax.get_xaxis().set_ticks([])\n",
+    "        ax.get_yaxis().set_ticks([])\n",
+    "        ax.get_zaxis().set_ticks([])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b0b713",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = MARBLE.construct_dataset(pos, features=vel, graph_type='cknn', k=10, stop_crit=0.05, local_gauges=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb29a0b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_plot = data.to_data_list()\n",
+    "for i in [1,4,6]:\n",
+    "    d = data_plot[i]\n",
+    "    c = [(0, 0, 0), cm.viridis(i/6)] # first color is black, last is Ci\n",
+    "    cmap = LinearSegmentedColormap.from_list(\"Custom\", c, N=140)\n",
+    "    ind = np.linspace(0,1,140)\n",
+    "    colors = cmap(ind[time[i][d.sample_ind].astype(int)])\n",
+    "    plotting.fields([d], view=(10,90), figsize=(3,3), scale=2, width=7., color=colors, axes_visible=False)\n",
+    "    plt.axis('on')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43d0816b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

data/examples/macaque_reaching/run_cebra.py

@@ -0,0 +1,112 @@
+import pickle
+import os
+import sys
+import numpy as np
+from scipy.signal import savgol_filter
+from sklearn.decomposition import PCA
+from sklearn.neighbors import LocalOutlierFactor
+from macaque_reaching_helpers import fit_pca, format_data
+from tqdm import tqdm
+from cebra import CEBRA
+
+
+def main():
+
+    """fitting model for each day + pca embedding"""
+    
+    data_file = "data/rate_data_20ms.pkl"
+    metadata_file = "data/trial_ids.pkl"
+    
+    rates = pickle.load(open(data_file, "rb"))
+    trial_ids = pickle.load(open(metadata_file, "rb"))
+
+    # defining the set of conditions
+    conditions = ["DownLeft", "Left", "UpLeft", "Up", "UpRight", "Right", "DownRight"]
+
+    # list of days
+    days = rates.keys()
+
+    # define some parameters
+    pca_n = 5
+    filter_data = True
+
+    # storing all distance matrices
+    embeddings = []
+    distance_matrices = []
+    times = [] # to store the time point of each node in the trajectory
+    all_condition_labels = [] # to store the condition label for each node
+    all_trial_ids = [] # trial ids for each node
+    all_sampled_ids = [] # to store all the nodes sampled by marble
+    
+    # loop over each day
+    for day in tqdm(days):
+
+        # first stack all trials from that day together and fit pca
+        print(day)
+        pca = fit_pca(rates, day, conditions, filter_data=filter_data, pca_n=pca_n)
+        pos, vel, timepoints, condition_labels, trial_indexes = format_data(rates, 
+                                                                            trial_ids,
+                                                                            day, 
+                                                                            conditions, 
+                                                                            pca=pca,
+                                                                            filter_data=filter_data)
+            
+        
+        cebra_model = CEBRA(model_architecture='offset10-model',
+                        batch_size=512,
+                        learning_rate=0.0001,
+                        temperature=1,
+                        output_dimension=20,
+                        max_iterations=5000,
+                        distance='euclidean',
+                        conditional='time_delta',
+                        device='cuda_if_available',
+                        verbose=True,
+                        time_offsets=10)
+
+        pos_all = np.vstack(pos)
+        condition_labels = np.hstack(condition_labels)
+        cebra_model.fit(pos_all, condition_labels)
+        cebra_pos = cebra_model.transform(pos_all)
+
+        cebra_model.save("data/session_{}_20ms.pt".format(day))
+
+        embeddings.append(cebra_pos)
+        distance_matrices.append([])
+        times.append(np.hstack(timepoints))
+        all_condition_labels.append(np.hstack(condition_labels))
+        all_trial_ids.append(np.hstack(trial_indexes))
+        all_sampled_ids.append([])
+
+        # save over after each session (incase computations crash)
+        with open("data/cebra_embeddings_20ms_out20.pkl", "wb") as handle:
+            pickle.dump(
+                [
+                    distance_matrices,
+                    embeddings,
+                    times,
+                    all_condition_labels,
+                    all_trial_ids,
+                    all_sampled_ids,
+                ],
+                handle,
+                protocol=pickle.HIGHEST_PROTOCOL,
+            )
+
+    # final save
+    with open("data/cebra_embeddings_20ms_out20.pkl", "wb") as handle:
+        pickle.dump(
+            [
+                distance_matrices,
+                embeddings,
+                times,
+                all_condition_labels,
+                all_trial_ids,
+                all_sampled_ids,
+            ],
+            handle,
+            protocol=pickle.HIGHEST_PROTOCOL,
+        )
+
+if __name__ == "__main__":
+    sys.exit(main())