vneumodpy 0.1.6__py3-none-any.whl

vneumodpy/__init__.py

@@ -0,0 +1,38 @@
+
+from .models.multivaliate_var_network import MultivariateVARNetwork
+from .models.mvar_init_with_cell_mth import call_executor as mvar_init_with_cell_mth
+from .models.regress import linear
+from .models.regress import prepare
+from .models.regress import inv_qr
+from .models import group_range
+
+from .glm.canonical_hrf import get as canonical_hrf
+from .glm.hrf_design_matrix import get as hrf_design_matrix
+from .glm.tukey import calc as tukey
+from .glm.tukey_mp import calc as tukey_mp  # multi processing version
+from .glm.contrast_image import calc as contrast_image
+from .glm.roi_ts_to4dimage import get as roi_ts_to4dimage
+from .glm.roi_ts_from4dimage import get as roi_ts_from4dimage
+from .glm.adjust_volume_dir import adjust_volume_dir
+from .glm.resampling_nifti_volume import resampling_nifti_volume
+
+from .surrogate.multivariate_var import calc as multivariate_var
+from .surrogate.dbs_multivariate_var import calc as dbs_multivariate_var
+from .surrogate.vnm_addmul_signals import get as vnm_addmul_signals
+from .surrogate.vnm_var_surrogate import calc as vnm_var_surrogate
+from .surrogate.vnm_subject_perm import get as vnm_subject_perm
+
+from .measures import ac
+from .measures import pac
+from .measures import cm
+from .measures import ccm
+from .measures import pcm
+from .measures import pccm
+from .measures import pccm_
+from .measures import mtess
+from .measures import mskewkurt
+from .measures.cos_sim import calc as cos_sim
+
+from .nuisance.mean_time_series import get as nuisance_mean_time_series
+from .nuisance.acompcor import get as nuisance_acompcor
+from .nuisance.regression_out import get as nuisance_regression_out

vneumodpy/glm/adjust_volume_dir.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+##
+# Adjust NIfTI volume direction based on NIfTI info Transpose matrix
+# returns adjusted NIfTI volume
+# input:
+#  V            nifti 4D volume (X x Y x Z x frames)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+
+
+def adjust_volume_dir(V, info):
+    A = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])
+    if np.sum(np.abs(A * info.affine[:3, :3])) > 0:
+        print('nifti volume transformation is not supported.')
+        return V
+    if info.affine[0, 0] < 0:  # check flip X axis
+        V = np.flipud(V).copy()
+    if info.affine[1, 1] < 0:  # check flip Y axis
+        V = np.fliplr(V).copy()
+    if info.affine[2, 2] < 0:  # check flip Z axis
+        V = np.flip(V, axis=2).copy()
+    return V

vneumodpy/glm/canonical_hrf.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+##
+# get GLM Canonical hemodynamic response function
+# returns time range (t), HRF time-series (hrf)
+# input:
+#  dt                 time resolution (sec) (default:0.045)
+#  responseDelay      delay of response (gamma a)(sec) (default:6)
+#  underShootDelay    delay of undershoot (gamma a)(sec) (default:16)
+#  kernelSec          kernel time length (sec) (default: 32)
+#  underShootRatio    ratio of underShoot (default: 0.167)
+#  hrfScale           HRF scale (gamma b) (default: 0.9)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import gamma
+
+def get(dt=0.045, response_delay=6, under_shoot_delay=16, kernel_sec=32, under_shoot_ratio=0.167, hrf_scale=0.9):
+
+    t = np.arange(0, kernel_sec+dt, dt)
+    hrf = gamma.pdf(t,response_delay,scale=hrf_scale) - gamma.pdf(t,under_shoot_delay,scale=hrf_scale) * under_shoot_ratio
+    hrf = hrf.T / np.sum(hrf)
+    return t, hrf

