boostrsa 0.0.1.dev0__tar.gz → 0.0.1.dev3__tar.gz

boostrsa-0.0.1.dev3/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: boostrsa
+Version: 0.0.1.dev3
+Summary: This is toolbox for boosting calculation speed using GPU
+Home-page: https://github.com/SeojinYoon/boostrsa.git
+Author: seojin
+Author-email: pures1@hanyang.ac.kr
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: tqdm
+
+
+# Boostrsa
+
+This library is based on rsatoolbox(https://github.com/rsagroup/rsatoolbox).
+
+The purpose of library is made to boost calcuation speed for searchlight RSA(Representational Similarity Analysis). However, It is still in development, so this library only includes tools for boosting crossnobis distance calculation for constructing RDM(Representational Dissimilartiy Matrix) on the whole brain. 
+
+## How it works?
+
+Basically, this library uses a Nvidia's GPU instead of CPU for parallel processing. In the searchlight analysis, the data targeted for constructing the RDM in volvxes a voxel and its neighboring voxels. That is well-suited for parallel processing since the calculations for each target are independent of one another. This library utilizes GPU-compatible libraries such as Numba and Cupy to facilitate this process.
+
+## Dependencies
+
+To use this library, you need to have a Nvidia's GPU and CUDA. Additionally, this library heavily relies on Cupy and Numba. It is essential to install the appropriate versions of these libraries.
+
+### Cupy
+
+Cupy is designed to work with specific versions of CUDA. See cupy's guide and install appropriate version in correspond to your system (https://github.com/cupy/cupy).
+
+Please check your cuda version to install cupy.
+- versions
+    - cupy-cuda10x (for cuda 10)
+    - cupy-cuda11x (for cuda 11)
+    - cupy-cuda12x (for cuda 12)
+    
+
+If you installed the cuda10 in your computer, then install cupy-cuda10x. install cupy-cuda10x. ex) pip install cupy-cuda10x
+
+### Numba
+
+The numba library is a powerful tool that enbales python functions to be compiled to machine code at runtime using the LLVM. One of its key features is the ability to generate native code for different architectures, including CPUs and GPUs, which greatly accelerates the execution of data-heavy and computationally intense python code.
+
+Please see installation guideline of numba (https://numba.pydata.org/numba-doc/latest/user/installing.html).
+
+Pip installation). 
+- pip install numba
+
+
+## Installation
+
+pip install boostrsa
+
+# Checked version
+
+These are the latest checked environment.
+
+- OS
+    - Linux, ubuntu - 21.10
+- numba
+    - 0.57.0 ~ 0.59.1 is fine to use
+- cupy
+    - cupy-cuda11x
+    - cupy-cuda12x
+
+# Future works
+
+- Add calculation sources to get neighbors and centers (boost)
+- Add RSA sources (boost)
+- Support other calculation methods except crossnobis distance

boostrsa-0.0.1.dev3/README.md

@@ -0,0 +1,59 @@
+
+# Boostrsa
+
+This library is based on rsatoolbox(https://github.com/rsagroup/rsatoolbox).
+
+The purpose of library is made to boost calcuation speed for searchlight RSA(Representational Similarity Analysis). However, It is still in development, so this library only includes tools for boosting crossnobis distance calculation for constructing RDM(Representational Dissimilartiy Matrix) on the whole brain. 
+
+## How it works?
+
+Basically, this library uses a Nvidia's GPU instead of CPU for parallel processing. In the searchlight analysis, the data targeted for constructing the RDM in volvxes a voxel and its neighboring voxels. That is well-suited for parallel processing since the calculations for each target are independent of one another. This library utilizes GPU-compatible libraries such as Numba and Cupy to facilitate this process.
+
+## Dependencies
+
+To use this library, you need to have a Nvidia's GPU and CUDA. Additionally, this library heavily relies on Cupy and Numba. It is essential to install the appropriate versions of these libraries.
+
+### Cupy
+
+Cupy is designed to work with specific versions of CUDA. See cupy's guide and install appropriate version in correspond to your system (https://github.com/cupy/cupy).
+
+Please check your cuda version to install cupy.
+- versions
+    - cupy-cuda10x (for cuda 10)
+    - cupy-cuda11x (for cuda 11)
+    - cupy-cuda12x (for cuda 12)
+    
+
+If you installed the cuda10 in your computer, then install cupy-cuda10x. install cupy-cuda10x. ex) pip install cupy-cuda10x
+
+### Numba
+
+The numba library is a powerful tool that enbales python functions to be compiled to machine code at runtime using the LLVM. One of its key features is the ability to generate native code for different architectures, including CPUs and GPUs, which greatly accelerates the execution of data-heavy and computationally intense python code.
+
+Please see installation guideline of numba (https://numba.pydata.org/numba-doc/latest/user/installing.html).
+
+Pip installation). 
+- pip install numba
+
+
+## Installation
+
+pip install boostrsa
+
+# Checked version
+
+These are the latest checked environment.
+
+- OS
+    - Linux, ubuntu - 21.10
+- numba
+    - 0.57.0 ~ 0.59.1 is fine to use
+- cupy
+    - cupy-cuda11x
+    - cupy-cuda12x
+
+# Future works
+
+- Add calculation sources to get neighbors and centers (boost)
+- Add RSA sources (boost)
+- Support other calculation methods except crossnobis distance

