tsdr 0.1__tar.gz → 0.2__tar.gz

{tsdr-0.1 → tsdr-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsdr
-Version: 0.1
+Version: 0.2
 Summary: Time-series dimension reduction
 Author-Email: Kieran S Owens <kowe6911@uni.sydney.edu.au>
 Maintainer-Email: Kieran S Owens <kowe6911@uni.sydney.edu.au>
@@ -27,9 +27,9 @@ Description-Content-Type: text/markdown
 
 ## About
 
-Time-series dimension reduction (TSDR) methods are a class of algorithms for the dimension reduction of multivariate data that exploit temporal structure. As compared to general dimension reduction (GDR) methods, the outputs of which are invariant to temporal permutation, TSDR methods are sensitive to temporal structure.
+Time-series dimension reduction (TSDR) methods are a class of algorithms for the dimension reduction of multivariate data that exploit temporal structure. In contrast to general dimension reduction (GDR) methods, the outputs of which are invariant to temporal permutation, TSDR methods are sensitive to temporal structure.
 
-The figure above visually summarises the categories of TSDR methods that we defined in Owens & Fulcher (2025). The first five categories (a-e) consist of methods that extract time-series components based on different aspects of temporal structure, i.e., slowness, autocorrelation, predictability, determinism, and non-stationarity. The final two categories (f-g) consist of methods that share a common methodology, i.e., diffusion-based and latente variable methods.
+The figure above visually summarises the categories of TSDR methods that we defined in Owens & Fulcher (2025). The first five categories (a-e) consist of methods that extract time-series components based on different aspects of temporal structure, i.e., slowness, autocorrelation, predictability, determinism, and non-stationarity. The final two categories (f-g) consist of methods that share a common methodology, i.e., diffusion-based and latent variable methods.
 
 The <em>tsdr</em> package provides python implementations of TSDR methods from each of these seven categories. The methods are written in a simple, readable style to enable time-series analysts to better understand a subset of the TSDR methods discussed in the Owens & Fulcher (2025) review paper.
 

{tsdr-0.1 → tsdr-0.2}/README.md

@@ -10,9 +10,9 @@
 
 ## About
 
-Time-series dimension reduction (TSDR) methods are a class of algorithms for the dimension reduction of multivariate data that exploit temporal structure. As compared to general dimension reduction (GDR) methods, the outputs of which are invariant to temporal permutation, TSDR methods are sensitive to temporal structure.
+Time-series dimension reduction (TSDR) methods are a class of algorithms for the dimension reduction of multivariate data that exploit temporal structure. In contrast to general dimension reduction (GDR) methods, the outputs of which are invariant to temporal permutation, TSDR methods are sensitive to temporal structure.
 
-The figure above visually summarises the categories of TSDR methods that we defined in Owens & Fulcher (2025). The first five categories (a-e) consist of methods that extract time-series components based on different aspects of temporal structure, i.e., slowness, autocorrelation, predictability, determinism, and non-stationarity. The final two categories (f-g) consist of methods that share a common methodology, i.e., diffusion-based and latente variable methods.
+The figure above visually summarises the categories of TSDR methods that we defined in Owens & Fulcher (2025). The first five categories (a-e) consist of methods that extract time-series components based on different aspects of temporal structure, i.e., slowness, autocorrelation, predictability, determinism, and non-stationarity. The final two categories (f-g) consist of methods that share a common methodology, i.e., diffusion-based and latent variable methods.
 
 The <em>tsdr</em> package provides python implementations of TSDR methods from each of these seven categories. The methods are written in a simple, readable style to enable time-series analysts to better understand a subset of the TSDR methods discussed in the Owens & Fulcher (2025) review paper.
 

{tsdr-0.1 → tsdr-0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsdr"
-version = "0.1"
+version = "0.2"
 authors = [
     { name = "Kieran S Owens", email = "kowe6911@uni.sydney.edu.au" },
 ]

{tsdr-0.1 → tsdr-0.2}/tsdr/autocorrelation.py

@@ -480,8 +480,9 @@ class CSA():
         The dimension (number of variables) of the time-series output.
         Default: 1.
 
-    lag: int
-        The maximum time lag at which to compute autocorrelation.
+    lag: int or list
+        The maximum time lag at which to compute autocorrelation,
+        or else a list of specified lags.
         Default: 1.
 
     method: str
@@ -497,13 +498,13 @@ class CSA():
         to the input time series X.
     """
 
-    def __init__(self, n_components=1, lags=2, max_iters=1000):
+    def __init__(self, n_components=1, lag=2, max_iters=1000):
 
         self.n_components = n_components
-        if isinstance(lags, int):
-            self.lags = range(1, lags+1)
-        elif isinstance(lags, list):
-            self.lags = lags
+        if isinstance(lag, int):
+            self.lags = range(1, lag+1)
+        elif isinstance(lag, list):
+            self.lags = list(lag)
         self.max_iters = max_iters
 
     def fit(self, X, y=None):
@@ -661,7 +662,7 @@ class sPCA_dwt():
 
     whiten: bool
         Whether to whiten the data.
-        Default: False.
+        Default: True
 
     method: str
         Whether to use PCA or SVD. Options: 'pca' or 'svd'.

{tsdr-0.1 → tsdr-0.2}/tsdr/diffusion.py

@@ -156,12 +156,12 @@ class DMcov():
             Wnorm = D_neg_root @ W @ D_neg_root
 
             # eigendecomposition
-            _, eigvecs = np.linalg.eig(Wnorm)
+            _, eigvecs = np.linalg.eigh(Wnorm)
 
         else:
 
             # eigendecomposition
-            _, eigvecs = np.linalg.eig(D - W)
+            _, eigvecs = np.linalg.eigh(D - W)
 
         self.components = eigvecs[:,1:1+self.n_components]
 
@@ -292,8 +292,10 @@ class DIG():
         for i in range(D):
             for j in range(D):
                 if i != j:
-                    W[i,j] += 0.5*(np.exp(-G[i,j]/knn_k[i])**self.alpha)
-                    W[i,j] += 0.5*(np.exp(-G[i,j]/knn_k[j])**self.alpha)
+                    # W[i,j] += 0.5*(np.exp(-G[i,j]/knn_k[i])**self.alpha)
+                    # W[i,j] += 0.5*(np.exp(-G[i,j]/knn_k[j])**self.alpha)
+                    W[i,j] += 0.5*np.exp(-(G[i,j]/knn_k[i])**self.alpha)
+                    W[i,j] += 0.5*np.exp(-(G[i,j]/knn_k[j])**self.alpha)
 
         return W
     
@@ -311,7 +313,7 @@ class DIG():
 
         kneedle = KneeLocator(range(1, self.tmax + 1), vne, 
                             S=1.0, curve='convex', direction='decreasing')
-        return int(kneedle.elbow)
+        return int(kneedle.elbow) if kneedle.elbow is not None else self.tmax//2
     
     # computation of information distance
     def _information_distance(self, W):
@@ -332,7 +334,7 @@ class DIG():
 
         N = D.shape[0]
         H = np.eye(N) - np.ones((N, N)) / N
-        K = -0.5 * (H @ D @ H)
+        K = -0.5 * (H @ (D **2) @ H)
         eigenvals, eigenvecs = np.linalg.eigh(K)
         eigenvals_sorted = eigenvals.argsort()[::-1]
         idxs = eigenvals_sorted[:self.n_components]

{tsdr-0.1 → tsdr-0.2}/tsdr/latentvariable.py

@@ -140,6 +140,7 @@ class LDS():
 
         # Sum expectations over time
         sum_Exx = Exx.sum(axis=0)           # \sum_t E[x_t x_t^T]
+        sum_Exx0 = Exx[:-1].sum(axis=0)      # sum_{t=1}^{T-1}
         sum_Exx1 = Exx[1:].sum(axis=0)      # \sum_{t=2}^T E[x_t x_t^T]
         sum_Exxm1 = Exxm1.sum(axis=0)       # \sum_{t=2}^T E[x_t x_{t-1}^T]
 
@@ -147,11 +148,12 @@ class LDS():
         if self.constrain_A_identity:
             A = np.eye(d)
         else:
-            A = sum_Exxm1 @ pinv(sum_Exx1)
+            A = sum_Exxm1 @ pinv(sum_Exx0)
 
         # Update the latent state noise covariance matrix Q, Eq. (20)
         # and enforce symmetry
-        Q = (sum_Exx1 - A @ sum_Exxm1.T) / (T - 1)
+        #Q = (sum_Exx1 - A @ sum_Exxm1.T) / (T - 1)
+        Q = (sum_Exx1 - A @ sum_Exxm1.T - sum_Exxm1 @ A.T + A @ sum_Exx0 @ A.T) / (T - 1)
         Q = (Q + Q.T) / 2  
 
         # Update the output/Observation matrix C, Eq. (14)

{tsdr-0.1 → tsdr-0.2}/tsdr/nonstationarity.py

@@ -118,7 +118,7 @@ class ASSA():
         S = self._compute_S(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(S)
+        eigvals, eigvecs = np.linalg.eigh(S)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # eigenvalues
@@ -269,7 +269,7 @@ class SSAsir():
         Mm = self._compute_Mm(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(Mm)
+        eigvals, eigvecs = np.linalg.eigh(Mm)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -417,7 +417,7 @@ class SSAsave():
         Mv = self._compute_Mv(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(Mv)
+        eigvals, eigvecs = np.linalg.eigh(Mv)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -575,7 +575,7 @@ class SSAcor():
         Mtau = self._compute_Mtau(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(Mtau)
+        eigvals, eigvecs = np.linalg.eigh(Mtau)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -777,7 +777,7 @@ class WaSSAf():
         S = self._compute_S(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(S)
+        eigvals, eigvecs = np.linalg.eigh(S)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -937,7 +937,7 @@ class WaSSAr():
         S = self._compute_S(Xw)
 
         # eigendecomposition of S
-        eigvals, eigvecs = np.linalg.eig(S)
+        eigvals, eigvecs = np.linalg.eigh(S)
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -1067,7 +1067,7 @@ class BSSnonstat():
         T, D = X0.shape
 
         # matrix used during optimisation
-        M = X0.T @ Xlag + Xlag.T @ X0
+        M = (X0.T @ Xlag + Xlag.T @ X0) / T
 
         # collect projection vectors
         W = []
@@ -1084,12 +1084,12 @@ class BSSnonstat():
                 e1 = np.zeros(shape=w.shape)
                 e2 = np.zeros(shape=w.shape)
 
-                for i in range(T - self.lag):
+                for i in range(T):
                     ztau = Xlag[i,:].reshape(-1,1)
                     zt = X0[i,:].reshape(-1,1)
 
-                    e1 += (zt @ w.T @ zt @ (w.T @ ztau)**2)/(T - self.lag)
-                    e2 += (ztau @ w.T @ ztau @ (w.T @ zt)**2) / (T - self.lag)
+                    e1 += (zt @ w.T @ zt @ (w.T @ ztau)**2)/T
+                    e2 += (ztau @ w.T @ ztau @ (w.T @ zt)**2) / T
 
                 w = e1 + e2 - 2*w - M @ w @ (w.T @ M @ w)
                 w = w / np.linalg.norm(w)

{tsdr-0.1 → tsdr-0.2}/tsdr/predictability.py

@@ -95,7 +95,7 @@ class TLPC():
         Sigma = Ctau @ np.linalg.pinv(C0)
 
         # eigendecomposition of I - Sigma^2
-        eigvals, eigvecs = np.linalg.eig(np.eye(Sigma.shape[0]) - Sigma @ Sigma)
+        eigvals, eigvecs = np.real(np.linalg.eig(np.eye(Sigma.shape[0]) - Sigma @ Sigma))
         eigvecs_sorted = eigvecs[:,np.argsort(eigvals)]
 
         # get linear transformation
@@ -244,18 +244,17 @@ class PrCA():
 
         else:
 
-            # (empty) time series of prediction errors (i.e., residuals)
-            E = np.zeros((T - (self.p + self.lag), D))
+            # prediction errors have T - (p + lag - 1) rows
+            E = np.zeros((T - (self.p + self.lag - 1), D))
 
-            # for each feature/variable
             for i in range(D):
 
                 # data to use for predictions
                 x = X[:,i]
-                x_p = self._tde(x[:-(self.lag+1)].reshape(-1,1), self.p, 1)
+                x_p = self._tde(x[:-self.lag].reshape(-1,1), self.p, 1)   # drop last `lag` points
 
                 # data to predict
-                y = x[self.p + self.lag:]
+                y = x[self.p - 1 + self.lag:]  
 
                 # fit a model using x_p and y
                 if self.model == 'linear_reg':
@@ -426,12 +425,11 @@ class DiCCA():
             # initialise AR weights beta
             beta = np.eye(self.s)[:,0]
 
-            # prediction (Ubeta) and prediction error (Utilde)
-            Ubeta = sum([U_list[i]*beta[i] for i in range(self.s)])
-            Utilde = Us - Ubeta
-
             # iteratively optimize transformation w and AR weights beta
             for _ in range(100):
+                # prediction (Ubeta) and prediction error (Utilde)
+                Ubeta = sum([U_list[i]*beta[i] for i in range(self.s)])
+                Utilde = Us - Ubeta
                 w = PCA().fit(Utilde).components_.T[:,-1]
                 t = U @ w
                 Ts = [beta[0] * U_list[0] @ w]