def load_nii(nifiti, clean=True, sparse=False, smooth=False, **kwargs):
"""Convert the nifiti-1 file into a 2D array (n_sample x n_features).
Parameters
----------
nifti - str
The name of the data to load
clean - boolean (True)
Remove invariant features features? If used n_features will
not match n_voxels in the orignal nifit1 file. This operation
is not reversable. If you clean there is probablity little
point in converting to a sparse representation.
sparse - boolean (False)
Use the (CSC) sparse format (True)?
smooth - boolean (False)
High/low pass filter the data?
[, ...] - Optional parameters for smooth
(defaults: tr=1.5, ub=0.06, lb=0.006)
Return
------
X - 2D array (n_sample x n_features)
The BOLD data
"""
# Data is 4d (x,y,z,t) we want 2d, where each column is
# a voxel and each row is the temporal (t) data
# i.e. the final shape should be (x*y*x, t)
nii = nb.nifti1.load(nifiti)
numt = nii.shape[3]
numxyz = nii.shape[0] * nii.shape[1] * nii.shape[2]
dims = (numxyz, numt)
# Get into 2d (n_feature, n_sample)
X = nii.get_data().astype('int16').reshape(dims).transpose()
if clean:
X = remove_invariant_features(X, sparse=False)
if smooth:
# Setup smooth params
tr = 1.5
ub = 0.06
lb = 0.001
if "tr" in kwargs:
tr = kwargs["tr"]
if "ub" in kwargs:
ub = kwargs["ub"]
if "lb" in kwargs:
ub = kwargs["lb"]
X = smoothfn(X, tr=tr, ub=ub, lb=lb)
assert checkX(X)
if sparse:
X = csc_matrix(X)
return X
def load_nii(nifiti, clean=True, sparse=False, smooth=False, **kwargs):
"""Convert the nifiti-1 file into a 2D array (n_sample x n_features).
Parameters
----------
nifti - str
The name of the data to load
clean - boolean (True)
Remove invariant features features? If used n_features will
not match n_voxels in the orignal nifit1 file. This operation
is not reversable. If you clean there is probablity little
point in converting to a sparse representation.
sparse - boolean (False)
Use the (CSC) sparse format (True)?
smooth - boolean (False)
High/low pass filter the data?
[, ...] - Optional parameters for smooth
(defaults: tr=1.5, ub=0.06, lb=0.006)
Return
------
X - 2D array (n_sample x n_features)
The BOLD data
"""
# Data is 4d (x,y,z,t) we want 2d, where each column is
# a voxel and each row is the temporal (t) data
# i.e. the final shape should be (x*y*x, t)
nii = nb.nifti1.load(nifiti)
numt = nii.shape[3]
numxyz = nii.shape[0] * nii.shape[1] * nii.shape[2]
dims = (numxyz, numt)
# Get into 2d (n_feature, n_sample)
X = nii.get_data().astype('int16').reshape(dims).transpose()
if clean:
X = remove_invariant_features(X, sparse=False)
if smooth:
# Setup smooth params
tr = 1.5
ub = 0.06
lb = 0.001
if "tr" in kwargs:
tr = kwargs["tr"]
if "ub" in kwargs:
ub = kwargs["ub"]
if "lb" in kwargs:
ub = kwargs["lb"]
X = smoothfn(X, tr=tr, ub=ub, lb=lb)
assert checkX(X)
if sparse:
X = csc_matrix(X)
return X
def run(self, basename, cond, index, wheelerdata, cond_to_rt,
smooth=False,
filtfile=None, TR=2, trname="TR",
n_features=10, n_univariate=None, n_accumulator=None, n_decision=None,
n_noise=None, drift_noise=False, step_noise=False, z_noise=False,
drift_noise_param=None, step_noise_param=None, z_noise_param=None,
noise_f=white, hrf_f=None, hrf_params=None, prng=None):
"""Reproduce the cond from the wheelerdata experiment
Parameters
---------
basename : str
The name for the Reproduced datafile, will be suffixed
by each cond and scode and .csv
(i.e. `'{0}_{1}_{2}.csv'.format(basename, cond, scode)`).
cond : str
A condition name found in the wheelerdata objects metadata
index : str
A name of a trial index found in the wheelerdata object metadata
wheelerdata : object, instance of Wheelerdata
A Wheelerdata object
cond_to_rt: dict
A map of cond (key) to reaction time (item, (int, float))
smooth : boolean, optional
Do bandpass filtering (default False)
filtfile : str, None
A name of json file designed for reprocessing Wheelerdata metadata
TR : float, int
The repitition time of the experiement
trname : str
The name of the index of TRs in the metadata
n_features : int
The number of features in total (other n_* arguements
must sum to this value
n_univariate : int
The number of univariate (boxcar) features
n_accumulator : int
The number of accumulator features
n_decision : int
The number of decision features
n_noise : int
The number of noise features
drift_noise : boolean, optional
Add noise to the drift rate of the accumulator features
step_noise : boolean, optional
Add Noise to each step accumulator features
z_noise : boolean, optional
Add noise to the start value of accumulator features
drift_noise_param : None or dict, optional
Parameters for drift_noise which is drawn from a
Gaussian distribution. None defaults to:
`{"loc": 0, "scale" : 0.5}`
step_noise_param : None or dict, optional
Parameters for step_noise which is drawn from a
Gaussian distribution. None defaults to:
`{"loc" : 0, "scale" : 0.2, "size" : 1}`
z_noise_param : None or dict, optional
Parameters for z_noise which is drawn from the uniform
distribution. None defaults to:
`{"low" : 0.01, "high" : 0.5, "size" : 1}`
noise_f : function, optional
Produces noise, must have signatures like `noise, prng = f(N, prng)`
hrf_f : function, optional
Returns a haemodynamic response, signature hrf_f(**hrf_params)
hrf_params : dict
Keyword parameters for hrf_f
prng : None or RandomState object
Allows for independent random draws, used for all
random sampling
"""
mode = 'w'
header = True
# All *s lists correspond to wheelerdata.scodes
scodes = self.data.scodes
Xs, ys, yindices = make_bold_re(
cond, index, self.data,
cond_to_rt,
filtfile=filtfile,
trname=trname,
noise_f=noise_f,
hrf_f=hrf_f,
hrf_params=hrf_params,
n_features=n_features,
n_univariate=n_univariate,
n_accumulator=n_accumulator,
n_decision=n_decision,
n_noise=n_noise,
drift_noise=drift_noise,
step_noise=step_noise,
z_noise=z_noise,
drift_noise_param=drift_noise_param,
step_noise_param=step_noise_param,
z_noise_param=z_noise_param,
prng=prng)
for scode, X, y, yindex in zip(scodes, Xs, ys, yindices):
if smooth:
X = smoothfn(X, tr=1.5, ub=0.10, lb=0.001)
# Normalize
norm = MinMaxScaler((0,1))
X = norm.fit_transform(X.astype(np.float))
Xcs, csnames, ti_cs = self.spacetime.fit_transform(
X, y, yindex, self.window, self.tr)
# Name them,
csnames = unique_nan(y)
csnames = sort_nanfirst(csnames)
# and write.
for Xc, csname, ti in zip(Xcs, csnames, ti_cs):
save_tcdf(
name=join_by_underscore(True, basename, csname),
X=Xc,
cond=csname,
dataname=join_by_underscore(False,
os.path.split(basename)[-1], scode),
index=ti.astype(np.int),
header=header,
mode=mode,
float_format="%.{0}f".format(self.nsig))
# After s 1 go to append mode
mode = 'a'
header = False
def run(self, basename, smooth=False, filtfile=None,
n=None, tr=None, n_rt=None, n_trials_per_cond=None,
durations=None ,noise=None, n_features=None, n_univariate=None,
n_accumulator=None, n_decision=None, n_noise=None,
n_repeated=None, drift_noise=False, step_noise=False):
# Write init
mode = 'w'
header = True
for scode in range(n):
# If were past the first Ss data, append.
if scode > 0:
mode = 'a'
header = False
# Create the data
X, y, y_trialcount = make_bold(
n_rt,
n_trials_per_cond,
tr,
durations=durations,
noise=noise,
n_features=n_features,
n_univariate=n_univariate,
n_accumulator=n_accumulator,
n_decision=n_decision,
n_noise=n_noise,
n_repeated=n_repeated,
drift_noise=drift_noise,
step_noise=step_noise)
targets = construct_targets(trial_index=y_trialcount, y=y)
# Drop baseline trials created by make_bold
baselinemask = np.arange(y.shape[0])[y != 0]
X = X[baselinemask, ]
targets = filter_targets(baselinemask, targets)
# Filter and
if filtfile is not None:
X, targets = filterX(filtfile, X, targets)
if smooth:
X = smoothfn(X, tr=1.5, ub=0.10, lb=0.001)
# Normalize
norm = MinMaxScaler((0,1))
X = norm.fit_transform(X.astype(np.float))
# finally decompose.
Xcs, csnames, ti_cs = self.spacetime.fit_transform(
X, targets["y"], targets["trial_index"],
self.window)
# Name them,
csnames = unique_nan(y)
csnames = sort_nanfirst(csnames)
# and write.
for Xc, csname, ti in zip(Xcs, csnames, ti_cs):
save_tcdf(
name=join_by_underscore(True, basename, csname),
X=Xc,
cond=csname,
dataname=join_by_underscore(False,
os.path.split(basename)[-1], scode),
index=ti.astype(np.int),
header=header,
mode=mode,
float_format="%.{0}f".format(self.nsig))