vneumodpy/glm/contrast_image.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate GLM Contrast Image with prewhitening.
+# based on K.J.Friston et al. (2000), M.W.Woolrich et al. (2001), K.J.Worsley (2001)
+# returns cells of T-value matrix (Ts)
+# input:
+#  Cs           cells of contrast vectors (contrasts (predictor size) x 1)
+#  B            predictor variables (node x predictor variables)
+#  RSS          Residual Sum of Squares (node x 1)
+#  X2is         Vector or single value of inv(X' * X) for contrast
+#  tRs          Vector or single value of trace(R) for contrast
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from math import sqrt
+
+def calc(Cs, B, RSS, X2is, tRs):
+    # GLM contrast image
+    # T = (c' * B) / sqrt(c' * X' * inv(V) * X * c * (RSS / trace(R)))
+    Ts = []
+    roiNum = RSS.shape[0]
+    T2 = np.zeros((roiNum,1), dtype=np.float32)
+
+    for c in Cs:
+        for i in range(roiNum):
+            if X2is.shape[0] == roiNum:
+                X2i = X2is[i, :, :]
+                d = sqrt(c.T @ X2i @ c)
+            else:
+                d = sqrt(c.T @ X2is @ c)
+
+            if tRs.shape[0] == roiNum:
+                se2 = sqrt(RSS[i].item() / tRs[i].item()) # to scalar
+            else:
+                se2 = sqrt(RSS[i].item() / tRs) # to scalar
+
+            T2[i] = (c.T @ B[i, :].T) / (d * se2)
+        Ts.append(T2.copy())
+    return Ts

vneumodpy/glm/hrf_design_matrix.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# get GLM HRF (hemodynamic response function) design matrix
+# input:
+#  onsets       cells of task set start time
+#  durations    cells of task set duration
+#  frames       fMRI time frames
+#  TR           fMRI TR
+#  res          sampling resolution of HRF
+#  sp           sampling starting point (in resolution)
+#  hrf          Canonical hemodynamic response function (optional)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+
+from ..glm.canonical_hrf import get as canonical_hrf    # for command mode
+
+def get(onsets, durations, frames, TR, res, sp, hrf=[]):
+
+    # get Canonical hemodynamic response function
+    if len(hrf) == 0:
+        dt = TR / res
+        t, hrf = canonical_hrf(dt)
+
+    tasknum = len(onsets)
+    X = np.zeros((frames * res, tasknum), float)
+    U = np.zeros((frames * res, tasknum), float)
+    for k in range(tasknum):
+        onset = onsets[k]
+        duration = durations[k]
+        for i in range(len(onset)):
+            t1 = int(np.ceil(onset[i] / TR * res))
+            t2 = int(np.ceil(t1 + duration[i] / TR * res))
+            U[t1-1:t2,k] = 1
+        # get design matrix
+        C = np.convolve(U[:,k], hrf)
+        X[:,k] = C[0:frames * res]
+
+    # final sampling
+    X = X[np.arange((sp-1),X.shape[0],res),:]
+    U = U[np.arange((sp-1),U.shape[0],res),:]
+    return X, U

