vbi 0.1.3__cp310-cp310-manylinux2014_x86_64.whl

vbi/utils.py

@@ -0,0 +1,402 @@
+import os
+import time
+import torch
+import numpy as np
+
+from rich import box
+from rich.table import Table
+from rich.console import Console
+
+from os.path import join
+from scipy.stats import gaussian_kde
+from sbi.analysis.plot import _get_default_opts, _update, ensure_numpy
+
+from torch import Tensor
+from typing import Union
+
+
+import re
+try :
+    import nbformat
+    from nbconvert import PythonExporter
+except:
+    pass
+
+
+def timer(func):
+    """
+    decorator to measure elapsed time
+
+    Parameters
+    -----------
+    func: function
+        function to be decorated
+    """
+
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        display_time(end - start, message="{:s}".format(func.__name__))
+        return result
+
+    return wrapper
+
+
+def display_time(time, message=""):
+    """
+    display elapsed time in hours, minutes, seconds
+
+    Parameters
+    -----------
+    time: float
+        elaspsed time in seconds
+    """
+
+    hour = int(time / 3600)
+    minute = (int(time % 3600)) // 60
+    second = time - (3600.0 * hour + 60.0 * minute)
+    print(
+        "{:s} Done in {:d} hours {:d} minutes {:09.6f} seconds".format(
+            message, hour, minute, second
+        )
+    )
+
+
+class LoadSample(object):
+    def __init__(self, nn=84) -> None:
+
+        self.root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        self.nn = nn
+
+    def get_weights(self, normalize=True):
+        nn = self.nn
+        SC_name = join(
+            self.root_dir, "vbi/dataset", f"connectivity_{nn}", "weights.txt"
+        )
+        SC = np.loadtxt(SC_name)
+        np.fill_diagonal(SC, 0.0)
+        if normalize:
+            SC /= SC.max()
+        SC[SC < 0] = 0.0
+        return SC
+
+    def get_lengths(self):
+        nn = self.nn
+        tract_lenghts_name = join(
+            self.root_dir, "vbi/dataset", f"connectivity_{nn}", "tract_lengths.txt"
+        )
+        tract_lengths = np.loadtxt(tract_lenghts_name)
+        return tract_lengths
+
+    def get_bold(self):
+        nn = self.nn
+        bold_name = join(
+            self.root_dir, "vbi", "dataset", f"connectivity_{nn}", "Bold.npz"
+        )
+        bold = np.load(bold_name)["Bold"]
+        return bold.T
+
+
+def get_limits(samples, limits=None):
+
+    if type(samples) != list:
+        samples = ensure_numpy(samples)
+        samples = [samples]
+    else:
+        for i, sample_pack in enumerate(samples):
+            samples[i] = ensure_numpy(samples[i])
+
+    # Dimensionality of the problem.
+    dim = samples[0].shape[1]
+
+    if limits == [] or limits is None:
+        limits = []
+        for d in range(dim):
+            min = +np.inf
+            max = -np.inf
+            for sample in samples:
+                min_ = sample[:, d].min()
+                min = min_ if min_ < min else min
+                max_ = sample[:, d].max()
+                max = max_ if max_ > max else max
+            limits.append([min, max])
+    else:
+        if len(limits) == 1:
+            limits = [limits[0] for _ in range(dim)]
+        else:
+            limits = limits
+    limits = torch.as_tensor(limits)
+
+    return limits
+
+
+def posterior_peaks(samples, return_dict=False, **kwargs):
+
+    opts = _get_default_opts()
+    opts = _update(opts, kwargs)
+
+    limits = get_limits(samples)
+    samples = samples.numpy()
+    n, dim = samples.shape
+
+    try:
+        labels = opts["labels"]
+    except:
+        labels = range(dim)
+
+    peaks = {}
+    if labels is None:
+        labels = range(dim)
+    for i in range(dim):
+        peaks[labels[i]] = 0
+
+    for row in range(dim):
+        density = gaussian_kde(samples[:, row], bw_method=opts["kde_diag"]["bw_method"])
+        xs = np.linspace(limits[row, 0], limits[row, 1], opts["kde_diag"]["bins"])
+        ys = density(xs)
+
+        # y, x = np.histogram(samples[:, row], bins=bins)
+        peaks[labels[row]] = xs[ys.argmax()]
+
+    if return_dict:
+        return peaks
+    else:
+        return list(peaks.values())
+
+
+def p2j(modulePath):
+    """convert python script to jupyter notebook"""
+    os.system(f"p2j -o {modulePath}")
+
+
+def j2p(notebookPath, modulePath=None):
+    """
+    convert a jupyter notebook to a python module
+
+    >>> j2p("sample.ipynb", "sample.py")
+
+    """
+
+    with open(notebookPath) as fh:
+        nb = nbformat.reads(fh.read(), nbformat.NO_CONVERT)
+
+    exporter = PythonExporter()
+    source, meta = exporter.from_notebook_node(nb)
+
+    # remove lines start with `# In[` from source
+    source = re.sub(r"^# In\[[0-9 ]*\]:\n", "", source, flags=re.MULTILINE)
+
+    # replace more that 1 empty lines with 1 empty line
+    source = re.sub(r"\n{2,}", "\n\n", source)
+
+    if modulePath is None:
+        modulePath = notebookPath.replace(".ipynb", ".py")
+
+    with open(modulePath, "w+") as fh:
+        fh.writelines(source)
+
+
+def posterior_shrinkage(
+    prior_samples: Union[Tensor, np.ndarray], post_samples: Union[Tensor, np.ndarray]
+) -> Tensor:
+    """
+    Calculate the posterior shrinkage, quantifying how much
+    the posterior distribution contracts from the initial
+    prior distribution.
+    References:
+    https://arxiv.org/abs/1803.08393
+
+    Parameters
+    ----------
+    prior_samples : array_like or torch.Tensor [n_samples, n_params]
+        Samples from the prior distribution.
+    post_samples : array-like or torch.Tensor [n_samples, n_params]
+        Samples from the posterior distribution.
+
+    Returns
+    -------
+    shrinkage : torch.Tensor [n_params]
+        The posterior shrinkage.
+    """
+
+    if len(prior_samples) == 0 or len(post_samples) == 0:
+        raise ValueError("Input samples are empty")
+
+    if not isinstance(prior_samples, torch.Tensor):
+        prior_samples = torch.tensor(prior_samples, dtype=torch.float32)
+    if not isinstance(post_samples, torch.Tensor):
+        post_samples = torch.tensor(post_samples, dtype=torch.float32)
+
+    if prior_samples.ndim == 1:
+        prior_samples = prior_samples[:, None]
+    if post_samples.ndim == 1:
+        post_samples = post_samples[:, None]
+
+    prior_std = torch.std(prior_samples, dim=0)
+    post_std = torch.std(post_samples, dim=0)
+
+    return 1 - (post_std / prior_std) ** 2
+
+
+def posterior_zscore(
+    true_theta: Union[Tensor, np.array, float], post_samples: Union[Tensor, np.array]
+):
+    """
+    Calculate the posterior z-score, quantifying how much the posterior
+    distribution of a parameter encompasses its true value.
+    References:
+    https://arxiv.org/abs/1803.08393
+
+    Parameters
+    ----------
+    true_theta : float, array-like or torch.Tensor [n_params]
+        The true value of the parameters.
+    post_samples : array-like or torch.Tensor [n_samples, n_params]
+        Samples from the posterior distributions.
+
+    Returns
+    -------
+    z : Tensor [n_params]
+        The z-score of the posterior distributions.
+    """
+
+    if len(post_samples) == 0:
+        raise ValueError("Input samples are empty")
+
+    if not isinstance(true_theta, torch.Tensor):
+        true_theta = torch.tensor(true_theta, dtype=torch.float32)
+    if not isinstance(post_samples, torch.Tensor):
+        post_samples = torch.tensor(post_samples, dtype=torch.float32)
+
+    true_theta = np.atleast_1d(true_theta)
+    if post_samples.ndim == 1:
+        post_samples = post_samples[:, None]
+
+    post_mean = torch.mean(post_samples, dim=0)
+    post_std = torch.std(post_samples, dim=0)
+
+    return torch.abs((post_mean - true_theta) / post_std)
+
+
+def set_diag(A: np.ndarray, k: int = 0, value: float = 0.0):
+    """
+    set k diagonals of the given matrix to given value.
+    
+    Parameters
+    ----------
+    A: np.ndarray
+        matrix
+    k: int
+        number of diagonals
+    value: float
+        value to be set
+    
+    Returns
+    -------
+    A: np.ndarray
+        matrix with k diagonals set to value
+    
+    """
+
+    assert len(A.shape) == 2
+    n = A.shape[0]
+    assert k < n
+    for i in range(-k, k + 1):
+        a1 = np.diag(np.random.randint(1, 2, n - abs(i)), i)
+        idx = np.where(a1)
+        A[idx] = value
+    return A
+
+
+def test_imports():
+    """Check required dependencies, print versions, and warn if unavailable."""
+    console = Console()
+    table = Table(title="Dependency Check", box=box.SIMPLE_HEAVY)
+    table.add_column("Package", style="bold cyan")
+    table.add_column("Version", style="bold green")
+    table.add_column("Status", style="bold yellow")
+    
+    dependencies = [
+        ("vbi", "vbi"),
+        ("numpy", "numpy"),
+        ("scipy", "scipy"),
+        ("matplotlib", "matplotlib"),
+        ("sbi", "sbi"),
+        ("torch", "torch"),
+        ("cupy", "cupy")
+    ]
+    
+    for name, module in dependencies:
+        try:
+            pkg = __import__(module)
+            version = pkg.__version__
+            status = "✅ Available"
+        except ImportError:
+            version = "-"
+            status = "❌ Not Found"
+        
+        table.add_row(name, version, status)
+    
+    console.print(table)
+    
+    # Additional GPU checks
+    try:
+        import torch
+        console.print(f"[bold blue]Torch GPU available:[/bold blue] {torch.cuda.is_available()}")
+        console.print(f"[bold blue]Torch device count:[/bold blue] {torch.cuda.device_count()}")
+        console.print(f"[bold blue]Torch CUDA version:[/bold blue] {torch.version.cuda}")  # Display CUDA version used by PyTorch
+    except ImportError:
+        pass
+
+    try:
+        import cupy
+        console.print(f"[bold blue]CuPy GPU available:[/bold blue] {cupy.cuda.is_available()}")
+        console.print(f"[bold blue]CuPy device count:[/bold blue] {cupy.cuda.runtime.getDeviceCount()}")
+        info = get_cuda_info()
+        if isinstance(info, dict):
+            print(f"CUDA Version: {info['cuda_version']}")
+            print(f"Device Name: {info['device_name']}")
+            print(f"Total Memory: {info['total_memory']:.2f} GB")
+            print(f"Compute Capability: {info['compute_capability']}")
+
+    except ImportError:
+        pass
+
+    
+    
+def get_cuda_info():
+    """
+    Get CUDA version and device information using CuPy.
+    
+    Returns:
+        dict: Dictionary containing CUDA version and device information
+    """
+    import cupy as cp
+    
+    try:
+        # Get CUDA version
+        cuda_version = cp.cuda.runtime.runtimeGetVersion()
+        major = cuda_version // 1000
+        minor = (cuda_version % 1000) // 10
+        
+        # Get device info
+        device = cp.cuda.runtime.getDeviceProperties(0)
+        
+        return {
+            'cuda_version': f"{major}.{minor}",
+            'device_name': device['name'].decode(),
+            'total_memory': device['totalGlobalMem'] / (1024**3),  # Convert to GB
+            'compute_capability': f"{device['major']}.{device['minor']}"
+        }
+    except ImportError:
+        return "CuPy is not installed"
+    except Exception as e:
+        return f"Error getting CUDA information: {str(e)}"
+
+
+
+# def tests():
+#     from vbi.tests.test_suite import tests
+#     tests()
+    