{boostrsa-0.0.1.dev0 → boostrsa-0.0.1.dev3}/setup.py

@@ -8,12 +8,13 @@ with open("README.md", "r") as fh:
 
 setup(
     name = "boostrsa",
-    version = "0.0.1dev",
+    version = "0.0.1dev3",
     author = "seojin",
     author_email = "pures1@hanyang.ac.kr",
     description = "This is toolbox for boosting calculation speed using GPU",
     long_description = long_description,
     long_description_content_type="text/markdown",
+    url = "https://github.com/SeojinYoon/boostrsa.git",
     packages = find_packages(where = "src"),
     package_dir = {"": "src"},
     classifiers = [
@@ -21,7 +22,7 @@ setup(
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-    python_requires='>=3.9',
+    python_requires='>=3.8',
     install_requires = [
         "numpy",
         "pandas",

boostrsa-0.0.1.dev3/src/boostrsa/boostrsa_types.py

@@ -0,0 +1,6 @@
+
+class ShrinkageMethod:
+    shrinkage_eye = "shrinkage_eye"
+    shrinkage_diag = "shrinkage_diag"
+
+

boostrsa-0.0.1.dev3/src/boostrsa/searchlight.py

@@ -0,0 +1,233 @@
+
+# Common Libraries
+import numpy as np
+from numba import cuda, jit
+import cupy as cp
+import itertools
+from tqdm import trange
+
+# Custom Libraries
+from boostrsa_types import ShrinkageMethod
+from cores.cpu.matrix import convert_1d_to_symmertic, mean_fold_variance
+from cores.cpgpu.stats import _covariance_diag, _covariance_eye
+from cores.gpu.mask import set_mask
+from cores.gpu.matrix import calc_kernel, rdm_from_kernel
+
+# Functions
+def calc_sl_precision(residuals, 
+                      neighbors, 
+                      n_split_data, 
+                      masking_indexes, 
+                      n_thread_per_block = 1024,
+                      shrinkage_method = "shrinkage_diag"):
+    """
+    Calculate precision
+    
+    :param residuals(np.ndarray):  , shape: (#run, #point, #channel)
+    :param neighbors(np.ndarray): , shape: (#center, #neighbor)
+    :param n_split_data(int): how many datas to process at once
+    :param masking_indexes(np.array):  , shape: (#channel) / index of masking brain
+    :param n_thread_per_block(int): block per thread
+    
+    return (np.ndarray), shape: (#channel, #run, #neighbor, #neighbor)
+    """
+    
+    n_run = residuals.shape[0]
+    n_p = residuals.shape[1]
+    n_channel = residuals.shape[-1]
+    
+    n_center = len(neighbors)
+    n_block = int(np.ceil(n_split_data / n_thread_per_block))
+    n_neighbor = neighbors.shape[-1]
+    r, c = np.triu_indices(n_neighbor, k = 0)
+    
+    mempool = cp.get_default_memory_pool()
+    
+    chunk_precisions = []
+    for i in trange(0, n_center, n_split_data):
+        # select neighbors
+        target_neighbors = neighbors[i:i + n_split_data, :]
+        len_target = len(target_neighbors)
+        
+        # output_1d
+        mask_out = cuda.to_device(np.zeros((len_target, n_channel)))
+
+        # Make mask - neighbor
+        set_mask[n_block, n_thread_per_block](target_neighbors, masking_indexes, mask_out)
+        
+        # sync
+        cuda.synchronize()
+
+        # Apply mask
+        cpu_mask = mask_out.copy_to_host()
+        masked_residuals = []
+        for j in range(len(target_neighbors)):
+            masked_residuals.append(residuals[:, :, cpu_mask[j] == 1])
+        masked_residuals = np.array(masked_residuals)
+
+        del mask_out
+        cuda.defer_cleanup()
+
+        # Calculate demean
+        target_residuals = masked_residuals.reshape(-1, n_p, n_neighbor)
+        mean_residuals = np.mean(target_residuals, axis = 1, keepdims=1)
+        target_residuals = (target_residuals - mean_residuals)
+
+        # Calculate covariance
+        if shrinkage_method == ShrinkageMethod.shrinkage_diag:
+            covariances = _covariance_diag(target_residuals)
+        elif shrinkage_method == ShrinkageMethod.shrinkage_eye:
+            covariances = _covariance_eye(target_residuals)
+
+        # Calculate precision matrix
+        stack_precisions = cp.linalg.inv(cp.asarray(covariances)).get()
+        
+        # sync
+        cuda.synchronize()
+        
+        # concat
+        stack_precisions = stack_precisions.reshape(len_target, n_run, n_neighbor, n_neighbor)
+        stack_precisions = stack_precisions[:, :, r, c]
+    
+        # add chunk
+        chunk_precisions.append(stack_precisions)
+        
+        # Clean data
+        cuda.defer_cleanup()
+        mempool.free_all_blocks()
+        
+    return chunk_precisions
+
+def calc_sl_rdm_crossnobis(n_split_data, 
+                           centers, 
+                           neighbors, 
+                           precs,
+                           measurements,
+                           masking_indexes,
+                           conds, 
+                           sessions, 
+                           n_thread_per_block = 1000):
+    """
+    Calculate searchlight crossnobis rdm
+    
+    :param n_split_data(int): how many datas to process at once
+    :param centers(np.array): centers, shape: (#center)
+    :param neighbors(np.array): neighbors , shape: (#center, #neighbor)
+    :param precs(np.array): precisions , shape: (#channel, #run, #precision_mat_element)
+    :param measurements(np.array): measurment values , shape: (#cond, #channel)
+    :param masking_indexes: (np.array) , shape: (#channel) , index of masking brain
+    :param conds: conds(np.array - 1d)
+    :param sessions(np.array - 1d): session corressponding to conds
+    :param n_thread_per_block(int): , block per thread
+    
+    """
+    # Data configuration
+    n_run = len(np.unique(sessions))
+    n_cond = len(np.unique(conds))
+    n_dissim = int((n_cond * n_cond - n_cond) / 2)
+    n_neighbor = neighbors.shape[-1]
+    uq_conds = np.unique(conds)
+    n_channel = measurements.shape[-1]
+    uq_sessions = np.unique(sessions)
+    
+    assert n_channel == masking_indexes.shape[0], "n_channel should be same"
+    
+    # Fold
+    fold_info = cuda.to_device(list(itertools.combinations(np.arange(len(uq_sessions)), 2)))
+    n_fold = len(fold_info)
+    total_calculation = n_split_data * n_fold
+    
+    # GPU Configuration
+    n_block = int(np.ceil(n_split_data / n_thread_per_block))
+    n_thread_per_block_2d = int(np.ceil(np.sqrt(n_thread_per_block)))
+    block_2ds = (total_calculation // n_thread_per_block_2d, total_calculation // n_thread_per_block_2d)
+    thread_2ds = (n_thread_per_block_2d, n_thread_per_block_2d)
+    
+    # Memory pool
+    mempool = cp.get_default_memory_pool()
+    
+    # Calculation
+    rdm_outs = []
+    for i in trange(0, len(centers), n_split_data):
+        # select neighbors
+        target_centers = centers[i:i + n_split_data]
+        target_neighbors = neighbors[i:i + n_split_data, :]
+
+        n_target_centers  = len(target_centers)
+
+        # output_1d
+        mask_out = cuda.to_device(np.zeros((n_target_centers, n_channel)))
+
+        # Make mask - neighbor
+        set_mask[n_block, n_thread_per_block](target_neighbors, masking_indexes, mask_out)
+        cuda.synchronize()
+
+        # Apply mask
+        cpu_mask = mask_out.copy_to_host()
+        masked_measurements = []
+        for j in range(n_target_centers):
+            masked_measurements.append(measurements[:, cpu_mask[j] == 1])
+        masked_measurements = np.array(masked_measurements)
+        masked_measurements = cp.asarray(masked_measurements)
+
+        del mask_out
+        cuda.defer_cleanup()
+
+        # precision
+        prec_mat_shape = int((n_neighbor * n_neighbor - n_neighbor) / 2) + n_neighbor
+        target_precs = precs[i:i+n_target_centers].reshape(-1, prec_mat_shape)
+        target_precs = np.array([convert_1d_to_symmertic(pre, size = n_neighbor) for pre in target_precs])
+        variances = cp.linalg.inv(cp.asarray(target_precs))
+        variances = variances.reshape(n_target_centers, n_run, n_neighbor, n_neighbor).get()
+        fold_preicions = cp.linalg.inv(cp.asarray(mean_fold_variance(variances, fold_info.copy_to_host())))
+        fold_preicions = cuda.to_device(fold_preicions.reshape(n_target_centers, len(fold_info), n_neighbor, n_neighbor).get())
+        mempool.free_all_blocks()
+
+        # Avg conds per session
+        avg_measurements = []
+        avg_conds = []
+        for session in uq_sessions:
+            filtering_session = sessions == session
+            sess_cond = conds[filtering_session]
+            sess_measurements = cp.compress(filtering_session, masked_measurements, axis = 1)
+
+            mean_measurments = []
+            for cond in uq_conds:
+                filtering_cond = sess_cond == cond
+                cond_measurments = cp.compress(filtering_cond, sess_measurements, axis = 1)
+                mean_cond_measurement = cp.mean(cond_measurments, axis = 1)
+                mean_measurments.append(cp.expand_dims(mean_cond_measurement, axis = 1))
+
+                avg_conds.append(cond)
+
+            avg_measurements.append(cp.expand_dims(cp.concatenate(mean_measurments, axis = 1), axis = 1))
+        avg_measurements = cp.concatenate(avg_measurements, axis = 1).get()
+
+        avg_conds = np.array(avg_conds)
+
+        mempool.free_all_blocks()
+
+        # make kernel
+        avg_measurements = cuda.to_device(avg_measurements)
+
+        matmul1_out = cuda.to_device(np.zeros((n_target_centers, n_fold, n_cond, n_neighbor)))
+        kernel_out = cuda.to_device(np.zeros((n_target_centers, n_fold, n_cond, n_cond)))
+        calc_kernel[block_2ds, thread_2ds](avg_measurements, fold_preicions, fold_info, matmul1_out, kernel_out)
+
+        cuda.synchronize()
+        del matmul1_out
+        cuda.defer_cleanup()
+
+        rdm_out = cuda.to_device(np.zeros((n_target_centers, n_fold, n_dissim)))
+        rdm_from_kernel[block_2ds, thread_2ds](kernel_out, n_neighbor, rdm_out)
+
+        cuda.synchronize()
+
+        mean_rdms = cp.mean(rdm_out.copy_to_host(), axis = 1)
+        rdm_outs.append(mean_rdms)
+
+        del kernel_out
+        del rdm_out
+        cuda.defer_cleanup()
+        
+    return rdm_outs, uq_conds

boostrsa-0.0.1.dev3/src/boostrsa.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: boostrsa
+Version: 0.0.1.dev3
+Summary: This is toolbox for boosting calculation speed using GPU
+Home-page: https://github.com/SeojinYoon/boostrsa.git
+Author: seojin
+Author-email: pures1@hanyang.ac.kr
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: tqdm
+
+
+# Boostrsa
+
+This library is based on rsatoolbox(https://github.com/rsagroup/rsatoolbox).
+
+The purpose of library is made to boost calcuation speed for searchlight RSA(Representational Similarity Analysis). However, It is still in development, so this library only includes tools for boosting crossnobis distance calculation for constructing RDM(Representational Dissimilartiy Matrix) on the whole brain. 
+
+## How it works?
+
+Basically, this library uses a Nvidia's GPU instead of CPU for parallel processing. In the searchlight analysis, the data targeted for constructing the RDM in volvxes a voxel and its neighboring voxels. That is well-suited for parallel processing since the calculations for each target are independent of one another. This library utilizes GPU-compatible libraries such as Numba and Cupy to facilitate this process.
+
+## Dependencies
+
+To use this library, you need to have a Nvidia's GPU and CUDA. Additionally, this library heavily relies on Cupy and Numba. It is essential to install the appropriate versions of these libraries.
+
+### Cupy
+
+Cupy is designed to work with specific versions of CUDA. See cupy's guide and install appropriate version in correspond to your system (https://github.com/cupy/cupy).
+
+Please check your cuda version to install cupy.
+- versions
+    - cupy-cuda10x (for cuda 10)
+    - cupy-cuda11x (for cuda 11)
+    - cupy-cuda12x (for cuda 12)
+    
+
+If you installed the cuda10 in your computer, then install cupy-cuda10x. install cupy-cuda10x. ex) pip install cupy-cuda10x
+
+### Numba
+
+The numba library is a powerful tool that enbales python functions to be compiled to machine code at runtime using the LLVM. One of its key features is the ability to generate native code for different architectures, including CPUs and GPUs, which greatly accelerates the execution of data-heavy and computationally intense python code.
+
+Please see installation guideline of numba (https://numba.pydata.org/numba-doc/latest/user/installing.html).
+
+Pip installation). 
+- pip install numba
+
+
+## Installation
+
+pip install boostrsa
+
+# Checked version
+
+These are the latest checked environment.
+
+- OS
+    - Linux, ubuntu - 21.10
+- numba
+    - 0.57.0 ~ 0.59.1 is fine to use
+- cupy
+    - cupy-cuda11x
+    - cupy-cuda12x
+
+# Future works
+
+- Add calculation sources to get neighbors and centers (boost)
+- Add RSA sources (boost)
+- Support other calculation methods except crossnobis distance

boostrsa-0.0.1.dev3/src/boostrsa.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE.txt
+README.md
+setup.py
+src/boostrsa/__init__.py
+src/boostrsa/boostrsa_types.py
+src/boostrsa/searchlight.py
+src/boostrsa.egg-info/PKG-INFO
+src/boostrsa.egg-info/SOURCES.txt
+src/boostrsa.egg-info/dependency_links.txt
+src/boostrsa.egg-info/requires.txt
+src/boostrsa.egg-info/top_level.txt
+src/boostrsa/cores/__init__.py
+src/boostrsa/cores/cpgpu/__init__.py
+src/boostrsa/cores/cpgpu/stats.py
+src/boostrsa/cores/cpu/__init__.py
+src/boostrsa/cores/cpu/matrix.py
+src/boostrsa/cores/gpu/__init__.py
+src/boostrsa/cores/gpu/basic_operations.py
+src/boostrsa/cores/gpu/mask.py
+src/boostrsa/cores/gpu/matrix.py
+tests/test_module1.py

boostrsa-0.0.1.dev3/src/boostrsa.egg-info/top_level.txt

@@ -0,0 +1 @@
+boostrsa

boostrsa-0.0.1.dev3/tests/test_module1.py

@@ -0,0 +1,3 @@
+
+def test_example_function():
+    assert True

boostrsa-0.0.1.dev0/PKG-INFO

@@ -1,27 +0,0 @@
-Metadata-Version: 2.1
-Name: boostrsa
-Version: 0.0.1.dev0
-Summary: This is toolbox for boosting calculation speed using GPU
-Author: seojin
-Author-email: pures1@hanyang.ac.kr
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-
-
-# Boostrsa
-
-blahblah
-
-## Setup
-
-### Dependencies
-
-numba
-cupy
-
-### PIP
-

boostrsa-0.0.1.dev0/README.md

@@ -1,14 +0,0 @@
-
-# Boostrsa
-
-blahblah
-
-## Setup
-
-### Dependencies
-
-numba
-cupy
-
-### PIP
-

boostrsa-0.0.1.dev0/src/boostrsa.egg-info/PKG-INFO

@@ -1,27 +0,0 @@
-Metadata-Version: 2.1
-Name: boostrsa
-Version: 0.0.1.dev0
-Summary: This is toolbox for boosting calculation speed using GPU
-Author: seojin
-Author-email: pures1@hanyang.ac.kr
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-
-
-# Boostrsa
-
-blahblah
-
-## Setup
-
-### Dependencies
-
-numba
-cupy
-
-### PIP
-

boostrsa-0.0.1.dev0/src/boostrsa.egg-info/SOURCES.txt

@@ -1,17 +0,0 @@
-LICENSE.txt
-README.md
-setup.py
-src/boostrsa.egg-info/PKG-INFO
-src/boostrsa.egg-info/SOURCES.txt
-src/boostrsa.egg-info/dependency_links.txt
-src/boostrsa.egg-info/requires.txt
-src/boostrsa.egg-info/top_level.txt
-src/cores/__init__.py
-src/cores/cpgpu/__init__.py
-src/cores/cpgpu/stats.py
-src/cores/cpu/__init__.py
-src/cores/cpu/matrix.py
-src/cores/gpu/__init__.py
-src/cores/gpu/basic_operations.py
-src/cores/gpu/mask.py
-src/cores/gpu/matrix.py

boostrsa-0.0.1.dev0/src/boostrsa.egg-info/top_level.txt

@@ -1 +0,0 @@
-cores