vneumodpy/glm/resampling_nifti_volume.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# resampling NIfTI volume.
+# returns re-sampled volume (outV)
+# input:
+#  V            nifti 3D volume (X x Y x Z)
+#  stepXY       XY axes resampling rate
+#  stepZ        Z axes resampling rate
+#  operation    operation for each plane ('mode'(default),'max','min','mean','median')
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import mode
+
+def resampling_nifti_volume(V, stepXY, stepZ, operation='mode'):
+    xs = int(np.floor(V.shape[0] / stepXY))
+    ys = int(np.floor(V.shape[1] / stepXY))
+    zs = int(np.floor(V.shape[2] / stepZ))
+    outV = np.zeros((xs, ys, zs), dtype=np.float32)
+
+    if stepXY >= 1 and stepZ >= 1:
+        # scale down
+        for z in range(1,zs+1):
+            for y in range(1,ys+1):
+                for x in range(1,xs+1):
+                    x_start = int(round(x * stepXY - (stepXY - 1))) - 1
+                    x_end = int(round(x * stepXY))
+                    y_start = int(round(y * stepXY - (stepXY - 1))) - 1
+                    y_end = int(round(y * stepXY))
+                    z_start = int(round(z * stepZ - (stepZ - 1))) - 1
+                    z_end = int(round(z * stepZ))
+                    A = V[x_start:x_end, y_start:y_end, z_start:z_end]
+
+                    if operation == 'mode':
+                        A_flat = A[~np.isnan(A)]
+                        if A_flat.size == 0:
+                            m = np.nan
+                        else:
+                            m = mode(A_flat, axis=None).mode[0]
+                    elif operation == 'min':
+                        m = np.nanmin(A)
+                    elif operation == 'max':
+                        m = np.nanmax(A)
+                    elif operation == 'mean':
+                        m = np.nanmean(A)
+                    elif operation == 'median':
+                        m = np.nanmedian(A)
+                    else:
+                        raise ValueError(f"Unsupported operation: {operation}")
+
+                    outV[x-1, y-1, z-1] = m
+    else:
+        # scale up
+        out_shape = (
+            int(np.ceil(V.shape[0] / stepXY)),
+            int(np.ceil(V.shape[1] / stepXY)),
+            int(np.ceil(V.shape[2] / stepZ))
+        )
+        outV = np.zeros(out_shape, dtype=np.float32)
+
+        for z in range(1,V.shape[2]+1):
+            for y in range(1,V.shape[1]+1):
+                for x in range(1,V.shape[0]+1):
+                    m = V[x-1, y-1, z-1]
+                    xx_start = int(round((x-1) / stepXY))
+                    xx_end = int(round(x / stepXY))
+                    yy_start = int(round((y-1) / stepXY))
+                    yy_end = int(round(y / stepXY))
+                    zz_start = int(round((z-1) / stepZ))
+                    zz_end = int(round(z / stepZ))
+                    outV[xx_start:xx_end, yy_start:yy_end, zz_start:zz_end] = m
+
+    return outV

vneumodpy/glm/roi_ts_from4dimage.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+##
+# get ROI time-series (matrix) from NIfTI 4D volume.
+# returns ROI time-series (X)
+# input:
+#  V            nifti 4D volume (X x Y x Z x frames)
+#  atlasV       nifti 3D atlas (X x Y x Z)
+#  operation    calc operation for each plane ('mode'(default),'max','min','mean','median','sum')
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import mode
+
+def get(V, atlasV, operation='mode'):
+    roiIdx = np.unique(atlasV)
+    roiIdx = roiIdx[roiIdx != 0]  # remove 0
+
+    X = np.zeros((len(roiIdx), V.shape[3]), dtype=np.float32)
+    A = V.reshape(-1, V.shape[3])
+    for i in range(len(roiIdx)):
+        j = roiIdx[i]
+        B = A[atlasV.flatten() == j, :]
+        if operation == 'mode':
+            m = mode(B, axis=0, nan_policy='omit').mode[0]
+        elif operation == 'min':
+            m = np.nanmin(B, axis=0)
+        elif operation == 'max':
+            m = np.nanmax(B, axis=0)
+        elif operation == 'mean':
+            m = np.nanmean(B, axis=0)
+        elif operation == 'median':
+            m = np.nanmedian(B, axis=0)
+        elif operation == 'sum':
+            m = np.nansum(B, axis=0)
+        else:
+            raise ValueError(f"Unsupported operation: {operation}")
+        X[i, :] = m
+    return X

