vbi 0.1.3__cp310-cp310-manylinux2014_x86_64.whl → 0.2__cp310-cp310-manylinux2014_x86_64.whl

vbi/feature_extraction/features.json

@@ -359,6 +359,7 @@
         "verbose": false,
         "pca_num_components": 3,
         "quantiles": [0.05, 0.25, 0.5, 0.75, 0.95],
+        "k": null,
         "features": ["sum", "max", "min", "mean", "std", "skew", "kurtosis"]
       },
       "use": "yes",
@@ -459,7 +460,9 @@
         "moments": [2, 3, 4, 5, 6],
         "normalize": false,
         "verbose": false,
-        "indices": null
+        "indices": null,
+        "average": false
+
       },
       "use": "yes",
       "tag": "all"

vbi/feature_extraction/features.py

@@ -1128,6 +1128,7 @@ def fcd_stat(
     pca_num_components=3,
     quantiles=[0.05, 0.25, 0.5, 0.75, 0.95],
     features=["sum", "max", "min", "mean", "std", "skew", "kurtosis"],
+    k=None,
     verbose=False,
 ):
     
@@ -1142,8 +1143,7 @@ def fcd_stat(
 
     Values = []
     Labels = []
-
-    k = int(win_len / TR)
+    k = k if k is not None else int(win_len / TR)
     fcd = get_fcd(ts=ts, TR=TR, win_len=win_len, positive=positive, masks=masks)
     for key in fcd.keys():
         values, labels = matrix_stat(
@@ -1598,6 +1598,7 @@ def spectrum_moments(
     moments=[2, 3, 4, 5, 6],
     normalize=False,
     indices=None,
+    average=False,
     verbose=False,
 ):
     """
@@ -1660,8 +1661,13 @@ def spectrum_moments(
 
         for i in moments:
             _m = moment(psd, i, axis=1)
-            Values = np.append(Values, _m)
-            Labels = Labels + [f"spectrum_moment_{i}_{j}" for j in range(len(_m))]
+            if not average:
+                Values = np.append(Values, _m)
+                Labels = Labels + [f"spectrum_moment_{i}_{j}" for j in range(len(_m))]
+            else:
+                Values = np.append(Values, np.mean(_m))
+                Labels = Labels + [f"spectrum_moment_{i}"]
+
     return Values, Labels
 
 

vbi/inference.py

@@ -3,37 +3,67 @@ from vbi.utils import *
 from sbi.inference import SNPE, SNLE, SNRE
 from sbi.utils.user_input_checks import process_prior
 
+
 class Inference(object):
     def __init__(self) -> None:
         pass
 
     @timer
-    def train(self,
-              theta,
-              x,
-              prior,
-              num_threads=1,
-              method="SNPE",
-              device="cpu",
-              density_estimator="maf"
-              ):
+    def train(
+        self,
+        theta,
+        x,
+        prior,
+        num_threads=1,
+        method="SNPE",
+        device="cpu",
+        density_estimator="maf",
+    ):
+        '''
+        train the inference model
+        
+        Parameters
+        ----------
+        theta: torch.tensor float32 (n, d)
+            parameter samples, where n is the number of samples and d is the dimension of the parameter space
+        x: torch.tensor float32 (n, d)
+            feature samples, where n is the number of samples and d is the dimension of the feature space
+        prior: sbi.utils object 
+            prior distribution object
+        num_threads: int
+            number of threads to use for training, for multi-threading support, default is 1
+        method: str
+            inference method to use, one of "SNPE", "SNLE", "SNRE", default is "SNPE"
+        device: str
+            device to use for training, one of "cpu", "cuda", default is "cpu"
+        density_estimator: str
+            density estimator to use, one of "maf", "nsf", default is "maf"
+        Returns
+        -------
+        posterior: sbi.utils object
+            posterior distribution object trained on the given data
+            
+        '''
 
         torch.set_num_threads(num_threads)
 
-        if (len(x.shape) == 1):
+        if len(x.shape) == 1:
             x = x[:, None]
-        if (len(theta.shape) == 1):
+        if len(theta.shape) == 1:
             theta = theta[:, None]
 
         if method == "SNPE":
             inference = SNPE(
-                prior=prior, density_estimator=density_estimator, device=device)
+                prior=prior, density_estimator=density_estimator, device=device
+            )
         elif method == "SNLE":
             inference = SNLE(
-                prior=prior, density_estimator=density_estimator, device=device)
+                prior=prior, density_estimator=density_estimator, device=device
+            )
         elif method == "SNRE":
             inference = SNRE(
-                prior=prior, density_estimator=density_estimator, device=device)
+                prior=prior, density_estimator=density_estimator, device=device
+            )
         else:
             raise ValueError("Invalid method: " + method)
 
@@ -45,7 +75,7 @@ class Inference(object):
 
     @staticmethod
     def sample_prior(prior, n, seed=None):
-        '''
+        """
         sample from prior distribution
 
         Parameters
@@ -58,19 +88,17 @@ class Inference(object):
         Returns
         -------
 
-        '''
+        """
         if seed is not None:
             torch.manual_seed(seed)
-            
+
         prior, _, _ = process_prior(prior)
         theta = prior.sample((n,))
         return theta
 
     @staticmethod
-    def sample_posterior(xo,
-                         num_samples,
-                         posterior):
-        '''
+    def sample_posterior(xo, num_samples, posterior):
+        """
         sample from the posterior using the given observation point.
 
         Parameters
@@ -87,7 +115,7 @@ class Inference(object):
         samples: torch.tensor float32 (num_samples, d)
             samples from the posterior
 
-        '''
+        """
 
         if not isinstance(xo, torch.Tensor):
             xo = torch.tensor(xo, dtype=torch.float32)

vbi/models/cpp/_src/jr_sde.hpp

@@ -30,7 +30,7 @@ private:
     size_t index_transition;
     vector<vector<unsigned>> adjlist;
 
-    double par_A;
+    dim1 A;
     double par_a;
     double par_B;
     double par_b;
@@ -64,7 +64,7 @@ public:
         double coupling,
         dim2 adj,
         dim1 y,
-        double A,
+        dim1 A,
         double B,
         double a,
         double b,
@@ -81,7 +81,7 @@ public:
     {
         assert(t_final > t_transition);
 
-        par_A = A;
+        this->A = A;
         par_B = B;
         par_a = a;
         par_b = b;
@@ -131,7 +131,6 @@ public:
 
         double a2 = par_a * par_a;
         double b2 = par_b * par_b;
-        double Aa = par_A * par_a;
         double Bb = par_B * par_b;
 
         size_t N2 = 2 * N;
@@ -152,8 +151,8 @@ public:
             dxdt[i] = y[i + N3];
             dxdt[i + N] = y[i + N4];
             dxdt[i + N2] = y[i + N5];
-            dxdt[i + N3] = par_A * par_a * sigma(y[i + N] - y[i + N2]) - 2 * par_a * y[i + N3] - a2 * y[i];
-            dxdt[i + N4] = Aa * (noise_mu + C1[i] * sigma(C0[i] * y[i]) + coupling * coupling_term) - 2 * par_a * y[i + N4] - a2 * y[i + N];
+            dxdt[i + N3] = A[i] * par_a * sigma(y[i + N] - y[i + N2]) - 2 * par_a * y[i + N3] - a2 * y[i];
+            dxdt[i + N4] = A[i] * par_a * (noise_mu + C1[i] * sigma(C0[i] * y[i]) + coupling * coupling_term) - 2 * par_a * y[i + N4] - a2 * y[i + N];
             dxdt[i + N5] = Bb * C3[i] * sigma(C2[i] * y[i]) - 2 * par_b * y[i + N5] -
                            b2 * y[i + N2];
         }

vbi/models/cpp/_src/jr_sde_wrap.cxx

@@ -11803,7 +11803,7 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_0(PyObject *self, Py_ssize_t nobjs,
   double arg5 ;
   dim2 arg6 ;
   dim1 arg7 ;
-  double arg8 ;
+  dim1 arg8 ;
   double arg9 ;
   double arg10 ;
   double arg11 ;
@@ -11827,8 +11827,6 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_0(PyObject *self, Py_ssize_t nobjs,
   int ecode4 = 0 ;
   double val5 ;
   int ecode5 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
   double val9 ;
   int ecode9 = 0 ;
   double val10 ;
@@ -11894,11 +11892,15 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_0(PyObject *self, Py_ssize_t nobjs,
     arg7 = *ptr;
     if (SWIG_IsNewObj(res)) delete ptr;
   }
-  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
-  if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_JR_sde" "', argument " "8"" of type '" "double""'");
-  } 
-  arg8 = static_cast< double >(val8);
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[7], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_JR_sde" "', argument " "8"" of type '" "dim1""'"); 
+    }
+    arg8 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
   ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
   if (!SWIG_IsOK(ecode9)) {
     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_JR_sde" "', argument " "9"" of type '" "double""'");
@@ -11980,7 +11982,7 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_0(PyObject *self, Py_ssize_t nobjs,
     SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "new_JR_sde" "', argument " "21"" of type '" "int""'");
   } 
   arg21 = static_cast< int >(val21);
-  result = (JR_sde *)new JR_sde(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9,arg10,arg11,arg12,arg13,arg14,SWIG_STD_MOVE(arg15),SWIG_STD_MOVE(arg16),SWIG_STD_MOVE(arg17),SWIG_STD_MOVE(arg18),arg19,arg20,arg21);
+  result = (JR_sde *)new JR_sde(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,arg10,arg11,arg12,arg13,arg14,SWIG_STD_MOVE(arg15),SWIG_STD_MOVE(arg16),SWIG_STD_MOVE(arg17),SWIG_STD_MOVE(arg18),arg19,arg20,arg21);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_JR_sde, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
@@ -11997,7 +11999,7 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_1(PyObject *self, Py_ssize_t nobjs,
   double arg5 ;
   dim2 arg6 ;
   dim1 arg7 ;
-  double arg8 ;
+  dim1 arg8 ;
   double arg9 ;
   double arg10 ;
   double arg11 ;
@@ -12020,8 +12022,6 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_1(PyObject *self, Py_ssize_t nobjs,
   int ecode4 = 0 ;
   double val5 ;
   int ecode5 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
   double val9 ;
   int ecode9 = 0 ;
   double val10 ;
@@ -12085,11 +12085,15 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_1(PyObject *self, Py_ssize_t nobjs,
     arg7 = *ptr;
     if (SWIG_IsNewObj(res)) delete ptr;
   }
-  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
-  if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_JR_sde" "', argument " "8"" of type '" "double""'");
-  } 
-  arg8 = static_cast< double >(val8);
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[7], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_JR_sde" "', argument " "8"" of type '" "dim1""'"); 
+    }
+    arg8 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
   ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
   if (!SWIG_IsOK(ecode9)) {
     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_JR_sde" "', argument " "9"" of type '" "double""'");
@@ -12166,7 +12170,7 @@ SWIGINTERN PyObject *_wrap_new_JR_sde__SWIG_1(PyObject *self, Py_ssize_t nobjs,
     SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_JR_sde" "', argument " "20"" of type '" "double""'");
   } 
   arg20 = static_cast< double >(val20);
-  result = (JR_sde *)new JR_sde(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9,arg10,arg11,arg12,arg13,arg14,SWIG_STD_MOVE(arg15),SWIG_STD_MOVE(arg16),SWIG_STD_MOVE(arg17),SWIG_STD_MOVE(arg18),arg19,arg20);
+  result = (JR_sde *)new JR_sde(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,arg10,arg11,arg12,arg13,arg14,SWIG_STD_MOVE(arg15),SWIG_STD_MOVE(arg16),SWIG_STD_MOVE(arg17),SWIG_STD_MOVE(arg18),arg19,arg20);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_JR_sde, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
@@ -12215,10 +12219,8 @@ SWIGINTERN PyObject *_wrap_new_JR_sde(PyObject *self, PyObject *args) {
                 int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
                 _v = SWIG_CheckState(res);
                 if (_v) {
-                  {
-                    int res = SWIG_AsVal_double(argv[7], NULL);
-                    _v = SWIG_CheckState(res);
-                  }
+                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
+                  _v = SWIG_CheckState(res);
                   if (_v) {
                     {
                       int res = SWIG_AsVal_double(argv[8], NULL);
@@ -12327,10 +12329,8 @@ SWIGINTERN PyObject *_wrap_new_JR_sde(PyObject *self, PyObject *args) {
                 int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
                 _v = SWIG_CheckState(res);
                 if (_v) {
-                  {
-                    int res = SWIG_AsVal_double(argv[7], NULL);
-                    _v = SWIG_CheckState(res);
-                  }
+                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
+                  _v = SWIG_CheckState(res);
                   if (_v) {
                     {
                       int res = SWIG_AsVal_double(argv[8], NULL);
@@ -12416,8 +12416,8 @@ SWIGINTERN PyObject *_wrap_new_JR_sde(PyObject *self, PyObject *args) {
 fail:
   SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JR_sde'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    JR_sde::JR_sde(size_t,double,double,double,double,dim2,dim1,double,double,double,double,double,double,double,dim1,dim1,dim1,dim1,double,double,int)\n"
-    "    JR_sde::JR_sde(size_t,double,double,double,double,dim2,dim1,double,double,double,double,double,double,double,dim1,dim1,dim1,dim1,double,double)\n");
+    "    JR_sde::JR_sde(size_t,double,double,double,double,dim2,dim1,dim1,double,double,double,double,double,double,dim1,dim1,dim1,dim1,double,double,int)\n"
+    "    JR_sde::JR_sde(size_t,double,double,double,double,dim2,dim1,dim1,double,double,double,double,double,double,dim1,dim1,dim1,dim1,double,double)\n");
   return 0;
 }
 

vbi/models/cpp/jansen_rit.py

@@ -124,7 +124,7 @@ class JR_sde:
             "method": "heun",
             "t_transition": 500.0,      # ms
             "t_end": 2501.0,            # ms
-            "output": "output",      # output directory
+            "output": "output",         # output directory
             "RECORD_AVG": False         # true to store large time series in file
         }
         return par
@@ -181,17 +181,13 @@ class JR_sde:
         self.t_transition = float(self.t_transition)
         self.t_end = float(self.t_end)
         self.G = float(self.G)
-        self.A = float(self.A)
         self.B = float(self.B)
         self.a = float(self.a)
         self.b = float(self.b)
         self.r = float(self.r)
         self.v0 = float(self.v0)
         self.vmax = float(self.vmax)
-        # self.C0 = np.asarray(self.C0)
-        # self.C1 = np.asarray(self.C1)
-        # self.C2 = np.asarray(self.C2)
-        # self.C3 = np.asarray(self.C3)
+        self.A = check_sequence(self.A, self.N)
         self.C0 = check_sequence(self.C0, self.N)
         self.C1 = check_sequence(self.C1, self.N)
         self.C2 = check_sequence(self.C2, self.N)
@@ -236,9 +232,6 @@ class JR_sde:
         for key in par.keys():
             if key not in self.valid_params:
                 raise ValueError("Invalid parameter: " + key)
-            # if key in ["C0", "C1", "C2", "C3"]:
-            #     self.set_C(key, par[key])
-            # else:
             setattr(self, key, par[key])
 
         self.prepare_input()

vbi/models/cupy/bold.py

@@ -105,6 +105,123 @@ class BoldStephan2008:
         q[0] = q[1]
 
 
+class Bold:
+
+    def __init__(self, par: dict = {}) -> None:
+
+        self._par = self.get_default_parameters()
+        self.valid_parameters = list(self._par.keys())
+        self.check_parameters(par)
+        self._par.update(par)
+
+        for item in self._par.items():
+            setattr(self, item[0], item[1])
+        self.update_dependent_parameters()
+            
+
+    def get_default_parameters(self):
+        """get balloon model parameters."""
+
+        vo = 0.08
+        theta = 40.3
+        TE = 0.04
+        Eo = 0.4
+        r0 = 25.0
+        epsilon = 0.34
+        k1 = 4.3 * theta * Eo * TE
+        k2 = epsilon * r0 * Eo * TE
+        k3 = 1 - epsilon
+
+        par = {
+            "kappa": 0.65,
+            "gamma": 0.41,
+            "tau": 0.98,
+            "alpha": 0.32,
+            "epsilon": epsilon,
+            "Eo": Eo,
+            "TE": TE,
+            "vo": vo,
+            "r0": r0,
+            "theta": theta,
+            "t_min": 0.0,
+            "rtol": 1e-5,
+            "atol": 1e-8,
+            "k1": k1,
+            "k2": k2,
+            "k3": k3
+        }
+        return par
+    
+    def update_dependent_parameters(self):
+        self.k1 = 4.3 * self.theta * self.Eo * self.TE
+        self.k2 = self.epsilon * self.r0 * self.Eo * self.TE
+        self.k3 = 1 - self.epsilon
+
+    def check_parameters(self, par):
+        for key in par.keys():
+            if key not in self.valid_parameters:
+                raise ValueError(f"Invalid parameter {key:s} provided.")
+            
+    def allocate_memory(self, xp, nn, ns, n_steps, bold_decimate, dtype):
+    
+        self.s = xp.zeros((2, nn, ns), dtype=dtype)
+        self.f = xp.zeros((2, nn, ns), dtype=dtype)
+        self.ftilde = xp.zeros((2, nn, ns), dtype=dtype)
+        self.vtilde = xp.zeros((2, nn, ns), dtype=dtype)
+        self.qtilde = xp.zeros((2, nn, ns), dtype=dtype)
+        self.v = xp.zeros((2, nn, ns), dtype=dtype)
+        self.q = xp.zeros((2, nn, ns), dtype=dtype)
+        self.vv = np.zeros((n_steps // bold_decimate, nn, ns), dtype="f")
+        self.qq = np.zeros((n_steps // bold_decimate, nn, ns), dtype="f")
+        self.s[0] = 1
+        self.f[0] = 1
+        self.v[0] = 1
+        self.q[0] = 1
+        self.ftilde[0] = 0
+        self.vtilde[0] = 0
+        self.qtilde[0] = 0
+
+    def do_bold_step(self, r_in, dtt):
+
+        Eo = self.Eo
+        tau = self.tau
+        kappa = self.kappa
+        gamma = self.gamma
+        alpha = self.alpha
+        ialpha = 1 / alpha
+        
+        v = self.v
+        q = self.q
+        s = self.s
+        f = self.f 
+        ftilde = self.ftilde
+        vtilde = self.vtilde
+        qtilde = self.qtilde
+
+        s[1] = s[0] + dtt * (r_in - kappa * s[0] - gamma * (f[0] - 1))
+        f[0] = np.clip(f[0], 1, None)
+        ftilde[1] = ftilde[0] + dtt * (s[0] / f[0])
+        fv = v[0] ** ialpha  # outflow
+        vtilde[1] = vtilde[0] + dtt * ((f[0] - fv) / (tau * v[0]))
+        q[0] = np.clip(q[0], 0.01, None)
+        ff = (1 - (1 - Eo) ** (1 / f[0])) / Eo  # oxygen extraction
+        qtilde[1] = qtilde[0] + dtt * ((f[0] * ff - fv * q[0] / v[0]) / (tau * q[0]))
+
+        f[1] = np.exp(ftilde[1])
+        v[1] = np.exp(vtilde[1])
+        q[1] = np.exp(qtilde[1])
+
+        f[0] = f[1]
+        s[0] = s[1]
+        ftilde[0] = ftilde[1]
+        vtilde[0] = vtilde[1]
+        qtilde[0] = qtilde[1]
+        v[0] = v[1]
+        q[0] = q[1]
+
+
+
+
 class BoldTVB:
 
     def __init__(self):

vbi/models/cupy/jansen_rit.py

@@ -199,7 +199,7 @@ class JR_sde:
 
         self.G = self.xp.array(self.G)
         assert self.weights is not None, "weights must be provided"
-        self.weights = self.xp.array(self.weights).T  # ! check this
+        self.weights = self.xp.array(self.weights) 
         self.weights = move_data(self.weights, self.engine)
         self.nn = self.num_nodes = self.weights.shape[0]