pcntoolkit 0.32.0__py3-none-any.whl

pcntoolkit/regression_model/blr/warp.py

@@ -0,0 +1 @@
+ 

pcntoolkit/trendsurf.py

@@ -0,0 +1,315 @@
+#!/opt/conda/bin/python
+
+# ------------------------------------------------------------------------------
+#  Usage:
+#  python trendsurf.py -m [maskfile] -b [basis] -c [covariates] <infile>
+#
+#  Written by A. Marquand
+# ------------------------------------------------------------------------------
+
+from __future__ import division, print_function
+
+import argparse
+import os
+import sys
+
+import nibabel as nib
+import numpy as np
+
+try:  # Run as a package if installed
+    from pcntoolkit.dataio import fileio
+    from pcntoolkit.model.bayesreg import BLR
+except ImportError:
+    pass
+    path = os.path.abspath(os.path.dirname(__file__))
+    if path not in sys.path:
+        sys.path.append(path)
+    del path
+
+    from dataio import fileio
+    from model.bayesreg import BLR
+
+
+def load_data(datafile, maskfile=None):
+    """
+    Load data from disk
+
+    This will load data from disk, either in nifti or ascii format. If the
+    data are in ascii format, they should be in tab or space delimited format
+    with the number of voxels in rows and the number of subjects in columns.
+    Neuroimaging data will be reshaped into the appropriate format
+
+    :param datafile: 4-d nifti file containing the images to be estimated
+    :param maskfile: nifti mask used to apply to the data
+    :returns: * dat - data in vectorised form
+              * world - voxel coordinates
+              * mask - mask used to apply to the data
+    """
+    if datafile.endswith("nii.gz") or datafile.endswith("nii"):
+        # we load the data this way rather than fileio.load() because we need
+        # access to the volumetric representation (to know the # coordinates)
+        dat = fileio.load_nifti(datafile, vol=True)
+        dim = dat.shape
+        if len(dim) <= 3:
+            dim = dim + (1,)
+    else:
+        raise ValueError("No routine to handle non-nifti data")
+
+    mask = fileio.create_mask(dat, mask=maskfile)
+
+    dat = fileio.vol2vec(dat, mask)
+    maskid = np.where(mask.ravel())[0]
+
+    # generate voxel coordinates
+    i, j, k = np.meshgrid(np.linspace(0, dim[0]-1, dim[0]),
+                          np.linspace(0, dim[1]-1, dim[1]),
+                          np.linspace(0, dim[2]-1, dim[2]), indexing='ij')
+
+    # voxel-to-world mapping
+    img = nib.load(datafile)
+    world = np.vstack((i.ravel(), j.ravel(), k.ravel(),
+                       np.ones(np.prod(i.shape), float))).T
+    world = np.dot(world, img.affine.T)[maskid, 0:3]
+
+    return dat, world, mask
+
+
+def create_basis(X, basis, mask):
+    """
+    Create a basis set
+
+    This will create a basis set for the trend surface model. This is
+    currently fit using a polynomial model of a specified degree. The models
+    are estimated on the basis of data stored on disk in ascii or
+    neuroimaging data formats (currently nifti only). Ascii data should be in
+    tab or space delimited format with the number of voxels in rows and the
+    number of subjects in columns. Neuroimaging data will be reshaped
+    into the appropriate format
+
+    :param X: covariates
+    :param basis: model order for the interpolating polynomial
+    :param mask: mask used to apply to the data
+    :returns: * Phi - basis set
+    """
+
+    # check whether we are using a polynomial basis set
+    if type(basis) is int or (type(basis) is str and len(basis) == 1):
+        dimpoly = int(basis)
+        dimx = X.shape[1]
+        print('Generating polynomial basis set of degree', dimpoly, '...')
+        Phi = np.zeros((X.shape[0], X.shape[1]*dimpoly))
+        colid = np.arange(0, dimx)
+        for d in range(1, dimpoly+1):
+            Phi[:, colid] = X ** d
+            colid += dimx
+    else:  # custom basis set
+        if type(basis) is str:
+            print('Loading custom basis set from', basis)
+
+            # Phi_vol = fileio.load_data(basis)
+            # we load the data this way instead so we can apply the same mask
+            Phi_vol = fileio.load_nifti(basis, vol=True)
+            Phi = fileio.vol2vec(Phi_vol, mask)
+            print('Basis set consists of', Phi.shape[1], 'basis functions.')
+            # maskid = np.where(mask.ravel())[0]
+        else:
+            raise ValueError("I don't know what to do with basis:", basis)
+
+    return Phi
+
+
+def write_nii(data, filename, examplenii, mask):
+    """
+    Write data to nifti file
+
+    This will write data to a nifti file, using the header information from
+    an example nifti file.
+
+    :param data: data to be written
+    :param filename: name of file to be written
+    :param examplenii: example nifti file
+    :param mask: mask used to apply to the data
+    :returns: * Phi - basis set
+    """
+    # load example image
+    ex_img = nib.load(examplenii)
+    dim = ex_img.shape[0:3]
+    nvol = int(data.shape[1])
+
+    # write data
+    array_data = np.zeros((np.prod(dim), nvol))
+    array_data[mask.flatten(), :] = data
+    array_data = np.reshape(array_data, dim+(nvol,))
+    array_img = nib.Nifti1Image(array_data,
+                                ex_img.get_affine(),
+                                ex_img.get_header())
+    nib.save(array_img, filename)
+
+
+def get_args(*args):
+    """
+    Parse command line arguments
+
+    This will parse the command line arguments for the trend surface model.
+    The arguments are:
+
+    :param filename: 4-d nifti file containing the images to be estimated
+    :param maskfile: nifti mask used to apply to the data
+    :param basis: model order for the interpolating polynomial
+    :param covfile: file containing covariates
+    :param ard: use ARD
+    :param outputall: output all measures
+    :returns: * filename - 4-d nifti file containing the images to be estimated
+              * maskfile - nifti mask used to apply to the data
+              * basis - model order for the interpolating polynomial
+              * covfile - file containing covariates
+              * ard - use ARD
+              * outputall - output all measures
+    """
+    parser = argparse.ArgumentParser(description="Trend surface model")
+    parser.add_argument("filename")
+    parser.add_argument("-b", help="basis set", dest="basis", default=3)
+    parser.add_argument("-m", help="mask file", dest="maskfile", default=None)
+    parser.add_argument("-c", help="covariates file", dest="covfile",
+                        default=None)
+    parser.add_argument("-a", help="use ARD", action='store_true')
+    parser.add_argument("-o", help="output all measures", action='store_true')
+    args = parser.parse_args()
+    wdir = os.path.realpath(os.path.curdir)
+    filename = os.path.join(wdir, args.filename)
+    if args.maskfile is None:
+        maskfile = None
+    else:
+        maskfile = os.path.join(wdir, args.maskfile)
+    basis = args.basis
+    if args.covfile is not None:
+        raise NotImplementedError("Covariates not implemented yet.")
+
+    return filename, maskfile, basis, args.a, args.o
+
+
+def estimate(filename, maskfile, basis, ard=False, outputall=False,
+             saveoutput=True, **kwargs):
+    """ Estimate a trend surface model
+
+    This will estimate a trend surface model, independently for each subject.
+    This is currently fit using a polynomial model of a specified degree.
+    The models are estimated on the basis of data stored on disk in ascii or
+    neuroimaging data formats (currently nifti only). Ascii data should be in
+    tab or space delimited format with the number of voxels in rows and the
+    number of subjects in columns. Neuroimaging data will be reshaped
+    into the appropriate format
+
+    Basic usage::
+
+        estimate(filename, maskfile, basis)
+
+    where the variables are defined below. Note that either the cfolds
+    parameter or (testcov, testresp) should be specified, but not both.
+
+    :param filename: 4-d nifti file containing the images to be estimated
+    :param maskfile: nifti mask used to apply to the data
+    :param basis: model order for the interpolating polynomial
+
+    All outputs are written to disk in the same format as the input. These are:
+
+    :outputs: * yhat - predictive mean
+              * ys2 - predictive variance
+              * trendcoeff - coefficients from the trend surface model
+              * negloglik - Negative log marginal likelihood
+              * hyp - hyperparameters
+              * explainedvar - explained variance
+              * rmse - standardised mean squared error
+    """
+
+    # parse arguments
+    optim = kwargs.get('optimizer', 'powell')
+
+    # load data
+    print("Processing data in", filename)
+    Y, X, mask = load_data(filename, maskfile)
+    Y = np.round(10000*Y)/10000  # truncate precision to avoid numerical probs
+    if len(Y.shape) == 1:
+        Y = Y[:, np.newaxis]
+    N = Y.shape[1]
+
+    # standardize responses and covariates
+    mY = np.mean(Y, axis=0)
+    sY = np.std(Y, axis=0)
+    Yz = (Y - mY) / sY
+    mX = np.mean(X, axis=0)
+    sX = np.std(X, axis=0)
+    Xz = (X - mX) / sX
+
+    # create basis set and set starting hyperparamters
+    Phi = create_basis(Xz, basis, mask)
+    if ard is True:
+        hyp0 = np.zeros(Phi.shape[1]+1)
+    else:
+        hyp0 = np.zeros(2)
+
+    # estimate the models for all subjects
+    if ard:
+        print('ARD is enabled')
+    yhat = np.zeros_like(Yz)
+    ys2 = np.zeros_like(Yz)
+    nlZ = np.zeros(N)
+    hyp = np.zeros((N, len(hyp0)))
+    rmse = np.zeros(N)
+    ev = np.zeros(N)
+    m = np.zeros((N, Phi.shape[1]))
+    bs2 = np.zeros((N, Phi.shape[1]))
+    for i in range(0, N):
+        print("Estimating model ", i+1, "of", N)
+        breg = BLR()
+        hyp[i, :] = breg.estimate(hyp0, Phi, Yz[:, i], optimizer=optim)
+        m[i, :] = breg.m
+        nlZ[i] = breg.nlZ
+
+        # compute extra measures (e.g. marginal variances)?
+        if outputall:
+            bs2[i] = np.sqrt(np.diag(np.linalg.inv(breg.A)))
+
+        # compute predictions and errors
+        yhat[:, i], ys2[:, i] = breg.predict(hyp[i, :], Phi, Yz[:, i], Phi)
+        yhat[:, i] = yhat[:, i]*sY[i] + mY[i]
+        rmse[i] = np.sqrt(np.mean((Y[:, i] - yhat[:, i]) ** 2))
+        ev[i] = 100*(1 - (np.var(Y[:, i] - yhat[:, i]) / np.var(Y[:, i])))
+
+        print("Variance explained =", ev[i], "% RMSE =", rmse[i])
+
+    print("Mean (std) variance explained =", ev.mean(), "(", ev.std(), ")")
+    print("Mean (std) RMSE =", rmse.mean(), "(", rmse.std(), ")")
+
+    # Write output
+    if saveoutput:
+        print("Writing output ...")
+        np.savetxt("trendcoeff.txt", m, delimiter='\t', fmt='%5.8f')
+        np.savetxt("negloglik.txt", nlZ, delimiter='\t', fmt='%5.8f')
+        np.savetxt("hyp.txt", hyp, delimiter='\t', fmt='%5.8f')
+        np.savetxt("explainedvar.txt", ev, delimiter='\t', fmt='%5.8f')
+        np.savetxt("rmse.txt", rmse, delimiter='\t', fmt='%5.8f')
+        fileio.save_nifti(yhat, 'yhat.nii.gz', filename, mask)
+        fileio.save_nifti(ys2, 'ys2.nii.gz', filename, mask)
+
+        if outputall:
+            np.savetxt("trendcoeffvar.txt", bs2, delimiter='\t', fmt='%5.8f')
+    else:
+        out = [yhat, ys2, nlZ, hyp, rmse, ev, m]
+        if outputall:
+            out.append(bs2)
+        return out
+
+def entrypoint(*args):
+    main(*args)
+
+def main(*args):
+    np.seterr(invalid='ignore')
+
+    filename, maskfile, basis, ard, outputall = get_args(args)
+    estimate(filename, maskfile, basis, ard, outputall)
+
+
+# For running from the command line:
+if __name__ == "__main__":
+    main(sys.argv[1:])