vneumodpy/glm/roi_ts_to4dimage.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+##
+# get NIfTI 4D volume from ROI time-series (matrix).
+# returns nifti 4D volume (V)(X x Y x Z x frames)
+# input:
+#  X            ROI time-series (ROIs x frames)
+#  atlasV       nifti 3D atlas (X x Y x Z)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+
+def get(X, atlasV):
+    roinum = X.shape[0]
+
+    xs, ys, zs = atlasV.shape
+    V = np.full((xs, ys, zs, X.shape[1]), np.nan, dtype=np.float32)
+
+    idxs = [None] * roinum
+    aVf = atlasV.flatten()
+    aVfidx = np.array(range(aVf.shape[0]))
+    for i in range(roinum):
+        idxs[i] = aVfidx[aVf == (i+1)]
+
+    for t in range(X.shape[1]):
+        A = np.full((xs, ys, zs), np.nan, dtype=np.float32)
+        for i in range(roinum):
+            A.flat[idxs[i]] = X[i, t]
+        V[:, :, :, t] = A
+
+    return V

vneumodpy/glm/tukey.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate General Linear Model with prewhitening (Tukey-Taper, Auto-correlation estimation Version)
+# based on M.W.Woolrich et al. (2001)
+#   Y = X * B + e
+#   e ~ N(0, s^2 * V)
+#   S * Y = S * X * B + r
+#   S = inv(K)
+#   V = K * K'
+#   V is auto-corerlation matrix estimated by Tukey-Taper
+#   r ~ N(0, s^2 * SVS') therefore N(0, s^2 * I)
+# This function is used for single session.
+# returns predictor variables (B), Residual Sum of Squares (RSS), degree of freedom (df),
+#   inv(X' * X) for contrast (X2is), trace(R) for contrast (tRs), full of Residuals (R)
+# input:
+#  Y         ROI or voxel time series (time series x node)
+#  X         design matrix (time series x predictor variables)
+#  tuM       Tukey-Taper window size (default: sqrt(time series length))
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+import time
+from scipy.linalg import toeplitz, cholesky, inv
+from scipy.stats import linregress
+
+def calc(Y, X, tuM=None, isOutX2is=False):
+    if tuM is None:
+        tuM = int(np.floor(np.sqrt(X.shape[0])))
+
+    print('process GLM with Tukey-Taper(' +str(tuM)+ ') estimation ...')
+    roiNum = Y.shape[1]
+    xsz = X.shape[1]
+    X2is = np.full((roiNum, xsz, xsz), np.nan, dtype=np.float32)
+    tRs = np.full((roiNum,1), np.nan, dtype=np.float32)
+    B = np.full((roiNum, xsz), np.nan, dtype=np.float32)
+    RSS = np.full((roiNum,1), np.nan, dtype=np.float32)
+    df = X.shape[0] - X.shape[1]
+
+    # make Tukey window
+    tuWin = np.zeros(tuM, dtype=np.float32)
+    for k in range(tuM):
+        tuWin[k] = 0.5 * (1 + np.cos(np.pi * (k+1) / tuM))
+
+    def regress(y, X):
+        # Equivalent to MATLAB regress: returns b, residuals
+        b, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
+        r = y - X @ b
+        return b, r
+
+    start = time.time()
+    for i in range(roiNum):
+        Yi = Y[:, i]
+        # 1st step OLS regression
+        _, r = regress(Yi, X)
+
+        # if residuals are all zero, probably original signal is just zero. ignore this voxel
+        if np.sum(r == 0) == r.shape[0]:
+            B[i, :] = 0
+            RSS[i] = 0
+            continue
+
+        # calc AR coefficients by Tukey-Taper of frequency domain
+        C = np.correlate(r, r, mode='full') / np.dot(r, r)
+        mid = len(C) // 2
+        Rxx = C[mid:mid + tuM]
+        Pxx = np.zeros(r.shape[0], dtype=np.float32)
+        Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+        V1 = toeplitz(Pxx)
+        K1 = np.linalg.cholesky(V1)  # upper=False is not necessary (numpy v1)
+
+        # second time regression
+#        Ki1 = np.linalg.inv(K1)
+#        Ya = Ki1 @ Yi
+#        Xt = Ki1 @ X
+        Ya = np.linalg.solve(K1, Yi)
+        Xt = np.linalg.solve(K1, X)
+        b, r = regress(Ya, Xt)
+
+        B[i, :] = b
+        RSS[i] = r.T @ r
+        if not isOutX2is:
+            continue
+
+        # used for contrast
+        C = np.correlate(r, r, mode='full') / np.dot(r, r)
+        Rxx = C[mid:mid + tuM]
+        Pxx = np.zeros(r.shape[0], dtype=np.float32)
+        Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+
+        V2 = toeplitz(Pxx)
+        X2is[i, :, :] = inv(X.T @ (inv(V2) @ X))
+        IR = np.eye(Xt.shape[0]) - Xt @ inv(Xt.T @ Xt) @ Xt.T
+        tRs[i] = np.trace(IR)
+
+    print('done t=' + str(time.time() - start) + ' sec')
+    return B, RSS, df, X2is, tRs

