Modal-Decomposition 0.0.4__tar.gz → 0.0.5__tar.gz

{modal_decomposition-0.0.4 → modal_decomposition-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.0.4
+Version: 0.0.5
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0

{modal_decomposition-0.0.4 → modal_decomposition-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Modal-Decomposition"
-version = "0.0.4"
+version = "0.0.5"
 requires-python = ">=3.8"
 
 authors = [

modal_decomposition-0.0.5/src/Modal_Decomposition/SSA.py

@@ -0,0 +1,228 @@
+"""
+
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	numba - 0.64.0
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize SSA, and optimize the use of numba and SSAfast(function).
+
+Modify:  (must)
+    2026.3.25 - I forgot.
+    2026.3.29 - Optimize the SSA.decompose function, it's faster now. Please use SSA() which means SSA.decompose_fast().
+"""
+
+import numpy as np
+from typing import Union
+
+class SSA:
+    def __init__(self, window_size=None):
+        """
+        :param:
+        window_size: size of windows, default 1/3 of sequence
+        """
+        self.window_size = window_size
+        self.components_ = None
+        self.sigma_ = None
+        self.U_ = None
+        self.V_ = None
+
+
+    def __call__(self, S, groups=None, faster=False):
+        return self.decompose_fast(S, groups, faster)
+
+
+    def hankel(self, S, L):
+        N = len(S)
+        K = N - L + 1
+
+        _S = np.asarray(S)
+        strides = (_S.strides[0], _S.strides[0])
+        return np.lib.stride_tricks.as_strided(_S, shape=(L, K), strides=strides)
+
+    @staticmethod
+    def diagonal_average(X_rec: Union[list, np.ndarray], L: int, K: int) -> np.ndarray:
+        """
+        :param X_rec: 2-dim
+        :param L: int
+        :param K: int
+        :return: rc (2-dim)
+        """
+        if not isinstance(X_rec, np.ndarray):
+            X_rec = np.array(X_rec)
+
+        N = L + K - 1
+        rc = np.zeros(N)
+        for n in range(N):
+            i_min = max(0, n - K + 1)
+            i_max = min(L - 1, n)
+
+            total = 0.0
+            count = 0
+            for i in range(i_min, i_max + 1):
+                j = n - i
+                total += X_rec[i, j]
+                count += 1
+            rc[n] = total / count
+
+        return rc
+
+    @staticmethod
+    def diagonal_average_fast(X_rec: Union[list, np.ndarray], L: int, K:int) -> np.ndarray:
+        """
+        like 'diagonal_average'
+        :param X_rec:
+        :param L:
+        :param K:
+        :return: rc (2-dim)
+        """
+        N = L + K - 1
+        n_idx = np.add.outer(np.arange(L), np.arange(K)).flatten()
+        values = X_rec.flatten()
+
+        Sum = np.bincount(n_idx, weights=values, minlength=N)
+
+        counts = np.bincount(n_idx, minlength=N)
+
+        counts[counts == 0] = 1
+
+        rc = Sum / counts
+
+        return rc
+
+    def decompose(self, S: Union[list, np.ndarray],  groups=None) -> np.ndarray:
+        """
+        :param S: Signal (1-dim)
+        :param L:
+        :param groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
+
+        :return: IMFs (2-dim)
+        """
+        if not isinstance(S, np.ndarray):
+            S = np.array(S)
+
+        series = np.asarray(S).flatten()
+        N = len(S)
+
+        if self.window_size is None:
+            L = N // 3
+        else:
+            L = min(self.window_size, N // 2)
+
+        K = N - L + 1
+
+        X = np.zeros((L, K))
+        for i in range(K):
+            X[:, i] = series[i:i + L]
+
+        U, sigma, VT = np.linalg.svd(X, full_matrices=False)
+
+        idx = np.argsort(-sigma)
+        sigma = sigma[idx]
+        U = U[:, idx]
+        VT = VT[idx, :]
+
+        if groups is None:
+            groups = [[i] for i in range(len(sigma))]
+
+        RCs = []
+
+        for group in groups:
+            x_group = np.zeros((L, K))
+
+            for i in group:
+                x_group += sigma[i] * np.outer(U[:, i], VT[i, :])
+
+            rc = np.zeros(N)
+            count = np.zeros(N)
+            for i in range(L):
+                for j in range(K):
+                    d = i + j
+                    rc[d] += x_group[i, j]
+                    count[d] += 1
+
+            rc = rc / count
+            RCs.append(rc)
+
+        self.components_ = np.array(RCs)
+        self.sigma_ = sigma
+        self.U_ = U
+        self.V_ = VT
+
+        return self.components_
+
+    def decompose_fast(self, S: Union[list, np.ndarray], groups=None, faster: bool=False) -> np.ndarray:
+        """
+        :param S: Signal (1-dim)
+        :param L:
+        :param groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
+        :param faster: if you choose True, function will be faster with wasting memory.
+        :return: IMFs (2-dim)
+        """
+
+        if not isinstance(S, np.ndarray):
+            S = np.array(S)
+
+        N = len(S)
+
+        if self.window_size is None:
+            L = N // 3
+        else:
+            L = min(self.window_size, N // 2)
+
+        K = N - L + 1
+
+        x = self.hankel(S, L)
+
+        U, s, Vt = np.linalg.svd(x, full_matrices=False)
+
+        if groups is None:
+            groups = [[i] for i in range(len(s))]
+
+        RCs = []
+        for group in groups:
+            X_rec = np.zeros((L, K))
+
+            # X_rec = np.sum(s[group] * np.outer(U[:, group], Vt[group, :]), keepdims=True)
+            def f(i) -> np.ndarray:
+                temp = s[i] * np.outer(U[:, i], Vt[i, :])
+                return temp
+
+            if faster:
+                X_rec = np.add.reduce([f(i) for i in group])  # but, you should consider the memory with this code.
+
+            else:
+                for i in group:
+                    X_rec += f(i)  # also, you can use code above:
+
+            rc = self.diagonal_average_fast(X_rec, L, K)
+
+            RCs.append(rc)
+
+        return np.array(RCs)
+
+
+# def give_fast_SSA() -> Callable:
+#     from numba import njit
+#
+#     @njit
+#     def SSAfast(series, L):
+#         N = len(series)
+#         K = N - L + 1
+#
+#         X = np.zeros((L, K))
+#         for i in range(K):
+#             X[:, i] = series[i:i + L]
+#
+#         # SVD decomposition
+#         U, s, VT = np.linalg.svd(X, full_matrices=False)
+#
+#         return U, s, VT
+#
+#     return SSAfast

{modal_decomposition-0.0.4 → modal_decomposition-0.0.5}/src/Modal_Decomposition/__init__.py

@@ -26,6 +26,7 @@ Description: (if None write None)
 Modify:
     2026.3.25 - Optimize the cost of import, from 5.001s to 0.747s. Put some heavy lib into internal of the function
     2026.3.26 - Optimize the description of the type of input and output. now, the dim of input and output is more clear.
+    2026.3.29 - Optimize the SSA.decompose function, time changed from 40min averagely to 2s averagely.
 """
 from .help_function import is_increasing
 
@@ -75,7 +76,7 @@ class Function:
     EEMD = eemd
     FMD = fmd
     EWT = ewt
-    SSA = ssa_cls.decompose
+    SSA = ssa_cls
     RPSEMD = rpsemd
     CEEMD = ceemd
     MEMD = memd

{modal_decomposition-0.0.4 → modal_decomposition-0.0.5}/src/Modal_Decomposition.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.0.4
+Version: 0.0.5
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0

modal_decomposition-0.0.5/tests/test.py

@@ -0,0 +1,87 @@
+import time
+from typing import Callable, Any
+import numpy as np
+
+
+def time_show(f: Callable) -> Callable:
+    def F(*args, **kwargs):
+        this = time.time()
+        f(*args, **kwargs)
+        now = time.time()
+        delta = now - this
+        print(f"this function use {delta}s")
+
+    return F
+
+def check_result(**kwargs):
+    IMFs: np.ndarray = kwargs.get("IMFs", None)  # IMFs
+    Res: np.ndarray = kwargs.get("Res", None)  # Res
+    S: np.ndarray = kwargs.get("S", None)  # origin signal
+
+    RMSE = None
+    OI = None
+    R = None
+    MSE = None
+
+    if IMFs is None or IMFs.size == 0:
+        print("this function doesn't decompose the useful IMFs. Exit...")
+        return
+
+    if IMFs.ndim == 1:
+        IMFs = IMFs.reshape(1, -1)
+
+    Res = np.asarray(Res).flatten()
+
+    reconstructed = np.sum(IMFs, axis=0) + Res
+    # 计算 RMSE 和 MSE
+    mse = np.mean((S - reconstructed) ** 2)
+    rmse = np.sqrt(mse)
+    RMSE = rmse
+    MSE = mse
+
+    K, N = IMFs.shape
+    if K <= 1:
+        OI = 0.0
+
+    else:
+        corr_matrix = np.corrcoef(IMFs)
+
+        upper_tri = np.triu_indices_from(corr_matrix, k=1)
+        OI = np.mean(np.abs(corr_matrix[upper_tri]))
+
+        R = corr_matrix
+
+    print(f"RMSE={RMSE} | MES={MSE} | OI={OI} | R={R}")
+
+@time_show
+def test_SSA(S):
+    from src.Modal_Decomposition import Function as F
+    SSA = F.SSA
+
+    RCs = SSA(S)
+
+    IMFs = RCs[:-1, :]
+    Res = RCs[-1, :]
+
+    check_result(IMFs=IMFs, Res=Res, S=S)
+
+    return RCs
+
+
+if __name__ == '__main__':
+    t = np.arange(0, 1000, 1)
+    S = 1 + np.sin(t ** 2) + 4 * np.cos(3 * t - 1) - (np.sin(t + 3) * 9) ** 2
+
+    test_SSA(S)
+
+    # a = np.array \
+    # (
+    #     [
+    #         [1, 2, 3, 8],
+    #         [2, 5, 7, 2],
+    #         [3, 5, 1, 3],
+    #         [1, 4, 5, 2]
+    #     ]
+    # )
+    #
+    # print(a[[0, 1], 3])

modal_decomposition-0.0.4/src/Modal_Decomposition/SSA.py

@@ -1,113 +0,0 @@
-"""
-
-Python version:  (must)
-    3.10.11
-
-Lib and Version:  (if None write None)
-    numpy - 2.2.6
-	numba - 0.64.0
-
-Only accessed by:  (must)
-    Only __init__.py
-
-Modify:  (must)
-    2026.3.25
-
-Description: (if None write None)
-    Realize SSA, and optimize the use of numba and SSAfast(function).
-"""
-
-import numpy as np
-from typing import Union
-
-class SSA:
-    def __init__(self, window_size=None):
-        """
-        :param:
-        window_size: size of windows, default 1/3 of sequence
-        """
-        self.window_size = window_size
-        self.components_ = None
-        self.sigma_ = None
-        self.U_ = None
-        self.V_ = None
-
-    def decompose(self, S: Union[list, np.ndarray], groups=None) -> np.ndarray:
-        """
-        :param S: Signal (1-dim)
-        :param groups: group information, such as: [[0], [1,2], [3,4]] means which components will be merged. If None, return all
-
-        :return: IMFs (2-dim)
-        """
-        if not isinstance(S, np.ndarray):
-            S = np.array(S)
-
-        series = np.asarray(S).flatten()
-        N = len(series)
-
-        if self.window_size is None:
-            L = N // 3
-        else:
-            L = min(self.window_size, N // 2)
-
-        K = N - L + 1
-
-        X = np.zeros((L, K))
-        for i in range(K):
-            X[:, i] = series[i:i + L]
-
-        U, sigma, VT = np.linalg.svd(X, full_matrices=False)
-
-        idx = np.argsort(-sigma)
-        sigma = sigma[idx]
-        U = U[:, idx]
-        VT = VT[idx, :]
-
-        if groups is None:
-            groups = [[i] for i in range(len(sigma))]
-
-        RCs = []
-
-        for group in groups:
-            x_group = np.zeros((L, K))
-
-            for i in group:
-                x_group += sigma[i] * np.outer(U[:, i], VT[i, :])
-
-            rc = np.zeros(N)
-            count = np.zeros(N)
-            for i in range(L):
-                for j in range(K):
-                    d = i + j
-                    rc[d] += x_group[i, j]
-                    count[d] += 1
-
-            rc = rc / count
-            RCs.append(rc)
-
-        self.components_ = np.array(RCs)
-        self.sigma_ = sigma
-        self.U_ = U
-        self.V_ = VT
-
-        return self.components_
-
-
-# def give_fast_SSA() -> Callable:
-#     from numba import njit
-#
-#     @njit
-#     def SSAfast(series, L):
-#         N = len(series)
-#         K = N - L + 1
-#
-#         X = np.zeros((L, K))
-#         for i in range(K):
-#             X[:, i] = series[i:i + L]
-#
-#         # SVD decomposition
-#         U, s, VT = np.linalg.svd(X, full_matrices=False)
-#
-#         return U, s, VT
-#
-#     return SSAfast

modal_decomposition-0.0.4/tests/test.py

@@ -1,12 +0,0 @@
-import time
-now = time.time()
-
-now = time.time() - now
-
-print(f"{now:.3f} seconds")
-
-"""
-4.728
-5.007
-0.747
-"""