pcntoolkit/util/__init__.py

@@ -0,0 +1 @@
+from . import utils

pcntoolkit/util/bspline.py

@@ -0,0 +1,149 @@
+import numpy as np
+from scipy.interpolate import BSpline
+
+
+class BSplineBasis:
+    def __init__(
+        self, order, nknots, knot_method="uniform", left_expand=0.05, right_expand=0.05
+    ):
+        """
+        Initialize the BSplineBasis object.
+        :param order: Degree of the B-spline
+        :param nknots: Number of interior knots. Mind that this is the number of interior
+        knots. The final number of knots will be nknotes+2 as two knots will be added at boundries.
+        :param knot_method: 'uniform' or 'percentile' for knot placement
+        :param left_expand: Fraction to expand the range on the left (default 0)
+        :param right_expand: Fraction to expand the range on the right (default 0)
+        """
+        if nknots + 2 < order + 1:
+            raise ValueError("Number of knots+2 must be at least degree + 1.")
+        if knot_method not in ["uniform", "percentile"]:
+            raise ValueError("knot_method must be 'uniform' or 'percentile'.")
+        if not (0 <= left_expand <= 1 and 0 <= right_expand <= 1):
+            raise ValueError("left_expand and right_expand must be between 0 and 1.")
+
+        self.degree = order
+        self.nknots = nknots
+        self.knot_method = knot_method
+        self.left_expand = left_expand
+        self.right_expand = right_expand
+        self.knots = None
+        self.feature_min = None
+        self.feature_max = None
+
+    def fit(self, X, feature_min=None, feature_max=None):
+        """
+        Fit B-spline basis functions to the dataset.
+        :param X: [N×P] array of covariates
+        :param feature_min: Minimum values for features (optional)
+        :param feature_max: Maximum values for features (optional)
+        """
+        if not isinstance(X, np.ndarray):
+            raise ValueError("Input X must be a NumPy array.")
+        if X.ndim != 2:
+            raise ValueError("Input X must be a 2D array.")
+
+        self.feature_min = (
+            np.min(X, axis=0) if feature_min is None else np.array(feature_min)
+        )
+        self.feature_max = (
+            np.max(X, axis=0) if feature_max is None else np.array(feature_max)
+        )
+
+        feature_num = X.shape[1]
+        self.knots = []
+
+        for i in range(feature_num):
+            # Determine range of bspline basis
+            minx = self.feature_min[i]
+            maxx = self.feature_max[i]
+            delta = maxx - minx
+            t_min = minx - self.left_expand * delta
+            t_max = maxx + self.right_expand * delta
+
+            # Determine knot locations
+            if self.knot_method == "uniform":
+                interior_knots = np.linspace(t_min, t_max, self.nknots)
+            elif self.knot_method == "percentile":
+                interior_knots = np.percentile(
+                    X[:, i], np.linspace(0, 100, self.nknots)
+                )
+
+            # Add boundary knots
+            t = np.concatenate(
+                ([t_min] * self.degree, interior_knots, [t_max] * self.degree)
+            )
+
+            self.knots.append(t)
+
+    def transform(self, X):
+        """
+        Transform the dataset using the fitted B-spline basis functions.
+        :param X: [N×P] array of clinical covariates
+        :return: [N×(P×n_basis)] array of transformed data
+        """
+        if self.knots is None:
+            raise ValueError(
+                "B-spline basis functions have not been fitted. Call 'fit' first."
+            )
+        if not isinstance(X, np.ndarray):
+            raise ValueError("Input X must be a NumPy array.")
+        if X.ndim != 2:
+            raise ValueError("Input X must be a 2D array.")
+        if len(self.knots) != X.shape[1]:
+            raise ValueError(
+                "Number of B-spline basis functions must match the number of features in X."
+            )
+
+        transformed_features = []
+        for f in range(len(self.knots)):
+            phi = BSpline.design_matrix(
+                x=X[:, f], t=self.knots[f], k=self.degree, extrapolate=True
+            ).toarray()
+            transformed_features.append(phi)
+        return np.concatenate(transformed_features, axis=1)
+
+    def adapt(self, target_X):
+        """
+        Adapt the fitted B-spline basis functions to a target dataset.
+        :param target_X: [N×P] array of target clinical covariates
+        """
+        if self.knots is None:
+            raise ValueError(
+                "B-spline basis functions have not been fitted. Call 'fit' first."
+            )
+        if not isinstance(target_X, np.ndarray):
+            raise ValueError("Input target_X must be a NumPy array.")
+        if target_X.ndim != 2:
+            raise ValueError("Input target_X must be a 2D array.")
+        if len(self.knots) != target_X.shape[1]:
+            raise ValueError(
+                "Number of B-spline basis functions must match the number of features in target_X."
+            )
+
+        # Updating feature_min and feature_max using combined datsets
+        combined_min = np.minimum(self.feature_min, np.min(target_X, axis=0))
+        combined_max = np.maximum(self.feature_max, np.max(target_X, axis=0))
+        self.feature_min = combined_min
+        self.feature_max = combined_max
+
+        feature_num = target_X.shape[1]
+
+        new_knots = []
+
+        for i in range(feature_num):
+            minx = self.feature_min[i]
+            maxx = self.feature_max[i]
+            delta = maxx - minx
+            t_min = minx - self.left_expand * delta
+            t_max = maxx + self.right_expand * delta
+
+            # Adapt knots
+            source_knots = self.knots[i]
+            target_knots = t_min + (source_knots - source_knots[0]) * (
+                t_max - t_min
+            ) / (source_knots[-1] - source_knots[0])
+
+            new_knots.append(target_knots)
+
+        self.knots = new_knots