pytorch-mvgc 0.1.0__tar.gz

pytorch_mvgc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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.

pytorch_mvgc-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: pytorch-mvgc
+Version: 0.1.0
+Summary: A GPU-accelerated Multivariate Granger Causality implementation using PyTorch.
+Home-page: https://github.com/yourusername/pytorch-mvgc
+Author: nju_sit_hubc
+Author-email: 2515094316@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: torch>=1.9.0
+Requires-Dist: tqdm
+
+# PyTorch-MVGC
+
+[![PyPI version](https://badge.fury.io/py/pytorch-mvgc.svg)](https://badge.fury.io/py/pytorch-mvgc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**PyTorch-MVGC** is a GPU-accelerated Python implementation of **Multivariate Granger Causality (MVGC)** analysis. 
+
+It is designed for high-dimensional time-series data (e.g., EEG, fMRI, MEA) where traditional CPU-based implementations are too slow. By leveraging PyTorch tensors and batched matrix operations, this library achieves significant speedups compared to standard NumPy or Matlab implementations.
+
+## Features
+
+- **🚀 GPU Acceleration**: Fully implemented in PyTorch, supporting CUDA acceleration out-of-the-box.
+- **⚡ Batch Processing**: Optimized for processing multiple trials or sliding windows simultaneously.
+- **🔧 Numerical Stability**: Implements Ridge regularization and Pseudo-inverse solvers to handle ill-conditioned matrices common in high-channel neural recordings (e.g., 128-channel EEG).
+- **🐍 Python Native**: A seamless replacement for the Matlab MVGC toolbox for Python pipelines.
+
+## Installation
+
+```bash
+pip install pytorch-mvgc
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import torch
+from pytorch_mvgc import compute_mvgc
+
+# 1. Generate sample data (3 channels, 1000 timepoints)
+# System: Node 0 drives Node 1
+n_time = 1000
+X = np.zeros((3, n_time))
+noise = 0.5 * np.random.randn(3, n_time)
+for t in range(1, n_time):
+    X[0, t] = 0.8 * X[0, t-1] + noise[0, t]
+    X[1, t] = 0.5 * X[1, t-1] + 0.5 * X[0, t-1] + noise[1, t] # 0->1 Causal
+    X[2, t] = 0.7 * X[2, t-1] + noise[2, t]
+
+# 2. Compute MVGC
+# Returns matrix F where F[i, j] denotes causality j -> i
+F_matrix = compute_mvgc(X, p=1, device='cuda')
+
+print("MVGC Matrix:\n", np.round(F_matrix, 4))
+# Expected: F[1, 0] should be significant (> 0)
+```
+

pytorch_mvgc-0.1.0/README.md

@@ -0,0 +1,47 @@
+# PyTorch-MVGC
+
+[![PyPI version](https://badge.fury.io/py/pytorch-mvgc.svg)](https://badge.fury.io/py/pytorch-mvgc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**PyTorch-MVGC** is a GPU-accelerated Python implementation of **Multivariate Granger Causality (MVGC)** analysis. 
+
+It is designed for high-dimensional time-series data (e.g., EEG, fMRI, MEA) where traditional CPU-based implementations are too slow. By leveraging PyTorch tensors and batched matrix operations, this library achieves significant speedups compared to standard NumPy or Matlab implementations.
+
+## Features
+
+- **🚀 GPU Acceleration**: Fully implemented in PyTorch, supporting CUDA acceleration out-of-the-box.
+- **⚡ Batch Processing**: Optimized for processing multiple trials or sliding windows simultaneously.
+- **🔧 Numerical Stability**: Implements Ridge regularization and Pseudo-inverse solvers to handle ill-conditioned matrices common in high-channel neural recordings (e.g., 128-channel EEG).
+- **🐍 Python Native**: A seamless replacement for the Matlab MVGC toolbox for Python pipelines.
+
+## Installation
+
+```bash
+pip install pytorch-mvgc
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import torch
+from pytorch_mvgc import compute_mvgc
+
+# 1. Generate sample data (3 channels, 1000 timepoints)
+# System: Node 0 drives Node 1
+n_time = 1000
+X = np.zeros((3, n_time))
+noise = 0.5 * np.random.randn(3, n_time)
+for t in range(1, n_time):
+    X[0, t] = 0.8 * X[0, t-1] + noise[0, t]
+    X[1, t] = 0.5 * X[1, t-1] + 0.5 * X[0, t-1] + noise[1, t] # 0->1 Causal
+    X[2, t] = 0.7 * X[2, t-1] + noise[2, t]
+
+# 2. Compute MVGC
+# Returns matrix F where F[i, j] denotes causality j -> i
+F_matrix = compute_mvgc(X, p=1, device='cuda')
+
+print("MVGC Matrix:\n", np.round(F_matrix, 4))
+# Expected: F[1, 0] should be significant (> 0)
+```
+

pytorch_mvgc-0.1.0/fast_mvgc/__init__.py

@@ -0,0 +1,4 @@
+from .core import compute_mvgc, compute_mvgc_batch
+from .utils import segment_data
+
+__version__ = "0.1.0"

pytorch_mvgc-0.1.0/fast_mvgc/core.py

@@ -0,0 +1,169 @@
+import numpy as np
+import torch
+import warnings
+
+def check_backend(device: str = 'cuda'):
+    if device == 'cuda' and not torch.cuda.is_available():
+        warnings.warn("CUDA not available, falling back to CPU.")
+        return torch.device('cpu')
+    return torch.device(device)
+
+def compute_mvgc(X: np.ndarray, p: int, alpha: float = 0.01, device: str = 'cuda') -> np.ndarray:
+    """
+    计算 MVGC 矩阵（用户主入口）。
+    
+    Args:
+        X: (n_channels, n_time) 时间序列数据
+        p: VAR 滞后阶数 (Lag order)
+        alpha: 岭回归正则化系数 (Ridge regularization)，解决 NaN 的关键！
+               建议值 0.01 ~ 0.1。如果数据很干净，可以用 1e-4。
+        device: 'cuda' 或 'cpu'
+        
+    Returns:
+        F: (n_channels, n_channels) 格兰杰因果矩阵。F[i, j] 代表 j -> i 的因果强度。
+    """
+    X = np.asarray(X)
+    
+    # 维度检查与修正
+    if X.ndim != 2:
+        raise ValueError(f"Input must be 2D (n_channels, n_time), got {X.shape}")
+    
+    n_channels, n_time = X.shape
+    if n_channels > n_time:
+        warnings.warn(f"Warning: Channels ({n_channels}) > Time points ({n_time}). Did you transpose the input?")
+
+    # 视作 Batch = 1 进行处理
+    X_batch = X[np.newaxis, :, :] # (1, n, T)
+    
+    F_batch = compute_mvgc_batch(X_batch, p, alpha, device)
+    
+    return F_batch[0] # 返回 (n, n)
+
+def compute_mvgc_batch(X_batch: np.ndarray, p: int, alpha: float = 0.01, device: str = 'cuda') -> np.ndarray:
+    """
+    批量 MVGC 计算函数。
+    """
+    dev = check_backend(device)
+    X_t = torch.from_numpy(X_batch).to(dev, dtype=torch.float64) # 使用 float64 提高精度
+    
+    # 调用内部 Torch 内核
+    with torch.no_grad():
+        F_res = _mvgc_batch_kernel(X_t, p, alpha, dev)
+        
+    return F_res.cpu().numpy()
+
+def _mvgc_batch_kernel(segments: torch.Tensor, p: int, alpha: float, dev: torch.device) -> torch.Tensor:
+    """
+    PyTorch 核心计算逻辑：向量化 OLS 回归 + 岭回归正则化
+    segments: (B, n, T)
+    return: (B, n, n)
+    """
+    B, n, T = segments.shape
+    if T <= p:
+        raise ValueError(f'Time length {T} must be > order {p}')
+        
+    # 1. 去均值 (Centering)
+    seg_t = segments - segments.mean(dim=2, keepdim=True)
+    
+    # 2. 构建 Y (响应变量) 和 Z (设计矩阵)
+    # Y: (B, N, n), N = T-p
+    # Z: (B, N, n*p)
+    N = T - p
+    Y = seg_t[:, :, p:].permute(0, 2, 1) 
+    
+    Z_list = []
+    for k in range(1, p + 1):
+        # 滞后 k 个时间点
+        lag = seg_t[:, :, p - k : T - k].permute(0, 2, 1)
+        Z_list.append(lag)
+    Zs = torch.cat(Z_list, dim=2) # (B, N, n*p)
+    
+    D = n * p # 特征维度
+    
+    # 3. 计算 Full Model (全模型) 的残差方差
+    # 求解 Y = Z * Beta + E
+    # Beta = (Z^T Z + alpha*I)^-1 Z^T Y
+    
+    ZsT = Zs.permute(0, 2, 1) # (B, D, N)
+    ZTZ = torch.bmm(ZsT, Zs)  # (B, D, D)
+    ZTY = torch.bmm(ZsT, Y)   # (B, D, n)
+    
+    # === 关键：正则化 (Ridge) 防止奇异矩阵导致的 NaN ===
+    # 添加 alpha 到对角线
+    eye = torch.eye(D, device=dev, dtype=ZTZ.dtype).unsqueeze(0).expand(B, D, D)
+    ZTZ_reg = ZTZ + alpha * eye
+    
+    # 使用 cholesky 或 solve 求解比求逆更稳定
+    # beta_full: (B, D, n)
+    try:
+        # 尝试更快的 Cholesky
+        L = torch.linalg.cholesky(ZTZ_reg)
+        beta_full = torch.cholesky_solve(ZTY, L)
+    except:
+        # 回退到标准求逆 (伪逆)
+        beta_full = torch.linalg.solve(ZTZ_reg, ZTY)
+
+    # 计算 Full Model 残差方差 sigma_full
+    resid_full = Y - torch.bmm(Zs, beta_full)
+    # 只需要对角线部分的方差 (Generalized Variance 近似为变量方差的乘积，在MVGC中简化为逐变量比较)
+    sigma_full = resid_full.pow(2).sum(dim=1) # (B, n)
+    
+    # 4. 计算 Reduced Models (逐个剔除源变量 j)
+    # 结果矩阵 F (B, target, source)
+    F_batch = torch.zeros((B, n, n), dtype=torch.float64, device=dev)
+    
+    # 预先生成所有列的索引
+    all_cols = torch.arange(D, device=dev)
+    
+    for j in range(n): # j 是 Source (因)
+        # 剔除 j 的所有滞后项 (columns: j*p, j*p+1, ..., (j+1)*p-1)
+        # 保留 Target i 和其他变量 Z
+        
+        # 确定要保留的列索引
+        # 这是一个简单的掩码操作
+        mask = torch.ones(D, dtype=torch.bool, device=dev)
+        mask[j*p : (j+1)*p] = False
+        keep_idx = all_cols[mask]
+        
+        # 提取 Reduced 设计矩阵 Z_red
+        Zs_red = Zs.index_select(2, keep_idx) # (B, N, D_reduced)
+        D_red = Zs_red.shape[2]
+        
+        # OLS for Reduced Model
+        Zs_red_T = Zs_red.permute(0, 2, 1)
+        ZTZ_r = torch.bmm(Zs_red_T, Zs_red)
+        ZTY_r = torch.bmm(Zs_red_T, Y)
+        
+        # Regularization again
+        eye_r = torch.eye(D_red, device=dev, dtype=ZTZ_r.dtype).unsqueeze(0).expand(B, D_red, D_red)
+        ZTZ_r_reg = ZTZ_r + alpha * eye_r
+        
+        try:
+            L_r = torch.linalg.cholesky(ZTZ_r_reg)
+            beta_r = torch.cholesky_solve(ZTY_r, L_r)
+        except:
+            beta_r = torch.linalg.solve(ZTZ_r_reg, ZTY_r)
+            
+        resid_r = Y - torch.bmm(Zs_red, beta_r)
+        sigma_red = resid_r.pow(2).sum(dim=1) # (B, n) - 每个变量作为 Target 时的 Reduced 方差
+        
+        # 5. 计算 Granger Causality
+        # F_{j->i} = ln(var_reduced_i / var_full_i)
+        # 注意：这里 sigma_red 和 sigma_full 都是 (B, n)，表示 n 个变量作为 Target 时的方差
+        # 当前循环 j 是 Source。
+        # 所以 ratio[b, i] 代表：Source j 被剔除后，Target i 的方差变化
+        
+        # 加上极小值防止除以0
+        ratio = (sigma_red + 1e-12) / (sigma_full + 1e-12)
+        
+        # 结果填入 F 的第 j 列 (j -> all targets)
+        F_batch[:, :, j] = torch.log(ratio)
+        
+    # 6. 后处理：对角线置 0 (无自因果)
+    idx = torch.arange(n, device=dev)
+    F_batch[:, idx, idx] = 0.0
+    
+    # 修正可能的负值 (由于数值误差，完全无关时 log 可能出现微小负值)
+    F_batch = torch.relu(F_batch)
+    
+    return F_batch

pytorch_mvgc-0.1.0/fast_mvgc/cpu_engine.py

@@ -0,0 +1,120 @@
+import numpy as np
+import warnings
+
+def compute_mvgc_cpu(X: np.ndarray, p: int, alpha: float = 0.01) -> np.ndarray:
+    """
+    CPU implementation of MVGC using NumPy (OLS with Ridge Regression).
+    Acts as a fallback or reference implementation.
+    
+    Args:
+        X: (n_channels, n_time)
+        p: Lag order
+        alpha: Ridge regularization parameter
+    """
+    X = np.asarray(X)
+    n, T = X.shape
+    if T <= p:
+        raise ValueError(f'Time length {T} must be > order {p}')
+        
+    # 1. Prepare Data
+    # Center the data
+    X_mean = X - X.mean(axis=1, keepdims=True)
+    
+    # Build Y (Target) and Z (Design Matrix)
+    # Y: (n, N) where N = T - p
+    N = T - p
+    Y = X_mean[:, p:]
+    
+    Z_list = []
+    for k in range(1, p + 1):
+        lag = X_mean[:, p-k : T-k]
+        Z_list.append(lag)
+    # Stack lags: Z shape (n*p, N)
+    Z = np.vstack(Z_list)
+    
+    # 2. Full Model Regression
+    # Beta = (Z Z.T + alpha I)^-1 Z Y.T
+    # We solve (Z Z.T + alpha I) Beta = Z Y.T
+    
+    ZZT = Z @ Z.T
+    ZYT = Z @ Y.T
+    
+    # Ridge Regularization
+    D = n * p
+    ZZT_reg = ZZT + alpha * np.eye(D)
+    
+    # Solve linear system
+    try:
+        # utilize symmetry for speed (equivalent to cholesky solve)
+        beta_full = np.linalg.solve(ZZT_reg, ZYT)
+    except np.linalg.LinAlgError:
+        # Fallback to pseudoinverse if somehow still singular
+        beta_full = np.linalg.pinv(ZZT_reg) @ ZYT
+        
+    # Residuals
+    # Note: Beta shape is (n*p, n), so Z.T @ Beta gives (N, n), transpose to (n, N)
+    preds_full = beta_full.T @ Z 
+    res_full = Y - preds_full
+    # Variance of residuals (diagonal of covariance matrix)
+    sig_full = np.var(res_full, axis=1, ddof=0)
+    
+    # 3. Reduced Models (Loop over source j)
+    F = np.zeros((n, n))
+    
+    # Cache ZZT parts to avoid recomputing? 
+    # For CPU simple implementation, we just slice Z.
+    
+    for j in range(n):
+        # We want to calculate causality j -> i (for all i)
+        # So we remove source j from the predictors Z
+        
+        # Identify rows in Z to keep (remove lag rows corresponding to channel j)
+        # Z rows: 0..n-1 (lag 1), n..2n-1 (lag 2)...
+        keep_indices = []
+        for k in range(p):
+            # The row index for channel j at lag k+1 is: j + k*n
+            # Wait, construction of Z above:
+            # Z_list[0] is shape (n, N). It contains ch0_lag1, ch1_lag1, ...
+            # So Z structure is: [ch0_l1, ch1_l1, ..., ch0_l2, ...].T
+            # Correct index for channel c at lag k (1-based) is: c + (k-1)*n
+            
+            # Let's verify standard flattening. 
+            # Z = vstack(Z_list). Z_list[0] has n rows.
+            # Row x corresponds to channel (x % n)
+            pass
+
+        # Easier way: mask indices where (idx % n) != j
+        all_indices = np.arange(D)
+        mask = (all_indices % n) != j
+        idx_reduced = all_indices[mask]
+        
+        Z_red = Z[idx_reduced, :]
+        D_red = len(idx_reduced)
+        
+        # OLS Reduced
+        ZZT_r = Z_red @ Z_red.T
+        ZYT_r = Z_red @ Y.T
+        
+        ZZT_r_reg = ZZT_r + alpha * np.eye(D_red)
+        
+        try:
+            beta_r = np.linalg.solve(ZZT_r_reg, ZYT_r)
+        except np.linalg.LinAlgError:
+            beta_r = np.linalg.pinv(ZZT_r_reg) @ ZYT_r
+            
+        preds_r = beta_r.T @ Z_red
+        res_r = Y - preds_r
+        sig_r = np.var(res_r, axis=1, ddof=0)
+        
+        # 4. Granger Causality
+        # F_{j->i} = ln(sig_r_i / sig_full_i)
+        ratio = (sig_r + 1e-12) / (sig_full + 1e-12)
+        F[:, j] = np.log(ratio)
+        
+    # Zero diagonal
+    np.fill_diagonal(F, 0.0)
+    
+    # Clean up small negative values
+    F[F < 0] = 0.0
+    
+    return F

pytorch_mvgc-0.1.0/fast_mvgc/utils.py

@@ -0,0 +1,20 @@
+# fast_mvgc/utils.py
+import numpy as np
+
+def segment_data(X: np.ndarray, window_size: int, step_size: int = None) -> np.ndarray:
+    """
+    Generic segmentation function.
+    Args:
+        X: (n_channels, total_time)
+        window_size: Length of each segment
+        step_size: Stride (default = window_size, i.e., no overlap)
+    Returns:
+        segments: (n_segments, n_channels, window_size)
+    """
+    if step_size is None:
+        step_size = window_size
+        
+    n_channels, n_time = X.shape
+    starts = range(0, n_time - window_size + 1, step_size)
+    segments = [X[:, s:s+window_size] for s in starts]
+    return np.stack(segments, axis=0)

pytorch_mvgc-0.1.0/pytorch_mvgc.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: pytorch-mvgc
+Version: 0.1.0
+Summary: A GPU-accelerated Multivariate Granger Causality implementation using PyTorch.
+Home-page: https://github.com/yourusername/pytorch-mvgc
+Author: nju_sit_hubc
+Author-email: 2515094316@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: torch>=1.9.0
+Requires-Dist: tqdm
+
+# PyTorch-MVGC
+
+[![PyPI version](https://badge.fury.io/py/pytorch-mvgc.svg)](https://badge.fury.io/py/pytorch-mvgc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**PyTorch-MVGC** is a GPU-accelerated Python implementation of **Multivariate Granger Causality (MVGC)** analysis. 
+
+It is designed for high-dimensional time-series data (e.g., EEG, fMRI, MEA) where traditional CPU-based implementations are too slow. By leveraging PyTorch tensors and batched matrix operations, this library achieves significant speedups compared to standard NumPy or Matlab implementations.
+
+## Features
+
+- **🚀 GPU Acceleration**: Fully implemented in PyTorch, supporting CUDA acceleration out-of-the-box.
+- **⚡ Batch Processing**: Optimized for processing multiple trials or sliding windows simultaneously.
+- **🔧 Numerical Stability**: Implements Ridge regularization and Pseudo-inverse solvers to handle ill-conditioned matrices common in high-channel neural recordings (e.g., 128-channel EEG).
+- **🐍 Python Native**: A seamless replacement for the Matlab MVGC toolbox for Python pipelines.
+
+## Installation
+
+```bash
+pip install pytorch-mvgc
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import torch
+from pytorch_mvgc import compute_mvgc
+
+# 1. Generate sample data (3 channels, 1000 timepoints)
+# System: Node 0 drives Node 1
+n_time = 1000
+X = np.zeros((3, n_time))
+noise = 0.5 * np.random.randn(3, n_time)
+for t in range(1, n_time):
+    X[0, t] = 0.8 * X[0, t-1] + noise[0, t]
+    X[1, t] = 0.5 * X[1, t-1] + 0.5 * X[0, t-1] + noise[1, t] # 0->1 Causal
+    X[2, t] = 0.7 * X[2, t-1] + noise[2, t]
+
+# 2. Compute MVGC
+# Returns matrix F where F[i, j] denotes causality j -> i
+F_matrix = compute_mvgc(X, p=1, device='cuda')
+
+print("MVGC Matrix:\n", np.round(F_matrix, 4))
+# Expected: F[1, 0] should be significant (> 0)
+```
+

pytorch_mvgc-0.1.0/pytorch_mvgc.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.py
+fast_mvgc/__init__.py
+fast_mvgc/core.py
+fast_mvgc/cpu_engine.py
+fast_mvgc/utils.py
+pytorch_mvgc.egg-info/PKG-INFO
+pytorch_mvgc.egg-info/SOURCES.txt
+pytorch_mvgc.egg-info/dependency_links.txt
+pytorch_mvgc.egg-info/requires.txt
+pytorch_mvgc.egg-info/top_level.txt
+tests/test.py

pytorch_mvgc-0.1.0/pytorch_mvgc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytorch_mvgc-0.1.0/pytorch_mvgc.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+torch>=1.9.0
+tqdm

pytorch_mvgc-0.1.0/pytorch_mvgc.egg-info/top_level.txt

@@ -0,0 +1 @@
+fast_mvgc

pytorch_mvgc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytorch_mvgc-0.1.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="pytorch-mvgc",                
+    version="0.1.0",
+    author="nju_sit_hubc",
+    author_email="2515094316@qq.com",
+    description="A GPU-accelerated Multivariate Granger Causality implementation using PyTorch.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/pytorch-mvgc",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        "numpy",
+        "torch>=1.9.0",  # 指定最低版本
+        "tqdm"
+    ],
+)

pytorch_mvgc-0.1.0/tests/test.py

@@ -0,0 +1,49 @@
+import numpy as np
+import torch
+from fast_mvgc.core import compute_mvgc # 确保引用了上面的新文件
+
+def test_causality_fix():
+    print("=== 开始 MVGC 正确性测试 ===")
+    
+    # 1. 生成标准的 VAR(1) 3通道模型
+    # 0 -> 1 (强因果)
+    # 2 独立
+    np.random.seed(42)
+    n_time = 2000
+    X = np.zeros((3, n_time))
+    noise = np.random.randn(3, n_time) # 标准正态噪声
+    
+    print("生成数据中: Node 0 -> Node 1 ...")
+    for t in range(1, n_time):
+        X[0, t] = 0.8 * X[0, t-1] + noise[0, t]
+        # X[1] 依赖 X[0] 的过去值
+        X[1, t] = 0.5 * X[1, t-1] + 0.5 * X[0, t-1] + noise[1, t] 
+        X[2, t] = 0.7 * X[2, t-1] + noise[2, t]
+
+    # 2. 计算 MVGC
+    # 注意：alpha (正则化) 对于数值稳定性至关重要
+    try:
+        F = compute_mvgc(X, p=1, alpha=0.01, device='cuda')
+    except Exception as e:
+        print(f"GPU计算失败，尝试CPU... 错误: {e}")
+        F = compute_mvgc(X, p=1, alpha=0.01, device='cpu')
+
+    print("\n计算结果 F (F[i, j] 表示 j->i):")
+    print(np.round(F, 4))
+    
+    # 3. 验证
+    # 我们期望 F[1, 0] (0->1) 是显著的
+    val_0_to_1 = F[1, 0]
+    val_1_to_0 = F[0, 1]
+    
+    print(f"\n关键路径检查:")
+    print(f"0 -> 1 (预期 > 0.05): {val_0_to_1:.4f}", "✅ PASS" if val_0_to_1 > 0.05 else "❌ FAIL")
+    print(f"1 -> 0 (预期 < 0.05): {val_1_to_0:.4f}", "✅ PASS" if val_1_to_0 < 0.05 else "❌ FAIL (False Positive)")
+    
+    if np.isnan(F).any():
+        print("\n❌ 警告: 结果中包含 NaN!")
+    else:
+        print("\n✅ 结果数值正常 (无 NaN).")
+
+if __name__ == "__main__":
+    test_causality_fix()