boostrsa 0.0.1.dev0__tar.gz

boostrsa-0.0.1.dev0/LICENSE.txt

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2024 seojin yoon
+
+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.

boostrsa-0.0.1.dev0/PKG-INFO

@@ -0,0 +1,27 @@
+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

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

boostrsa-0.0.1.dev0/setup.cfg

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

boostrsa-0.0.1.dev0/setup.py

@@ -0,0 +1,30 @@
+
+import subprocess
+import re
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name = "boostrsa",
+    version = "0.0.1dev",
+    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",
+    packages = find_packages(where = "src"),
+    package_dir = {"": "src"},
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.9',
+    install_requires = [
+        "numpy",
+        "pandas",
+        "tqdm",
+    ]
+)

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,17 @@
+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/dependency_links.txt

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+numpy
+pandas
+tqdm

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

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

boostrsa-0.0.1.dev0/src/cores/cpgpu/stats.py

@@ -0,0 +1,130 @@
+
+import numpy as np
+import cupy as cp
+from numba import cuda, jit
+from boostrsa.src.types import ShrinkageMethod
+from boostrsa.src.gpu.basic_operations import outer_sum_square, outer_sum
+from boostrsa.src.gpu.matrix import diag, eyes
+from boostrsa.src.gpu.basic_operations import scaling
+
+def _covariance_eye(residuals, threads_per_block = 1024):
+    """
+    Computes an optimal shrinkage estimate of a sample covariance matrix as described by the following publication:
+    **matrix should be demeaned before!
+    
+    Ledoit and Wolfe (2004): "A well-conditioned estimator for large-dimensional covariance matrices"
+    
+    :param residuals(np.ndarray): , shape: (#data, #n_point, #n_channel)
+    """
+    print("shrinakge method:", ShrinkageMethod.shrinkage_eye)
+    
+    # Constant
+    data_len = len(residuals)
+    n_point = residuals.shape[1]
+    n_channel = residuals.shape[2]
+    
+    n_block = int(np.ceil(data_len / threads_per_block))
+    
+    # sum
+    out_sum_device = cuda.to_device(np.zeros((data_len, n_channel, n_channel)))
+
+    # sum square
+    out_sum_square_device = cuda.to_device(np.zeros((data_len, n_channel, n_channel)))
+    
+    # Calc sum, sum square
+    outer_sum[n_block, threads_per_block](residuals, out_sum_device)
+    outer_sum_square[n_block, threads_per_block](residuals, out_sum_square_device)
+
+    # b2
+    s = out_sum_device.copy_to_host() / n_point
+    s2 = out_sum_square_device.copy_to_host() / n_point
+    b2 = np.sum(s2 - s * s, axis = (1, 2)) / n_point
+
+    # calculate the scalar estimators to find the optimal shrinkage:
+    # m, d^2, b^2 as in Ledoit & Wolfe paper
+    # m - shape: (data_len)
+    # d2 - shape: (data_len)
+    # b2 - shape: (data_len)
+    repeat_eyes = np.repeat(np.eye(n_channel)[:, :, np.newaxis], data_len, axis = 2).T
+    
+    diag_s = np.diagonal(s, axis1 = 1, axis2 = 2)
+    m = (np.sum(diag_s, axis = 1) / n_channel)
+    d2 = np.sum((s - m[:, None, None] * repeat_eyes) ** 2, axis = (1, 2))
+    
+    b2 = np.minimum(d2, b2)
+    
+    # shrink covariance matrix
+    s_shrink = (b2 / d2 * m)[:, None, None] * repeat_eyes + ((d2-b2) / d2)[:, None, None] * s
+    
+    # correction for degrees of freedom
+    dof = n_point - 1
+    s_shrink = s_shrink * n_point / dof
+    
+    return s_shrink
+
+def _covariance_diag(residuals, threads_per_block = 1024):
+    """
+    Calculate covariance 
+    **matrix should be demeaned before!
+    
+    Schäfer, J., & Strimmer, K. (2005). "A Shrinkage Approach to Large-Scale
+    Covariance Matrix Estimation and Implications for Functional Genomics.
+    
+    :param residuals(np.ndarray): , shape: (#data, #n_point, #n_channel)
+    """
+    print("shrinakge method:", ShrinkageMethod.shrinkage_diag)
+    
+    # Constant
+    data_len = len(residuals)
+    n_point = residuals.shape[1]
+    n_channel = residuals.shape[2]
+    
+    n_block = int(np.ceil(data_len / threads_per_block))
+
+    # sum
+    out_sum_device = cuda.to_device(np.zeros((data_len, n_channel, n_channel)))
+
+    # sum square
+    out_sum_square_device = cuda.to_device(np.zeros((data_len, n_channel, n_channel)))
+
+    # Calc sum, sum square
+    outer_sum[n_block, threads_per_block](residuals, out_sum_device)
+    outer_sum_square[n_block, threads_per_block](residuals, out_sum_square_device)
+
+    # s
+    dof = n_point - 1
+    s = out_sum_device.copy_to_host() / dof
+
+    # var
+    stack_var_device = cuda.to_device(np.zeros((data_len, n_channel)))
+    diag[n_block, threads_per_block](s, stack_var_device)
+
+    # std
+    stack_std = np.sqrt(stack_var_device)
+
+    # sum mean
+    stack_s_mean = out_sum_device / np.expand_dims(stack_std, 1) / np.expand_dims(stack_std, 2) / (n_point - 1)
+
+    # s2 mean
+    stack_s2_mean = out_sum_square_device / np.expand_dims(stack_var_device, 1) / np.expand_dims(stack_var_device, 2) / (n_point - 1)
+
+    # var_hat
+    stack_var_hat = n_point / dof ** 2 * (stack_s2_mean - stack_s_mean ** 2)
+
+    # mask
+    mask = ~np.eye(n_channel, dtype=bool)
+
+    # lamb
+    stack_lamb_device = np.sum(stack_var_hat[:, mask], axis = 1) / np.sum(stack_s_mean[:, mask] ** 2, axis = 1)
+    stack_lamb_device = cp.maximum(cp.minimum(cp.array(stack_lamb_device), 1), 0)
+
+    # Scaling
+    stack_scaling_mats_device = cuda.to_device(np.zeros((data_len, n_channel, n_channel)))
+    eyes[n_block, threads_per_block](stack_scaling_mats_device)
+
+    scaling[n_block, threads_per_block](stack_scaling_mats_device, stack_lamb_device)
+    stack_s_shrink = s * stack_scaling_mats_device
+    
+    return stack_s_shrink   
+
+

