boostrsa 0.0.1.dev5__tar.gz → 0.0.1.dev8__tar.gz

{boostrsa-0.0.1.dev5/src/boostrsa.egg-info → boostrsa-0.0.1.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boostrsa
-Version: 0.0.1.dev5
+Version: 0.0.1.dev8
 Summary: This is toolbox for boosting calculation speed using GPU
 Home-page: https://github.com/SeojinYoon/boostrsa.git
 Author: seojin

{boostrsa-0.0.1.dev5 → boostrsa-0.0.1.dev8}/setup.py

@@ -1,6 +1,4 @@
 
-import subprocess
-import re
 from setuptools import setup, find_packages
 
 with open("README.md", "r") as fh:
@@ -8,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name = "boostrsa",
-    version = "0.0.1dev5",
+    version = "0.0.1dev8",
     author = "seojin",
     author_email = "pures1@hanyang.ac.kr",
     description = "This is toolbox for boosting calculation speed using GPU",

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

@@ -0,0 +1,182 @@
+
+import os
+import sys
+import numpy as np
+import cupy as cp
+from numba import cuda, jit
+
+if os.getenv("boostrsa_isRunSource"):
+    sys.path.append(os.getenv("boostrsa_source_home"))
+    from boostrsa_types import ShrinkageMethod
+    from cores.gpu.basic_operations import outer_sum_square, outer_sum
+    from cores.gpu.matrix import diag, eyes
+    from cores.gpu.basic_operations import scaling
+else:    
+    from boostrsa.boostrsa_types import ShrinkageMethod
+    from boostrsa.cores.gpu.basic_operations import outer_sum_square, outer_sum
+    from boostrsa.cores.gpu.matrix import diag, eyes
+    from boostrsa.cores.gpu.basic_operations import scaling
+
+def _covariance_eye(residuals: np.ndarray, 
+                    threads_per_block = 1024, 
+                    dtype = np.float32):
+    """
+    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: residual data after processing raw data, shape: (#run * #center, #point, #channel)
+    :param threads_per_block: #thread per GPU block
+    :param dtype: data type for storing array
+    """
+    # Constant
+    n_processing_unit = len(residuals)
+    n_point = residuals.shape[1]
+    n_channel = residuals.shape[2]
+    
+    n_block = int(np.ceil(n_processing_unit / threads_per_block))
+    
+    """
+    1. calculate outer product per data of each time
+    2. accumulate the outer product result
+
+    GPU memory capacity - (#run * #center, #channel, #channel)
+    """
+    out_sum_device = cuda.to_device(np.zeros((n_processing_unit, n_channel, n_channel), dtype = dtype))
+    outer_sum[n_block, threads_per_block](residuals, out_sum_device)
+    outer_sum_result = out_sum_device.copy_to_host()
+    del out_sum_device
+    cuda.synchronize()
+    
+    """
+    1. calculate outer product per data of each time
+    2. accumulate the outer product result with square operation
+
+    GPU memory capacity - (#run * #center, #channel, #channel)
+    """
+    out_sum_square_device = cuda.to_device(np.zeros((n_processing_unit, n_channel, n_channel), dtype = dtype))
+    outer_sum_square[n_block, threads_per_block](residuals, out_sum_square_device)
+    outer_sum_square_result = out_sum_square_device.copy_to_host()
+    del out_sum_square_device
+    cuda.synchronize()
+    
+    # b2
+    s = outer_sum_result / n_point
+    s2 = outer_sum_square_result / 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: (n_processing_unit)
+    # d2 - shape: (n_processing_unit)
+    # b2 - shape: (n_processing_unit)
+    repeat_eyes = np.repeat(np.eye(n_channel)[:, :, np.newaxis], n_processing_unit, 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: np.ndarray, 
+                     threads_per_block: int = 1024, 
+                     dtype = np.float32):
+    """
+    Calculate covariance 
+    
+    Schäfer, J., & Strimmer, K. (2005). "A Shrinkage Approach to Large-Scale Covariance Matrix Estimation and Implications for Functional Genomics.
+    
+    :param residuals: residual data after processing raw data, shape: (#run * #center, #point, #channel)
+    :param threads_per_block: #thread per GPU block
+    :param dtype: data type for storing array
+    """
+    # Constant
+    n_processing_unit = len(residuals)
+    n_point = residuals.shape[1]
+    n_channel = residuals.shape[2]
+    
+    n_block = int(np.ceil(n_processing_unit / threads_per_block))
+
+    """
+    1. calculate outer product per data of each time
+    2. accumulate the outer product result
+
+    GPU memory capacity: (shape: #run * #center * #channel * #channel)
+    """
+    out_sum_device = cuda.to_device(np.zeros((n_processing_unit, n_channel, n_channel), dtype = dtype))
+    outer_sum[n_block, threads_per_block](residuals, out_sum_device)
+    outer_sum_result = out_sum_device.copy_to_host()
+    del out_sum_device
+    cuda.synchronize()
+    
+    """
+    1. calculate outer product per data of each time
+    2. accumulate the outer product result with square operation
+
+    GPU memory capacity: (shape: #run * #center * #channel * #channel)
+    """
+    out_sum_square_device = cuda.to_device(np.zeros((n_processing_unit, n_channel, n_channel), dtype = dtype))
+    outer_sum_square[n_block, threads_per_block](residuals, out_sum_square_device)
+    outer_sum_square_result = out_sum_square_device.copy_to_host()
+    del out_sum_square_device
+    cuda.synchronize()
+
+    # s
+    dof = n_point - 1
+    s = outer_sum_result / dof
+
+    """
+    Calculate variance per each channel & run
+
+    GPU memory capacity: (shape: #run * #center * #channel * dataType)
+    """
+    stack_var_device = cuda.to_device(np.zeros((n_processing_unit, n_channel)))
+    diag[n_block, threads_per_block](s, stack_var_device)
+    stack_var = stack_var_device.copy_to_host()
+    del stack_var_device
+    cuda.synchronize()
+    
+    # std
+    stack_std = np.sqrt(stack_var)
+
+    # sum mean
+    stack_s_mean = outer_sum_result / np.expand_dims(stack_std, 1) / np.expand_dims(stack_std, 2) / (n_point - 1)
+
+    # s2 mean
+    stack_s2_mean = outer_sum_square_result / np.expand_dims(stack_var, 1) / np.expand_dims(stack_var, 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)
+
+    """
+    Scaling
+
+    GPU memory capacity: (shape: #run * #center * #channel * #channel * dataType)
+    """
+    stack_scaling_mats_device = cuda.to_device(np.zeros((n_processing_unit, n_channel, n_channel), dtype = dtype))
+    eyes[n_block, threads_per_block](stack_scaling_mats_device)
+    cuda.synchronize()
+
+    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[n_block, threads_per_block](stack_scaling_mats_device, stack_lamb_device)
+    stack_s_shrink = s * stack_scaling_mats_device
+    del stack_lamb_device
+    cuda.synchronize()
+    
+    return stack_s_shrink   
+
+

boostrsa-0.0.1.dev8/src/boostrsa/cores/cpu/mask.py

@@ -0,0 +1,12 @@
+
+import numpy as np
+
+def set_mask_cpu(neighbors, brain_1d_indexes):
+    """
+    Set neighbor mask(iterate over all neighbors)
+
+    :param neighbors(np.array - shape: (#center, #neighbor)): list of neighbor
+    :param brain_1d_indexes(np.array - shape: (#channel)): 1d location index converted from 3D brain coordinate (x,y,z)
+    :param out: masked_residual(np.array - shape: (#center, #channel)): output device memory
+    """
+    return np.array([np.where(np.isin(brain_1d_indexes, target_neighbor), 1, 0) for target_neighbor in neighbors])

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

@@ -0,0 +1,66 @@
+
+import numpy as np
+
+def convert_1d_to_symmertic(a_1d, size, k = 0, dtype = np.float32):
+    """
+    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), dtype = dtype)
+    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 (#run, #cov.shape)
+    :param fold_info(2d array): fold information - [[fold1, fold2], ...]
+    
+    return (np.array) - (#run * (#runC2), 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)
+
+def reconstruct_sl_precisionMats(sl_precisions: np.ndarray, n_neighbor: int) -> np.ndarray:
+    """
+    Reconstruct searchlight precision matrix from 1d(combination(n_neighbor, 2)) into 2d(n_neighbor * n_neighbor)
+
+    :param sl_precisions(shape - #center, #source, #element): array of precision matrices
+    :param n_neighbor: a number of neighbor of source from precision matrix
+    
+    return (shape - #center * n_source, n_spaital_dim, n_spatial_dim)
+    """
+    n_center, n_source, n_element = sl_precisions.shape
+    n_batch = n_center * n_source
+
+    # Indices
+    r, c = np.triu_indices(n_neighbor, k = 0)
+    off = (r != c)
+    
+    # Reconstruct matrix
+    dummy = np.zeros((n_batch, n_neighbor, n_neighbor))
+    packed = sl_precisions.reshape(n_batch, n_element)
+    dummy[:, r, c] = packed # Allocate upper triangle elements
+    dummy[:, c[off], r[off]] = packed[:, off] # Allocate lower triangle elements
+    
+    return dummy

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

@@ -0,0 +1,234 @@
+
+from numba import cuda, jit
+from numba.cuda.cudadrv.devicearray import DeviceNDArray
+
+@cuda.jit
+def calc_outerProduct(vec1, vec2, out):
+    """
+    Calculate outer product between vector1 and vector2.
+    This is same as np.outer(vec1, vec2).
+    
+    :param vec1(np.array): vector1
+    :param vec2(np.array): vector2
+    :param out(cuda.cudadrv.devicearray.DeviceNDArray - shape: (#vec1_component, #vec2_component)): output array to store outer product result
+    """
+    i = cuda.grid(1)
+    
+    for j, e1 in enumerate(vec1):
+        for k, e2 in enumerate(vec2):
+            out[j][k] = e1 * e2
+
+@cuda.jit
+def outer_sum(matrices, out):
+    """
+    Calculate outer product and accumulating the result
+    
+    1. Calculate outer product to each data
+        - np.outer(data, data): the data is same
+    2. Accumulate outer result to output array iterating over all datas
+
+    :param matrices(np.array - shape: (#run, #data, #channel)): measurement matrices
+    :param out(cuda.cudadrv.devicearray.DeviceNDArray - shape: (shape: (#run, #channel, #channel))): output array to store data after calculation
+    """
+    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):
+    """
+    Calculate outer product, square, and accumulating the result
+    
+    1. Calculate outer product to each data
+        - np.outer(data, data): the data is same
+    2. Calculate square product on the result
+    3. Accumulate outer result to output array iterating over all datas
+
+    :param matrices(np.array - shape: (#run, #data, #channel)): measurement matrices
+    :param out(cuda.cudadrv.devicearray.DeviceNDArray - shape: (shape: (#run, #channel, #channel))): output array to store data after calculation
+    """
+    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: DeviceNDArray, 
+           b: DeviceNDArray, 
+           out: DeviceNDArray):
+    """
+    Matrix multiplication a @ b
+    
+    :param a(shape - 2d): 2d matrix
+    :param b(shape - 2d): 2d matrix
+    :param out(shape - 2d): 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]
+
+def matmul2(a: DeviceNDArray, 
+            b: DeviceNDArray, 
+            out: DeviceNDArray):
+    """
+    Matrix multiplication - vector @ array(2d)
+
+    :param a(shape: 1d): vector
+    :param b(shape: 2d): 2d array
+    :param output(shape: 1d): output array
+    """
+    n_component_A = a.shape[0]
+    n_row_B, n_col_B = b.shape
+
+    for i in range(n_component_A):
+        for j in range(n_row_B):
+            out[i] += a[j] * b[j, i]
+
+@cuda.jit(device=True, inline=True)
+def matmul_upperTmat(vector: DeviceNDArray, 
+                     upperTmat: DeviceNDArray, 
+                     mul_mapping: DeviceNDArray, 
+                     output: DeviceNDArray):
+    """
+    Multiply matrix with vector and symmetric matrix
+
+    calculation: vector @ upperTmat
+    
+    :param vector(shape : #element): vector
+    :param upperTmat(shape: #comb(#element, 2)): upper triangle matrix including diagnoal element
+    :param mul_mapping(shape: (#element, #element)): index mapping to be multiplied
+    :param output(shape: #element): output array
+    """
+    for vec_i in range(len(vector)):
+        for row_i in range(len(mul_mapping)):
+            output[vec_i] += vector[row_i] * upperTmat[mul_mapping[row_i, vec_i]]
+
+@cuda.jit(device=True, inline=True)
+def minus(a: DeviceNDArray, 
+          b: DeviceNDArray, 
+          out: DeviceNDArray):
+    """
+    Matrix multiplication a @ b
+    
+    :param a(shape - 1d): 1d matrix
+    :param b(shape - 1d): 1d matrix
+    :param out(shape - 1d): output
+    """
+    n_a = len(a)
+    
+    for i in range(n_a):
+        out[i] = a[i] - b[i]
+
+@cuda.jit(device=True, inline=True)
+def dot(a1, a2, output, output_i):
+    for i in range(len(a1)):
+        output[output_i] += a1[i] * a2[i]
+        
+if __name__ == "__main__":
+    dummy_data = np.array([
+        [
+            [1,2,3], 
+            [4,5,6],
+            [5,6,7],
+        ],
+        [
+            [7,8,9], 
+            [0,1,2],
+            [3,4,5],
+        ],
+    ])
+    n_run, n_point, n_channel = dummy_data.shape
+    calc_outerProduct[1,1](dummy_data[0][0], dummy_data[0][1], out)
+
+    out_sum_device = cuda.to_device(np.zeros((n_run, n_channel, n_channel)))
+    outer_sum[1,1](dummy_data, out_sum_device)
+
+    out_sum_device = cuda.to_device(np.zeros((n_run, n_channel, n_channel)))
+    outer_sum_square[1,1](dummy_data, out_sum_device)
+
+    # Matmul 1
+    input_ = cuda.to_device(np.array([[1,2,3]]))
+    array = cuda.to_device(np.arange(1, 10).reshape(3,3))
+    result = cuda.to_device(np.zeros((3,3)).reshape(3,3))
+    matmul(input_, array, result)
+    
+    # Matmul 2
+    input_ = cuda.to_device(np.array([1,2,3]))
+    array = cuda.to_device(np.arange(1, 10).reshape(3,3))
+    result = cuda.to_device(np.zeros(3))
+    matmul2(input_, array, result)
+
+    # Matmul upper triangle mat
+    vector = cuda.to_device(np.array([1,2,3]))
+    n_element = vector.shape[0]
+    r_, c_ = np.triu_indices(n_element, k = 0)
+    upperTmat = np.array([
+        [1,2,3],
+        [2,4,5],
+        [3,5,2],
+    ])
+    upperTmat = cuda.to_device(upperTmat[r_, c_])
+    
+    mul_mapping = np.zeros((n_element, n_element))
+    mul_mapping[r_, c_] = np.arange(r_.shape[0])
+    mul_mapping += mul_mapping.T
+    idx = np.diag_indices(mul_mapping.shape[0])
+    mul_mapping[idx] = mul_mapping[idx] / 2
+    mul_mapping = mul_mapping.astype(int)
+    mul_mapping = cuda.to_device(mul_mapping)
+    output = cuda.to_device(np.zeros(n_element))
+
+    matmul_upperTmat(vector = vector, 
+                 upperTmat = upperTmat, 
+                 mul_mapping = mul_mapping, 
+                 output = output)
+
+    # Minus
+    a = cuda.to_device(np.ones(3))
+    b = cuda.to_device(np.ones(3) * 2)
+    output = cuda.to_device(np.zeros(3))
+    
+    @cuda.jit
+    def minus_jit(a, b, out):
+        minus(a, b, out)
+    minus_jit[1,1](a, b, output)
+
+    # Dot product
+    a1 = np.array([1,2,3])
+    a2 = np.array([1,2,3])
+    output = np.array([0])
+    
+    @cuda.jit
+    def dot_test(a1, a2, output):
+        dot(a1, a2, output, 0)
+    dot_test[1,1](a1, a2, output)

{boostrsa-0.0.1.dev5 → boostrsa-0.0.1.dev8}/src/boostrsa/cores/gpu/mask.py

@@ -2,12 +2,12 @@
 from numba import cuda, jit
 
 @cuda.jit
-def set_mask(neighbors, brain_1d_indexes, out):
+def set_mask_gpu(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 brain_1d_indexes(np.array): 1d location converted from 3D brain coordinate (x,y,z) , shape: #channel
     :param out: masked_residual, output device memory , shape: (#center, #channel)
     """
     i = cuda.grid(1)
@@ -19,5 +19,12 @@ def set_mask(neighbors, brain_1d_indexes, out):
             for brain_i, brain_pos in enumerate(brain_1d_indexes):
                 if brain_pos == neighbor_pos:
                     out[i][brain_i] = 1
-
-
+if __name__ == "__main__":
+    n_split_data = 2024
+    n_channel = 200000
+    n_thread_per_block = 1024
+    
+    n_block = int(np.ceil(n_split_data / n_thread_per_block))
+    mask_out = cuda.to_device(np.zeros((n_split_data, n_channel)))
+    target_neighbors = neighbors[0:0 + n_split_data, :]
+    set_mask[n_block, n_thread_per_block](target_neighbors, masking_indexes, mask_out)