vneumodpy/glm/tukey_mp.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate General Linear Model with prewhitening (Tukey-Taper, Auto-correlation estimation Version)
+# based on M.W.Woolrich et al. (2001)
+#   Y = X * B + e
+#   e ~ N(0, s^2 * V)
+#   S * Y = S * X * B + r
+#   S = inv(K)
+#   V = K * K'
+#   V is auto-corerlation matrix estimated by Tukey-Taper
+#   r ~ N(0, s^2 * SVS') therefore N(0, s^2 * I)
+# This function is used for single session.
+# returns predictor variables (B), Residual Sum of Squares (RSS), degree of freedom (df),
+#   inv(X' * X) for contrast (X2is), trace(R) for contrast (tRs), full of Residuals (R)
+# input:
+#  Y         ROI or voxel time series (time series x node)
+#  X         design matrix (time series x predictor variables)
+#  tuM       Tukey-Taper window size (default: sqrt(time series length))
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+import time
+import os
+from scipy.linalg import toeplitz, cholesky, inv
+from scipy.stats import linregress
+from concurrent.futures import ProcessPoolExecutor
+
+
+def regress(y, X):
+    # Equivalent to MATLAB regress: returns b, residuals
+    b, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
+    r = y - X @ b
+    return b, r
+
+def loop_fn(i, Yi, X, tuWin, tuM, isOutX2is):
+    # 1st step OLS regression
+    _, r = regress(Yi, X)
+
+    # if residuals are all zero, probably original signal is just zero. ignore this voxel
+    if np.sum(r == 0) == r.shape[0]:
+        return i, 0, 0
+
+    # calc AR coefficients by Tukey-Taper of frequency domain
+    C = np.correlate(r, r, mode='full') / np.dot(r, r)
+    mid = len(C) // 2
+    Rxx = C[mid:mid + tuM]
+    Pxx = np.zeros(r.shape[0], dtype=np.float32)
+    Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+    V1 = toeplitz(Pxx)
+    K1 = np.linalg.cholesky(V1) # upper=False is not necessary (numpy v1)
+
+    # second time regression
+#    Ki1 = np.linalg.inv(K1)
+#    Ya = Ki1 @ Yi
+#    Xt = Ki1 @ X
+    Ya = np.linalg.solve(K1, Yi)
+    Xt = np.linalg.solve(K1, X)
+    b, r = regress(Ya, Xt)
+
+    rss = r.T @ r
+    if not isOutX2is:
+        return i, b, rss
+
+    # used for contrast
+    C = np.correlate(r, r, mode='full') / np.dot(r, r)
+    Rxx = C[mid:mid + tuM]
+    Pxx = np.zeros(r.shape[0], dtype=np.float32)
+    Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+
+    V2 = toeplitz(Pxx)
+    x2is = inv(X.T @ (inv(V2) @ X))
+    IR = np.eye(Xt.shape[0]) - Xt @ inv(Xt.T @ Xt) @ Xt.T
+    trs = np.trace(IR)
+    return i, b, rss, x2is, trs
+
+def calc(Y, X, tuM=None, isOutX2is=False, n_jobs=8):
+    if tuM is None:
+        tuM = int(np.floor(np.sqrt(X.shape[0])))
+
+    print('process GLM with Tukey-Taper(' +str(tuM)+ ') estimation ...')
+    roiNum = Y.shape[1]
+    xsz = X.shape[1]
+    X2is = np.full((roiNum, xsz, xsz), np.nan, dtype=np.float32)
+    tRs = np.full((roiNum,1), np.nan, dtype=np.float32)
+    B = np.full((roiNum, xsz), np.nan, dtype=np.float32)
+    RSS = np.full((roiNum,1), np.nan, dtype=np.float32)
+    df = X.shape[0] - X.shape[1]
+
+    # make Tukey window
+    tuWin = np.zeros(tuM, dtype=np.float32)
+    for k in range(tuM):
+        tuWin[k] = 0.5 * (1 + np.cos(np.pi * (k+1) / tuM))
+
+    start = time.time()
+    with ProcessPoolExecutor(max_workers=n_jobs) as executor:  # -----(2)
+        futures = set()
+        for i in range(roiNum):
+            future = executor.submit(loop_fn, i, Y[:, i], X, tuWin, tuM, isOutX2is)
+            futures.add(future)
+
+    for f in futures:
+        r = f.result()
+        i = r[0]
+        B[i, :] = r[1]
+        RSS[i] = r[2]
+        if isOutX2is:
+            X2is[i, :, :] = r[3]
+            tRs[i] = r[4]
+
+    print('done t=' + str(time.time() - start) + ' sec')
+    return B, RSS, df, X2is, tRs