boostrsa-0.0.1.dev0/src/cores/cpu/matrix.py

@@ -0,0 +1,44 @@
+
+import numpy as np
+
+def convert_1d_to_symmertic(a_1d, size, k = 0):
+    """
+    Convert 1d array to symmetric matrix
+    
+    :param a_1d(1d array): 
+    :param size: matrix size
+    :param k(int): offset 
+    
+    return (np.array)
+    """
+
+    # put it back into a 2D symmetric array
+
+    X = np.zeros((size,size))
+    X[np.triu_indices(size, k = 0)] = a_1d
+    X = X + X.T - np.diag(np.diag(X))
+
+    return X
+
+def mean_fold_variance(variances, fold_info):
+    """
+    Calculate fold variacne from fold info
+    
+    :param variances: variances (#data, #cov.shape)
+    :param fold_info(2d array): fold information - [[fold1, fold2], ...]
+    
+    return (np.array) - (#data * fold_len, cov.shape)
+    """
+    n_d = len(variances)
+    
+    result_variances = []
+    for i in range(n_d):       
+        for fold1_i, fold2_i in fold_info:            
+            cov1 = variances[i][fold1_i]
+            cov2 = variances[i][fold2_i]
+            
+            result_variances.append((cov1 + cov2) / 2)
+    
+    return np.array(result_variances)
+
+

boostrsa-0.0.1.dev0/src/cores/gpu/basic_operations.py

@@ -0,0 +1,61 @@
+
+from numba import cuda, jit
+
+@cuda.jit
+def outer_sum(matrices, out):
+    i = cuda.grid(1)
+
+    if i < len(matrices):
+        matrix = matrices[i]
+
+        for m_line in matrix:
+            for j, e1 in enumerate(m_line):
+                for k, e2 in enumerate(m_line):
+                    out[i][j][k] += e1 * e2
+
+@cuda.jit
+def outer_sum_square(matrices, out):
+    i = cuda.grid(1)
+
+    if i < len(matrices):
+        matrix = matrices[i]
+
+        for m_line in matrix:
+            for j, e1 in enumerate(m_line):
+                for k, e2 in enumerate(m_line):
+                    out[i][j][k] += (e1 * e2) ** 2
+
+@cuda.jit
+def scaling(out, lambs):
+    i = cuda.grid(1)
+    lamb = lambs[i]
+
+    nd = out.shape[0]
+    nr = out.shape[1]
+    nc = out.shape[2]
+
+    if i < len(out):
+        for j in range(nr):
+            for k in range(nc):
+                if j != k:
+                    out[i][j][k] = (1 - lamb)
+
+@cuda.jit(device=True, inline=True)
+def matmul(a,b, out):
+    """
+    Matrix multiplication a @ b
+    
+    :param a(np.array): 2d matrix
+    :param b(np.array): 2d matrix
+    :param out(device array): output
+    """
+    ar,ac = a.shape 
+    br,bc = b.shape 
+    
+    for i in range(ar):
+        for j in range(bc):
+            for k in range(ac): # or br
+                out[i,j] += a[i,k] * b[k,j]
+    return out
+
+

boostrsa-0.0.1.dev0/src/cores/gpu/mask.py