vbi-0.1.3.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: vbi
+Version: 0.1.3
+Summary: Virtual brain inference.
+Author-email: Abolfazl Ziaeemehr <a.ziaeemehr@gmail.com>, Meysam Hashemi <meysam.hashemi@gmail.com>, Marmaduke Woodman <marmaduke.woodman@gmail.com>
+License: MIT
+Project-URL: homepage, https://ziaeemehr.github.io/vbi_paper/
+Project-URL: repository, https://github.com/Ziaeemehr/vbi_paper
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wheel
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: numba
+Requires-Dist: h5py
+Requires-Dist: pandas
+Requires-Dist: networkx
+Requires-Dist: nbconvert
+Requires-Dist: matplotlib
+Requires-Dist: setuptools-scm
+Requires-Dist: tqdm
+Requires-Dist: sbi
+Requires-Dist: torch
+Requires-Dist: parameterized
+Requires-Dist: scikit-learn
+Requires-Dist: pycatch22
+Requires-Dist: pytest
+Requires-Dist: swig
+Requires-Dist: rich
+Provides-Extra: dev
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: nbformat; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: cloud_sptheme; extra == "docs"
+Requires-Dist: sphinx_bootstrap_theme; extra == "docs"
+Provides-Extra: cu
+Requires-Dist: cupy; extra == "cu"
+Provides-Extra: all
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: sphinx; extra == "all"
+Requires-Dist: numpydoc; extra == "all"
+Requires-Dist: nbformat; extra == "all"
+Requires-Dist: nbsphinx; extra == "all"
+Requires-Dist: cloud_sptheme; extra == "all"
+Requires-Dist: sphinx_bootstrap_theme; extra == "all"
+Requires-Dist: cupy; extra == "all"
+Dynamic: license-file
+
+[![Test](https://github.com/ins-amu/vbi/actions/workflows/tests.yml/badge.svg)](https://github.com/ins-amu/vbi/actions/workflows/tests.yml)
+[![Documentation Status](https://readthedocs.org/projects/vbi/badge/?version=latest)](https://vbi.readthedocs.io/latest/)
+[![DOI](https://zenodo.org/badge/681090816.svg)](https://doi.org/10.5281/zenodo.14795543)
+[![Docker Build](https://github.com/ins-amu/vbi/actions/workflows/docker-image.yml/badge.svg)](https://github.com/ins-amu/vbi/actions/workflows/docker-image.yml)
+<!-- [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/ins-amu/vbi/main?labpath=docs/examples/intro.ipynb) -->
+
+
+# VBI: Virtual Brain Inference
+---
+[Getting Started](https://github.com/ins-amu/vbi/tree/main/docs/examples) |
+[Documentation](https://vbi.readthedocs.io/latest/) | 
+
+<p align="center">
+<img src="https://github.com/Ziaeemehr/vbi_paper/blob/main/vbi_log.png"  width="250">
+</p>
+
+
+## installation
+
+```bash
+    conda env create --name vbi python=3.10
+    conda activate vbi
+    git clone https://github.com/ins-amu/vbi.git
+    cd vbi
+    pip install .
+
+    # pip install -e .[all,dev,docs]
+```
+
+## Using Docker
+
+To use the Docker image, you can pull it from the GitHub Container Registry and run it as follows:
+
+```bash
+    # Get it without building anything locally
+    # without GPU
+    docker run --rm -it -p 8888:8888 ghcr.io/ins-amu/vbi:main
+
+    # with GPU
+    docker run --gpus all --rm -it -p 8888:8888 ghcr.io/ins-amu/vbi:main
+
+
+    # or build it locally:
+    docker build -t vbi-project .                      # build
+    docker run --gpus all -it -p 8888:8888 vbi-project # use with gpu
+
+```    
+
+- Quick check :
+
+```python
+
+    import vbi
+    vbi.tests()
+    vbi.test_imports()
+
+    
+  #              Dependency Check              
+  #                                         
+  #  Package      Version       Status        
+  #━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 
+  #  vbi          v0.1.3        ✅ Available  
+  #  numpy        1.24.4        ✅ Available  
+  #  scipy        1.10.1        ✅ Available  
+  #  matplotlib   3.7.5         ✅ Available  
+  #  sbi          0.22.0        ✅ Available  
+  #  torch        2.4.1+cu121   ✅ Available  
+  #  cupy         12.3.0        ✅ Available  
+  #                                          
+  #  Torch GPU available: True
+  #  Torch device count: 1
+  #  Torch CUDA version: 12.1
+  #  CuPy GPU available: True
+  #  CuPy device count: 1
+  #  CUDA Version: 11.8
+  #  Device Name: NVIDIA RTX A5000
+  #  Total Memory: 23.68 GB
+  #  Compute Capability: 8.6
+
+```
+
+
+## Feedback and Contributions
+
+We welcome contributions to the VBI project! If you have suggestions, bug reports, or feature requests, please open an issue on our [GitHub repository](https://github.com/ins-amu/vbi/issues). To contribute code, fork the repository, create a new branch for your feature or bugfix, and submit a pull request. Make sure to follow our coding standards and include tests for your changes. For detailed guidelines, please refer to our [CONTRIBUTING.md](https://github.com/ins-amu/vbi/blob/main/CONTRIBUTING.md) file. Thank you for helping us improve VBI!
+
+
+## Citation
+
+```bibtex
+@article{VBI,
+  author = {Ziaeemehr, Abolfazl and Woodman, Marmaduke and Domide, Lia and Petkoski, Spase and Jirsa, Viktor and Hashemi, Meysam},
+  title = {Virtual Brain Inference (VBI): A flexible and integrative toolkit for efficient probabilistic inference on virtual brain models},
+  journal = {bioRxiv},
+  year = {2025},
+  doi = {10.1101/2025.01.21.633922},
+  url = {https://doi.org/10.1101/2025.01.21.633922},
+  abstract = {Network neuroscience has proven essential for understanding the principles and mechanisms underlying complex brain (dys)function and cognition. In this context, whole-brain network modeling--also known as virtual brain modeling--combines computational models of brain dynamics (placed at each network node) with individual brain imaging data (to coordinate and connect the nodes), advancing our understanding of the complex dynamics of the brain and its neurobiological underpinnings. However, there remains a critical need for automated model inversion tools to estimate control (bifurcation) parameters at large scales and across neuroimaging modalities, given their varying spatio-temporal resolutions. This study aims to address this gap by introducing a flexible and integrative toolkit for efficient Bayesian inference on virtual brain models, called Virtual Brain Inference (VBI). This open-source toolkit provides fast simulations, taxonomy of feature extraction, efficient data storage and loading, and probabilistic machine learning algorithms, enabling biophysically interpretable inference from non-invasive and invasive recordings. Through in-silico testing, we demonstrate the accuracy and reliability of inference for commonly used whole-brain network models and their associated neuroimaging data. VBI shows potential to improve hypothesis evaluation in network neuroscience through uncertainty quantification, and contribute to advances in precision medicine by enhancing the predictive power of virtual brain models.}
+}
+```
+
+This research has received funding from:
+
+- EU's Horizon 2020 Framework Programme for Research and Innovation under the Specific Grant Agreements:
+  - No. 101147319 (EBRAINS 2.0 Project)
+  - No. 101137289 (Virtual Brain Twin Project)
+  - No. 101057429 (project environMENTAL)
+- Government grant managed by the Agence Nationale de la Recherche:
+  - Reference ANR-22-PESN-0012 (France 2030 program)
+
+The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.