vneumodpy/glm/tukey_mth.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate General Linear Model with prewhitening (Tukey-Taper, Auto-correlation estimation Version)
+# based on M.W.Woolrich et al. (2001)
+#   Y = X * B + e
+#   e ~ N(0, s^2 * V)
+#   S * Y = S * X * B + r
+#   S = inv(K)
+#   V = K * K'
+#   V is auto-corerlation matrix estimated by Tukey-Taper
+#   r ~ N(0, s^2 * SVS') therefore N(0, s^2 * I)
+# This function is used for single session.
+# returns predictor variables (B), Residual Sum of Squares (RSS), degree of freedom (df),
+#   inv(X' * X) for contrast (X2is), trace(R) for contrast (tRs), full of Residuals (R)
+# input:
+#  Y         ROI or voxel time series (time series x node)
+#  X         design matrix (time series x predictor variables)
+#  tuM       Tukey-Taper window size (default: sqrt(time series length))
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+import time
+import os
+from scipy.linalg import toeplitz, cholesky, inv
+from scipy.stats import linregress
+from concurrent.futures import ThreadPoolExecutor
+
+
+def regress(y, X):
+    # Equivalent to MATLAB regress: returns b, residuals
+    b, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
+    r = y - X @ b
+    return b, r
+
+def loop_fn(i, Yi, X, tuWin, tuM, isOutX2is):
+    # 1st step OLS regression
+    _, r = regress(Yi, X)
+
+    # if residuals are all zero, probably original signal is just zero. ignore this voxel
+    if np.sum(r == 0) == r.shape[0]:
+        return i, 0, 0
+
+    # calc AR coefficients by Tukey-Taper of frequency domain
+    C = np.correlate(r, r, mode='full') / np.dot(r, r)
+    mid = len(C) // 2
+    Rxx = C[mid:mid + tuM]
+    Pxx = np.zeros(r.shape[0], dtype=np.float32)
+    Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+    V1 = toeplitz(Pxx)
+    K1 = np.linalg.cholesky(V1) # upper=False is not necessary (numpy v1)
+
+    # second time regression
+#    Ki1 = np.linalg.inv(K1)
+#    Ya = Ki1 @ Yi
+#    Xt = Ki1 @ X
+    Ya = np.linalg.solve(K1, Yi)
+    Xt = np.linalg.solve(K1, X)
+    b, r = regress(Ya, Xt)
+
+    rss = r.T @ r
+    if not isOutX2is:
+        return i, b, rss
+
+    # used for contrast
+    C = np.correlate(r, r, mode='full') / np.dot(r, r)
+    Rxx = C[mid:mid + tuM]
+    Pxx = np.zeros(r.shape[0], dtype=np.float32)
+    Pxx[:tuM] = Rxx[:tuM] * tuWin[:tuM]
+
+    V2 = toeplitz(Pxx)
+    x2is = inv(X.T @ (inv(V2) @ X))
+    IR = np.eye(Xt.shape[0]) - Xt @ inv(Xt.T @ Xt) @ Xt.T
+    trs = np.trace(IR)
+    return i, b, rss, x2is, trs
+
+def calc(Y, X, tuM=None, isOutX2is=False):
+    if tuM is None:
+        tuM = int(np.floor(np.sqrt(X.shape[0])))
+
+    print('process GLM with Tukey-Taper(' +str(tuM)+ ') estimation ...')
+    roiNum = Y.shape[1]
+    xsz = X.shape[1]
+    X2is = np.full((roiNum, xsz, xsz), np.nan, dtype=np.float32)
+    tRs = np.full((roiNum,1), np.nan, dtype=np.float32)
+    B = np.full((roiNum, xsz), np.nan, dtype=np.float32)
+    RSS = np.full((roiNum,1), np.nan, dtype=np.float32)
+    df = X.shape[0] - X.shape[1]
+
+    # make Tukey window
+    tuWin = np.zeros(tuM, dtype=np.float32)
+    for k in range(tuM):
+        tuWin[k] = 0.5 * (1 + np.cos(np.pi * (k+1) / tuM))
+
+    start = time.time()
+    with ThreadPoolExecutor(max_workers=os.cpu_count() // 2) as executor:  # -----(2)
+        futures = set()
+        for i in range(roiNum):
+            future = executor.submit(loop_fn, i, Y[:, i], X, tuWin, tuM, isOutX2is)
+            futures.add(future)
+
+    for f in futures:
+        r = f.result()
+        i = r[0]
+        B[i, :] = r[1]
+        RSS[i] = r[2]
+        if isOutX2is:
+            X2is[i, :, :] = r[3]
+            tRs[i] = r[4]
+
+    print('done t=' + str(time.time() - start) + ' sec')
+    return B, RSS, df, X2is, tRs

vneumodpy/measures/ac.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate auto-correlation (simple version)
+# returns matrix (node x lags)
+# input:
+#  X                multivariate time series matrix (node x time series)
+#  max_lag          time lags for Auto-Correlation function (default: 15)
+
+from __future__ import print_function, division
+
+import numpy as np
+import matplotlib.pyplot as plt
+import statsmodels.api as sm
+
+
+def calc(x, max_lag=15):
+    node_num = x.shape[0]
+    xr = np.zeros((node_num, max_lag+1), dtype=x.dtype)
+    for i in range(node_num):
+        xr[i, :] = sm.tsa.stattools.acf(x[i, :], nlags=max_lag)
+    return xr
+
+
+def plot(x, max_lag=15):
+    xr = calc(x=x, max_lag=max_lag)
+    plt.matshow(xr, vmin=-1, vmax=1)
+    plt.colorbar()
+    plt.xlabel('Source Nodes')
+    plt.ylabel('Target Nodes')
+    plt.show(block=False)
+    plt.pause(1)
+    return xr