@@ -0,0 +1,23 @@
+
+from numba import cuda, jit
+
+@cuda.jit
+def set_mask(neighbors, brain_1d_indexes, out):
+    """
+    Set neighbor mask(iterate over all neighbors)
+
+    :param neighbors(np.array): list of neighbor , shape: (#center, #neighbor)
+    :param brain_1d_indexes(np.array): , shape: #channel
+    :param out: masked_residual, output device memory , shape: (#center, #channel)
+    """
+    i = cuda.grid(1)
+
+    if i < len(neighbors):
+        neighbor_positions = neighbors[i]
+
+        for neighbor_pos in neighbor_positions:
+            for brain_i, brain_pos in enumerate(brain_1d_indexes):
+                if brain_pos == neighbor_pos:
+                    out[i][brain_i] = 1
+
+

boostrsa-0.0.1.dev0/src/cores/gpu/matrix.py

@@ -0,0 +1,125 @@
+
+from numba import cuda, jit
+from basic_operations import matmul
+
+@jit(nopython=True)
+def upper_tri_1d_index(i, j, n_col, k):
+    """
+    Get upper triangle 1d index
+    
+    if k = 1)
+    
+    (0,1), (0,2), (0,3), (0,4) -> 0, 1, 2, 3
+           (1,2), (1,3), (1,4) -> 4, 5, 6
+                  (2,3), (2,4) -> 7, 8
+                         (3,3) -> 9
+                         
+    :param i: row index
+    :param j: column index
+    :param n_col: column number
+    :param k: #padding
+    """
+    if i > j:
+        return None
+    else:
+        sum_val = 0
+        for loop_row_i in range(0, i):
+            sum_val += (n_col - k) # maximum filled count of row.
+            sum_val += (-1) * loop_row_i # non-filled element is increased as row value is increased.
+        return sum_val + (j - i - k)
+
+@jit(nopython=True)
+def lower_tri_1d_index(i, j):
+    """
+    Get lower triangle 1d index
+    
+    :param i: row index
+    :param j: column index
+    """
+    
+    if i < j:
+        return None
+    else:        
+        total_fill = 0
+        for pr_row_i in range(1, i + 1):
+            total_fill += (pr_row_i - 1)
+        return total_fill + j
+
+@cuda.jit
+def diag(matrices, out):
+    i = cuda.grid(1)
+
+    if i < len(matrices):
+        matrix = matrices[i]
+
+        n_row = len(matrix)
+        for j in range(n_row):
+            out[i][j] = matrix[j][j]
+
+@cuda.jit
+def eyes(out):
+    i = cuda.grid(1)
+
+    nd = out.shape[0]
+    nr = out.shape[1]
+    nc = out.shape[2]
+
+    if i < len(out):
+        for j in range(nr):
+            out[i][j][j] = 1
+
+@cuda.jit
+def rdm_from_kernel(kernels, div, out):
+    """
+    Calculate rdm matrix
+    
+    :param kernels(Device array): kernel, shape: (n_data, n_fold, n_cond, n_cond))
+    :param div(int): div value
+    :param out(Device array): rdm output, shape: (n_data, n_fold, n_dissim)
+    """
+    n_data = kernels.shape[0]
+    n_validation = kernels.shape[1]
+    n_cond = kernels.shape[-1]
+    
+    i, j = cuda.grid(2)
+    
+    if i < n_data:
+        if j < n_validation:
+            kernel = kernels[i][j]
+            
+            for row_i in range(n_cond):
+                for column_i in range(n_cond):
+                    if row_i < column_i:
+                        dissim_i = int(upper_tri_1d_index(row_i, column_i, n_cond, 1))
+
+                        # Assign dissim value
+                        v1 = kernel[row_i][row_i] + kernel[column_i][column_i]
+                        v2 = kernel[row_i][column_i] + kernel[column_i][row_i]
+                        out[i][j][dissim_i] = (v1 - v2) / div
+
+@cuda.jit
+def calc_kernel(measurments, precisions, fold_info, out1, out2):
+    """
+    Calculate rdm kernel for calculating crossnobis
+    
+    (2048, 4, 8, 93)
+    
+    :param measurments(Device array): , shape: (n_data, n_run, n_cond, n_neighbor)
+    :param precisions(Device array): , shape: (n_data, n_fold, n_neighbor, n_neighbor)
+    :param fold_info(Device array): fold information - [[fold1, fold2], ...]
+    :param out1(Device array): intermediate matmul output , shape: (n_data, n_fold, n_cond, n_neighbor) 
+    :param out2(Device array): kernel output , shape: (n_data, n_fold, n_cond, n_cond))
+    """
+    n_data = out1.shape[0]
+    n_validation = out1.shape[1]
+
+    i, j = cuda.grid(2)
+    if i < n_data:
+        if j < n_validation:
+            data1_i, data2_i = fold_info[j]
+            
+            # measurements1 @ noise @ measurements2.T
+            matmul(measurments[i][data1_i], precisions[i][j], out1[i][j])
+            matmul(out1[i][j], measurments[i][data2_i].T, out2[i][j])
+
+