def ts(img_path,
mask=False,
substitution={},
):
"""
Return the mean and median of a Region of Interest (ROI) time course.
Parameters
----------
img_path : str
Path to NIfTI file from which the ROI is to be extracted.
maks : nilearn.NiftiMasker or str, optional
Nilearn `nifti1.Nifti1Image` object to use for masking the desired ROI, or a string specifying the path of a maskfile.
substitution : dict, optional
A dictionary with keys which include 'subject' and 'session'.
"""
if substitution:
img_path = img_path.format(**substitution)
img_path = path.abspath(path.expanduser(img_path))
img = nib.load(img_path)
try:
masked_data = mask.fit_transform(img)
except:
mask = path.abspath(path.expanduser(mask))
mask = NiftiMasker(mask_img=mask)
masked_data = mask.fit_transform(img).T
ts_means = np.mean(masked_data, axis=0)
ts_medians = np.mean(masked_data, axis=0)
return ts_means, ts_medians
def transform(self, imgs, confounds=None):
"""
Parameters
----------
imgs: list of Niimg-like objects
"""
self._check_fitted()
if self.smoothing_fwhm:
imgs = smooth_img(imgs, self.smoothing_fwhm)
imgs = [_utils.check_niimg_3d(img) for img in imgs]
for i, roi in enumerate(self.mask_img_):
masker = NiftiMasker(mask_img=roi)
x = masker.fit_transform(imgs)
if self.extract_funcs is not None:
x = np.array([FDICT[f][0](x, **FDICT[f][1]) for f in self.extract_funcs])
if i == 0:
X = x
else:
X = np.concatenate((X, x), axis=0)
return X.swapaxes(0, 1)
def create_rois_from_clusters(contrast_tmap, mask, threshold=3.09,
height_control='brute', cluster_threshold=10,
save_path=None):
if save_path is not None:
if not os.path.exists(save_path):
os.makedirs(save_path)
thresholded = map_threshold(contrast_tmap, mask, threshold,
height_control, cluster_threshold)
cluster_map, n_cluster = label(thresholded.get_data() > 0)
clusters = []
masker = NiftiMasker(mask_img=mask)
masker.fit()
mask_affine = nib.load(mask).get_affine()
for label_ in range(1, n_cluster + 1):
cluster = cluster_map.copy()
cluster[cluster_map != label_] = 0
cluster[cluster_map == label_] = 1
cluster = nib.Nifti1Image(cluster, mask_affine)
clusters.append(cluster)
if save_path is not None:
nib.save(cluster, os.path.join(save_path,
'cluster_{0}.nii'.format(label_)))
return clusters
def preprocess(num, subj, subj_dir, subj_warp_dir, force_warp=False):
bold_path = 'BOLD/task001_run00%i/bold_dico_bold7Tp1_to_subjbold7Tp1.nii.gz' % (num+1)
bold_path = os.path.join(DATA_DIR, subj, bold_path)
template_path = os.path.join(DATA_DIR, 'templates', 'grpbold7Tp1', 'brain.nii.gz')
warp_path = os.path.join(DATA_DIR, subj, 'templates', 'bold7Tp1', 'in_grpbold7Tp1', 'subj2tmpl_warp.nii.gz')
output_path = os.path.join(subj_warp_dir, 'run00%i.nii.gz' % num)
if force_warp or not os.path.exists(output_path):
print 'Warping image #%i...' % num
subprocess.call(['fsl5.0-applywarp', '-i', bold_path, '-o', output_path, '-r', template_path, '-w', warp_path, '-d', 'float'])
else:
print 'Reusing cached warp image #%i' % num
print 'Loading image #%i...' % num
bold = load(output_path)
masker = NiftiMasker(load(MASK_FILE))
# masker = niftimasker(load(MASK_FILE), detrend=true, smoothing_fwhm=4.0,
# high_pass=0.01, t_r=2.0, standardize=true)
masker.fit()
print 'Removing confounds from image #%i...' % num
data = masker.transform(bold, confounds(num, subj))
print 'Detrending image #%i...' % num
filtered = np.float32(savgol_filter(data, 61, 5, axis=0))
img = masker.inverse_transform(data-filtered)
print 'Smoothing image #%i...' % num
img = image.smooth_img(img, 4.0)
print 'Saving image #%i...' % num
save(img, os.path.join(subj_dir, 'run00%i.nii.gz' % num))
print 'Finished with image #%i' % num
def MaskFlatten(concat_dict, mask, iter_n):
'''Mask image data, convert to 2D feature matrix'''
nifti_masker = NiftiMasker(mask_img=mask)
masked_dict = {}
for i in range(iter_n):
masked_dict[i] = nifti_masker.fit_transform(concat_dict[i])
return masked_dict
def nilearn_denoise(in_file, brain_mask, wm_mask, csf_mask,
motreg_file, outlier_file,
bandpass, tr ):
"""Clean time series using Nilearn high_variance_confounds to extract
CompCor regressors and NiftiMasker for regression of all nuissance regressors,
detrending, normalziation and bandpass filtering.
"""
import numpy as np
import nibabel as nb
import os
from nilearn.image import high_variance_confounds
from nilearn.input_data import NiftiMasker
from nipype.utils.filemanip import split_filename
# reload niftis to round affines so that nilearn doesn't complain
wm_nii=nb.Nifti1Image(nb.load(wm_mask).get_data(), np.around(nb.load(wm_mask).get_affine(), 2), nb.load(wm_mask).get_header())
csf_nii=nb.Nifti1Image(nb.load(csf_mask).get_data(), np.around(nb.load(csf_mask).get_affine(), 2), nb.load(csf_mask).get_header())
time_nii=nb.Nifti1Image(nb.load(in_file).get_data(),np.around(nb.load(in_file).get_affine(), 2), nb.load(in_file).get_header())
# infer shape of confound array
# not ideal
confound_len = nb.load(in_file).get_data().shape[3]
# create outlier regressors
outlier_regressor = np.empty((confound_len,1))
try:
outlier_val = np.genfromtxt(outlier_file)
except IOError:
outlier_val = np.empty((0))
for index in np.atleast_1d(outlier_val):
outlier_vector = np.zeros((confound_len, 1))
outlier_vector[index] = 1
outlier_regressor = np.hstack((outlier_regressor, outlier_vector))
outlier_regressor = outlier_regressor[:,1::]
# load motion regressors
motion_regressor=np.genfromtxt(motreg_file)
# extract high variance confounds in wm/csf masks from motion corrected data
wm_regressor=high_variance_confounds(time_nii, mask_img=wm_nii, detrend=True)
csf_regressor=high_variance_confounds(time_nii, mask_img=csf_nii, detrend=True)
# create Nifti Masker for denoising
denoiser=NiftiMasker(mask_img=brain_mask, standardize=True, detrend=True, high_pass=bandpass[1], low_pass=bandpass[0], t_r=tr)
# denoise and return denoise data to img
confounds=np.hstack((outlier_regressor,wm_regressor, csf_regressor, motion_regressor))
denoised_data=denoiser.fit_transform(in_file, confounds=confounds)
denoised_img=denoiser.inverse_transform(denoised_data)
# save
_, base, _ = split_filename(in_file)
img_fname = base + '_denoised.nii.gz'
nb.save(denoised_img, img_fname)
confound_fname = os.path.join(os.getcwd(), "all_confounds.txt")
np.savetxt(confound_fname, confounds, fmt="%.10f")
return os.path.abspath(img_fname), confound_fname
def _run_interface(self, runtime):
from nilearn.input_data import NiftiMasker, NiftiLabelsMasker
from nipype.utils.filemanip import split_filename
import nibabel as nib
import os
functional_filename = self.inputs.in_file
atlas_filename = self.inputs.atlas_filename
mask_filename = self.inputs.mask_filename
# Extracting the ROI signals
masker = NiftiLabelsMasker(labels_img=atlas_filename,
background_label = 0,
standardize=True,
detrend = True,
verbose = 1
)
time_series = masker.fit_transform(functional_filename)
# Removing the ROI signal from the time series
nifti_masker = NiftiMasker(mask_img=mask_filename)
masked_data = nifti_masker.fit_transform(functional_filename, confounds=time_series[...,0])
masked_img = nifti_masker.inverse_transform(masked_data)
# Saving the result to disk
outputs = self._outputs().get()
fname = self.inputs.in_file
_, base, _ = split_filename(fname)
nib.save(masked_img, os.path.abspath(base + '_regressed.nii.gz'))
return runtime
def apply_mask(self, mask):
""" Mask Brain_Data instance
Args:
mask: mask (Brain_Data or nifti object)
"""
if isinstance(mask,Brain_Data):
mask = mask.to_nifti() # convert to nibabel
if not isinstance(mask, nib.Nifti1Image):
if type(mask) is str:
if os.path.isfile(mask):
mask = nib.load(mask)
# Check if mask need to be resampled into Brain_Data mask space
if not ((self.mask.get_affine()==mask.get_affine()).all()) & (self.mask.shape[0:3]==mask.shape[0:3]):
mask = resample_img(mask,target_affine=self.mask.get_affine(),target_shape=self.mask.shape)
else:
raise ValueError("Mask is not a nibabel instance, Brain_Data instance, or a valid file name.")
masked = deepcopy(self)
nifti_masker = NiftiMasker(mask_img=mask)
masked.data = nifti_masker.fit_transform(self.to_nifti())
if len(self.data.shape) > 2:
masked.data = masked.data.squeeze()
masked.nifti_masker = nifti_masker
return masked
def extract_brain_rad(db, rad_column, rad_dir, stat, include_chim=False):
"""Replaces radiation presence by stat on whole brain ROI.
Assumes brain mask and radiation nifti file is in rad_dir."""
brain_mask_file = 'BrainMask_to_rd.nii.gz'
extracted_rad_stat = {} # Memoization of radiation statistic
for idx, row in db.iterrows():
if row[rad_column] == 1:
sub_id = row['patient']
if sub_id in extracted_rad_stat:
db.loc[idx, rad_column] = extracted_rad_stat[sub_id]
else:
mask_path = os.path.join(rad_dir, sub_id, brain_mask_file)
mask_check = os.path.isfile(mask_path)
rad_path = os.path.join(rad_dir, sub_id, sub_id + '.nii')
rad_check = os.path.isfile(rad_path)
if mask_check and rad_check:
masker = NiftiMasker(mask_path)
rad_stat = stat(masker.fit_transform(rad_path))
extracted_rad_stat[sub_id] = rad_stat
db.loc[idx, rad_column] = rad_stat
else:
db.loc[idx, rad_column] = None
elif not include_chim:
db.loc[idx, rad_column] = None
db = db[db[rad_column].notnull()]
return db
def significant_signal(data_path,
substitution={},
mask_path='',
exclude_ones=False,
):
"""Return the mean and median inverse logarithm of a p-value map.
Parameters
----------
data_path : str
Path to a p-value map in NIfTI format.
mask_path : str
Path to a region of interest map in NIfTI format.
THIS IS ALMOST ALWAYS REQUIRED, as NIfTI statistic images populate the whole 3D circumscribed space around your structure of interest,
and commonly assign null values to the background.
In an inverse logarithm computation, null corresponds to infinity, which can considerably bias the evaluation.
substitution : dict
Dictionary whose keys are format identifiers present in `data_path` and whose values are strings.
Returns
-------
mean : float
median : float
"""
if substitution:
data_path = data_path.format(**substitution)
data_path = path.abspath(path.expanduser(data_path))
try:
img = nib.load(data_path)
except FileNotFoundError:
return float('NaN'), float('NaN')
if mask_path:
mask_path = path.abspath(path.expanduser(mask_path))
masker = NiftiMasker(mask_img=mask_path)
masked_data = masker.fit_transform(img).T
data = masked_data[~np.isnan(masked_data)]
else:
data = img.get_data()
data = data[~np.isnan(data)]
# We interpret zero as the lowest p-value, and conservatively estimate it to be equal to just under half of the smallest value in the defined range
nonzero = data[np.nonzero(data)]
data_min = np.min(nonzero)
data_min = data_min*0.49
data[data == 0] = data_min
if exclude_ones:
data = data[data!=1]
data = -np.log10(data)
# We use np.ma.median() because life is complicated:
# https://github.com/numpy/numpy/issues/7330
median = np.ma.median(data, axis=None)
mean = np.mean(data)
return mean, median
def similarity(self, image, method='correlation'):
""" Calculate similarity of Brain_Data() instance with single Brain_Data or Nibabel image
Args:
self: Brain_Data instance of data to be applied
image: Brain_Data or Nibabel instance of weight map
Returns:
pexp: Outputs a vector of pattern expression values
"""
if not isinstance(image, Brain_Data):
if isinstance(image, nib.Nifti1Image):
image = Brain_Data(image)
else:
raise ValueError("Image is not a Brain_Data or nibabel instance")
dim = image.shape()
# Check to make sure masks are the same for each dataset and if not create a union mask
# This might be handy code for a new Brain_Data method
if np.sum(self.nifti_masker.mask_img.get_data()==1)!=np.sum(image.nifti_masker.mask_img.get_data()==1):
new_mask = intersect_masks([self.nifti_masker.mask_img, image.nifti_masker.mask_img], threshold=1, connected=False)
new_nifti_masker = NiftiMasker(mask_img=new_mask)
data2 = new_nifti_masker.fit_transform(self.to_nifti())
image2 = new_nifti_masker.fit_transform(image.to_nifti())
else:
data2 = self.data
image2 = image.data
# Calculate pattern expression
if method is 'dot_product':
if len(image2.shape) > 1:
if image2.shape[0]>1:
pexp = []
for i in range(image2.shape[0]):
pexp.append(np.dot(data2, image2[i,:]))
pexp = np.array(pexp)
else:
pexp = np.dot(data2, image2)
else:
pexp = np.dot(data2, image2)
elif method is 'correlation':
if len(image2.shape) > 1:
if image2.shape[0]>1:
pexp = []
for i in range(image2.shape[0]):
pexp.append(pearson(image2[i,:], data2))
pexp = np.array(pexp)
else:
pexp = pearson(image2, data2)
else:
pexp = pearson(image2, data2)
return pexp
def _vectorize_nii(in_data_file, mask_file, parcellation_path, fwhm):
from nilearn.input_data import NiftiMasker, NiftiLabelsMasker
import nibabel as nib
if parcellation_path is None:
masker = NiftiMasker(mask_img=mask_file, smoothing_fwhm=fwhm)
else:
masker = NiftiLabelsMasker(labels_img=parcellation_path, smoothing_fwhm=fwhm)
vectorized_data = masker.fit_transform(in_data_file)
return vectorized_data, masker
def map_threshold(stat_img, mask_img, threshold, height_control='fpr',
cluster_threshold=0):
""" Threshold the provvided map
Parameters
----------
stat_img : Niimg-like object,
statistical image (presumably in z scale)
mask_img : Niimg-like object,
mask image
threshold: float,
cluster forming threshold (either a p-value or z-scale value)
height_control: string
false positive control meaning of cluster forming
threshold: 'fpr'|'fdr'|'bonferroni'|'none'
cluster_threshold : float, optional
cluster size threshold
Returns
-------
thresholded_map : Nifti1Image,
the stat_map theresholded at the prescribed voxel- and cluster-level
"""
# Masking
masker = NiftiMasker(mask_img=mask_img)
stats = np.ravel(masker.fit_transform(stat_img))
n_voxels = np.size(stats)
# Thresholding
if height_control == 'fpr':
z_th = norm.isf(threshold)
elif height_control == 'fdr':
z_th = fdr_threshold(stats, threshold)
elif height_control == 'bonferroni':
z_th = norm.isf(threshold / n_voxels)
else: # Brute-force thresholding
z_th = threshold
stats *= (stats > z_th)
stat_map = masker.inverse_transform(stats).get_data()
# Extract connected components above threshold
label_map, n_labels = label(stat_map > z_th)
labels = label_map[(masker.mask_img_.get_data() > 0)]
for label_ in range(1, n_labels + 1):
if np.sum(labels == label_) < cluster_threshold:
stats[labels == label_] = 0
return masker.inverse_transform(stats)
def make_ttest(reg1, reg2):
masker = NiftiMasker(nib.load(MASK_FILE), standardize=False)
masker.fit()
subjects = [1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
a = np.arctanh(join_all_subjects(reg1, subjects, masker))
b = np.arctanh(join_all_subjects(reg2, subjects, masker))
t, prob = ttest_rel(a, b)
tt = masker.inverse_transform(t)
pp = masker.inverse_transform(prob)
return tt, pp
def load_data():
with open(expanduser('~/data/HCP_unmasked/data.json'), 'r') as f:
data = json.load(f)
for this_data in data:
this_data['array'] += '.npy'
mask_img = expanduser('~/data/HCP_mask/mask_img.nii.gz')
masker = NiftiMasker(mask_img=mask_img, smoothing_fwhm=4,
standardize=True)
masker.fit()
smith2009 = fetch_atlas_smith_2009()
init = smith2009.rsn70
dict_init = masker.transform(init)
return masker, dict_init, sorted(data, key=lambda t: t['filename'])
def preprocess_varpar(num, subj, subj_dir, **kwargs):
from nistats.design_matrix import make_design_matrix
from nistats.first_level_model import run_glm
bold_path = 'BOLD/task001_run00%i/bold_dico_bold7Tp1_to_subjbold7Tp1.nii.gz' % (num+1)
bold_path = os.path.join(DATA_DIR, subj, bold_path)
mask = os.path.join(DATA_DIR, subj, 'templates', 'bold7Tp1', 'brain_mask.nii.gz')
bold = load(bold_path)
masker = NiftiMasker(mask)
data = masker.fit_transform(bold)
dmat = make_design_matrix(np.arange(data.shape[0])*TR, hrf_model='fir', drift_order=5,
**kwargs)
labels, results = run_glm(data, dmat, noise_model='ols', verbose=1)
img = masker.inverse_transform(StandardScaler().fit_transform(results[0.0].resid))
# return StandardScaler().fit_transform(results[0.0].resid)
save(img, os.path.join(subj_dir, 'run00%i.nii.gz' % num))
class SmoothResampleMasker(BaseMasker):
def __init__(self, mask_img=None, smoothing_fwhm=None, resampling=None, searchlight=False):
self.mask_img = mask_img
self.smoothing_fwhm = smoothing_fwhm
self.resampling = resampling
self.searchlight = searchlight
self.masker = None
def fit(self):
if self.resampling is not None:
self.mask_img = resample_img(self.mask_img, target_affine=np.diag(self.resampling * np.ones(3)))
self.masker = NiftiMasker(mask_img=self.mask_img)
self.masker.fit()
return self
def transform(self, imgs, confounds=None):
smooth_prefix = '' if self.smoothing_fwhm is None else 's%g' % self.smoothing_fwhm
resample_prefix = '' if self.smoothing_fwhm is None else 'r%g' % self.smoothing_fwhm
if not isinstance(imgs, list):
imgs = [imgs]
path_first = imgs[0] if isinstance(imgs[0], str) else imgs[0].get_filename()
path_first_resampled = os.path.join(os.path.dirname(path_first), resample_prefix + os.path.basename(path_first))
path_first_smoothed = os.path.join(os.path.dirname(path_first), smooth_prefix + resample_prefix + os.path.basename(path_first))
if self.resampling is not None and self.smoothing_fwhm is not None:
if self.resampling is not None:
if not os.path.exists(path_first_resampled) and not os.path.exists(path_first_smoothed):
imgs = resample_img(imgs, target_affine=np.diag(self.resampling * np.ones(3)))
else:
imgs = []
if self.smoothing_fwhm is not None:
if not os.path.exists(path_first_smoothed):
imgs = smooth_img(imgs, self.smoothing_fwhm)
else:
imgs = []
else:
imgs = [check_niimg_3d(img) for img in imgs]
return self.masker.transform(imgs)
class signal_extractor():
def __init__(self, dataset = None):
self.dataset = dataset
if dataset.has_key('mask'):
self.masker = NiftiMasker(mask_img = self.dataset.mask,
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
memory_level = 0,
verbose=5)
else:
self.masker = NiftiMasker(
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
memory_level = 0,
verbose=5)
def extract(self):
for idx, func in enumerate([self.dataset.func1]):
#add mask, smoothing, filter and detrending
for i in range(len(self.dataset.subjects)):
tic = time.clock()
#extract signal to x
x = self.masker.fit_transform(func[i])
print "loading time : "+ str(time.clock() - tic)
yield x, self.masker
def loader(anat, downsample, target_affine, dataroot, subject, maskpath, nrun,
niifilename, labels, **kwargs):
'''
All parameters are submitted as cfg dictionary.
Given parameters in cfg, return masked and concatenated over runs data
Input
anat: MNI template
downsample: 1 or 0
target_affine: downsampling matrix
dataroot: element of path to data
subject: folder in dataroot with subject data
maskpath: path to mask
nrun: number of runs
niifilename: how is the data file called
labels: labels from load_labels function
Output
dict(nii_func=nii_func,nii_mean=nii_mean,masker=masker,nii_mask=nii_mask)
nii_func: 4D data
nii_mean: mean over 4th dimension
masker: masker object from nibabel
nii_mask: 3D mask
'''
nii_func = list()
for r in range(nrun):
fname = '{0}/{1}/run{2}/{3}'.format(dataroot, subject, r+1, niifilename) # Assumption about file location
nii_img = load(fname, mmap=False)
nii_img.set_sform(anat.get_sform())
# Get mean over 4D
nii_mean = mean_img(nii_img)
# Masking
nii_mask = load(maskpath)
nii_mask.set_sform(anat.get_sform())
# Binarize the mask
nii_mask = check_binary(nii_mask)
if downsample:
nii_img = resample_img(nii_img, target_affine=target_affine)
nii_mask = resample_img(nii_mask, target_affine=target_affine, interpolation='nearest')
masker = NiftiMasker(nii_mask, standardize=True)
nii_img = masker.fit_transform(nii_img)
# Drop zero timepoints, zscore
nii_img = drop_labels(nii_img, labels.get('to_drop_zeros')[r])
nii_func.append(stats.zscore(nii_img, axis=0)) # zscore over time
# throw data together
nii_func = np.concatenate(nii_func)
return dict(nii_func=nii_func, nii_mean=nii_mean, masker=masker, nii_mask=nii_mask)
def __init__(self, data=None, Y=None, X=None, mask=None, output_file=None, **kwargs):
if mask is not None:
if not isinstance(mask, nib.Nifti1Image):
if type(mask) is str:
if os.path.isfile(mask):
mask = nib.load(mask)
else:
raise ValueError("mask is not a nibabel instance")
self.mask = mask
else:
self.mask = nib.load(os.path.join(get_resource_path(),'MNI152_T1_2mm_brain_mask.nii.gz'))
self.nifti_masker = NiftiMasker(mask_img=self.mask)
if data is not None:
if type(data) is str:
data=nib.load(data)
self.data = self.nifti_masker.fit_transform(data)
elif type(data) is list:
# Load and transform each image in list separately (nib.concat_images(data) can't handle images of different sizes)
self.data = []
for i in data:
if isinstance(i,six.string_types):
self.data.append(self.nifti_masker.fit_transform(nib.load(i)))
elif isinstance(i,nib.Nifti1Image):
self.data.append(self.nifti_masker.fit_transform(i))
self.data = np.array(self.data)
elif not isinstance(data, nib.Nifti1Image):
raise ValueError("data is not a nibabel instance")
# Collapse any extra dimension
if any([x==1 for x in self.data.shape]):
self.data=self.data.squeeze()
else:
self.data = np.array([])
if Y is not None:
if type(Y) is str:
if os.path.isfile(Y):
Y=pd.read_csv(Y,header=None,index_col=None)
if isinstance(Y, pd.DataFrame):
if self.data.shape[0]!= len(Y):
raise ValueError("Y does not match the correct size of data")
self.Y = Y
else:
raise ValueError("Make sure Y is a pandas data frame.")
else:
self.Y = pd.DataFrame()
if X is not None:
if self.data.shape[0]!= X.shape[0]:
raise ValueError("X does not match the correct size of data")
self.X = X
else:
self.X = pd.DataFrame()
if output_file is not None:
self.file_name = output_file
else:
self.file_name = []
def test_multi_pca_score():
shape = (6, 8, 10, 5)
affine = np.eye(4)
rng = np.random.RandomState(0)
# Create a "multi-subject" dataset
imgs = []
for i in range(8):
this_img = rng.normal(size=shape)
imgs.append(nibabel.Nifti1Image(this_img, affine))
mask_img = nibabel.Nifti1Image(np.ones(shape[:3], dtype=np.int8), affine)
# Assert that score is between zero and one
multi_pca = MultiPCA(mask=mask_img, random_state=0, memory_level=0,
n_components=3)
multi_pca.fit(imgs)
s = multi_pca.score(imgs)
assert_true(np.all(s <= 1))
assert_true(np.all(0 <= s))
# Assert that score does not fail with single subject data
multi_pca = MultiPCA(mask=mask_img, random_state=0, memory_level=0,
n_components=3)
multi_pca.fit(imgs[0])
s = multi_pca.score(imgs[0])
assert_true(isinstance(s, float))
assert(0. <= s <= 1.)
# Assert that score is one for n_components == n_sample
# in single subject configuration
multi_pca = MultiPCA(mask=mask_img, random_state=0, memory_level=0,
n_components=5)
multi_pca.fit(imgs[0])
s = multi_pca.score(imgs[0])
assert_almost_equal(s, 1., 1)
# Per component score
multi_pca = MultiPCA(mask=mask_img, random_state=0, memory_level=0,
n_components=5)
multi_pca.fit(imgs[0])
masker = NiftiMasker(mask_img).fit()
s = multi_pca._raw_score(masker.transform(imgs[0]), per_component=True)
assert_equal(s.shape, (5,))
assert_true(np.all(s <= 1))
assert_true(np.all(0 <= s))
def fit(self):
if self.resampling is not None:
self.mask_img = resample_img(self.mask_img, target_affine=np.diag(self.resampling * np.ones(3)))
self.masker = NiftiMasker(mask_img=self.mask_img)
self.masker.fit()
return self
def residualize_imgs(in_file, mask_file, confounds_file):
'''
* takes 4d file, mask file & confounds as np.array
* regresses out confounds (only within mask)
* writes residualized nii
'''
from nilearn.input_data import NiftiMasker
import os
import numpy as np
confounds = np.loadtxt(confounds_file)
masker = NiftiMasker(mask_img=mask_file)
brain_data_2d = masker.fit_transform(in_file, confounds=confounds)
out_file = os.path.join(os.getcwd(), 'residualized_data.nii.gz')
out_img = masker.inverse_transform(brain_data_2d)
out_img.to_filename(out_file)
return out_file
def multivariate_similarity(self, images, method='ols'):
""" Predict spatial distribution of Brain_Data() instance from linear combination of other Brain_Data() instances or Nibabel images
Args:
self: Brain_Data instance of data to be applied
images: Brain_Data instance of weight map
Returns:
out: dictionary of regression statistics in Brain_Data instances {'beta','t','p','df','residual'}
"""
## Notes: Should add ridge, and lasso, elastic net options options
if len(self.shape()) > 1:
raise ValueError("This method can only decompose a single brain image.")
if not isinstance(images, Brain_Data):
raise ValueError("Images are not a Brain_Data instance")
dim = images.shape()
# Check to make sure masks are the same for each dataset and if not create a union mask
# This might be handy code for a new Brain_Data method
if np.sum(self.nifti_masker.mask_img.get_data()==1)!=np.sum(images.nifti_masker.mask_img.get_data()==1):
new_mask = intersect_masks([self.nifti_masker.mask_img, images.nifti_masker.mask_img], threshold=1, connected=False)
new_nifti_masker = NiftiMasker(mask_img=new_mask)
data2 = new_nifti_masker.fit_transform(self.to_nifti())
image2 = new_nifti_masker.fit_transform(images.to_nifti())
else:
data2 = self.data
image2 = images.data
# Add intercept and transpose
image2 = np.vstack((np.ones(image2.shape[1]),image2)).T
# Calculate pattern expression
if method is 'ols':
b = np.dot(np.linalg.pinv(image2), data2)
res = data2 - np.dot(image2,b)
sigma = np.std(res,axis=0)
stderr = np.dot(np.matrix(np.diagonal(np.linalg.inv(np.dot(image2.T,image2)))**.5).T,np.matrix(sigma))
t_out = b /stderr
df = image2.shape[0]-image2.shape[1]
p = 2*(1-t.cdf(np.abs(t_out),df))
return {'beta':b, 't':t_out, 'p':p, 'df':df, 'sigma':sigma, 'residual':res}
def read_data_haxby(subject, tr=2.5, masker=False):
haxby_dataset = fetch_haxby(subjects=[subject])
# Load fmri data
fmri_filename = haxby_dataset.func[0]
fmri = load_img(fmri_filename)
# mask = haxby_dataset.mask_vt[0]
masker = NiftiMasker(mask_strategy='epi', standardize=True, detrend=True,
high_pass=0.01, t_r=tr, smoothing_fwhm=5)
fmri = masker.fit_transform(fmri)
fmri = fmri.reshape(12, -1, fmri.shape[-1])
# Load stimuli data
classes = np.array(['rest', 'face', 'house', 'bottle', 'cat', 'chair',
'scissors', 'shoe', 'scrambledpix'])
labels = np.recfromcsv(
haxby_dataset.session_target[0], delimiter=" ")['labels'].reshape(
12, -1)
stimuli, onsets, conditions = (np.zeros((
12, len(labels[0]), len(classes))), [], [])
stimuli[:, 0, 0] = 1
for session in range(12):
onsets.append([])
conditions.append([])
for scan in range(1, len(fmri[session])):
if (labels[session][scan - 1] == 'rest' and
labels[session][scan] != 'rest'):
label = labels[session][scan]
stimuli[session, scan, np.where(classes == label)[0][0]] = 1
conditions[session].append(label)
onsets[session].append(scan * tr)
else:
stimuli[session, scan, 0] = 1
if subject == 5:
fmri = np.vstack((fmri[:8], fmri[9:]))
stimuli = np.vstack((stimuli[:8], stimuli[9:]))
onsets = np.vstack((onsets[:8], onsets[9:]))
conditions = np.vstack((conditions[:8], conditions[9:]))
if masker:
return fmri, stimuli, onsets, conditions, masker
return fmri, stimuli, onsets, conditions
def apply_mask(data=None, weight_map=None, mask=None, method='dot_product', save_output=False, output_dir='.'):
""" Apply Nifti weight map to Nifti Images.
Args:
data: nibabel instance of data to be applied
weight_map: nibabel instance of weight map
mask: binary nibabel mask
method: type of pattern expression (e.g,. 'dot_product','correlation')
save_output: Boolean indicating whether or not to save output to csv file.
output_dir: Directory to use for writing all outputs
**kwargs: Additional parameters to pass
Returns:
pexp: Outputs a vector of pattern expression values
"""
if mask is not None:
if type(mask) is not nib.nifti1.Nifti1Image:
raise ValueError("Mask is not a nibabel instance")
else:
mask = nib.load(os.path.join(resource_dir,'MNI152_T1_2mm_brain_mask_dil.nii.gz'))
if type(data) is not nib.nifti1.Nifti1Image:
raise ValueError("Data is not a nibabel instance")
nifti_masker = NiftiMasker(mask_img=mask)
data_masked = nifti_masker.fit_transform(data)
if type(weight_map) is not nib.nifti1.Nifti1Image:
raise ValueError("Weight_map is not a nibabel instance")
weight_map_masked = nifti_masker.fit_transform(weight_map)
# Calculate pattern expression
if method is 'dot_product':
pexp = np.dot(data_masked,np.transpose(weight_map_masked)).squeeze()
elif method is 'correlation':
pexp = pearson(data_masked,weight_map_masked)
if save_output:
np.savetxt(os.path.join(output_dir,"Pattern_Expression_" + method + ".csv"), pexp, delimiter=",")
return pexp
def test_dict_learning():
data, mask_img, components, rng = _make_canica_test_data(n_subjects=8)
mask = NiftiMasker(mask_img=mask_img).fit()
dict_init = mask.inverse_transform(components)
dict_learning = DictLearning(n_components=4, random_state=0,
dict_init=dict_init,
mask=mask_img,
smoothing_fwhm=0., alpha=1)
dict_learning_auto_init = DictLearning(n_components=4, random_state=0,
mask=mask_img,
smoothing_fwhm=0., n_epochs=10,
alpha=1)
maps = {}
for estimator in [dict_learning,
dict_learning_auto_init]:
estimator.fit(data)
maps[estimator] = estimator.masker_. \
inverse_transform(estimator.components_).get_data()
maps[estimator] = np.reshape(np.rollaxis(maps[estimator], 3, 0),
(4, 400))
for this_dict_learning in [dict_learning]:
these_maps = maps[this_dict_learning]
S = np.sqrt(np.sum(components ** 2, axis=1))
S[S == 0] = 1
components /= S[:, np.newaxis]
S = np.sqrt(np.sum(these_maps ** 2, axis=1))
S[S == 0] = 1
these_maps /= S[:, np.newaxis]
K = np.abs(components.dot(these_maps.T))
recovered_maps = np.sum(K > 0.9)
assert(recovered_maps >= 2)
# Smoke test n_epochs > 1
dict_learning = DictLearning(n_components=4, random_state=0,
dict_init=dict_init,
mask=mask_img,
smoothing_fwhm=0., n_epochs=2, alpha=1)
dict_learning.fit(data)
def main(output_dir, n_jobs):
dir_list = [join(output_dir, f) for f in os.listdir(output_dir) if
os.path.isdir(join(output_dir, f))]
mask, func_filenames = get_hcp_data(raw=True)
masker = NiftiMasker(mask_img=mask, smoothing_fwhm=None,
standardize=False)
masker.fit()
test_data = func_filenames[(-n_test_records * 2)::2]
n_samples, n_voxels = np.load(test_data[-1], mmap_mode='r').shape
X = np.empty((n_test_records * n_samples, n_voxels))
for i, this_data in enumerate(test_data):
X[i * n_samples:(i + 1) * n_samples] = np.load(this_data,
mmap_mode='r')
Parallel(n_jobs=n_jobs, verbose=1, temp_folder='/dev/shm')(
delayed(analyse_dir)(dir_name, X, masker) for dir_name in dir_list)
def __init__(self, dataset = None):
self.dataset = dataset
if dataset.has_key('mask'):
self.masker = NiftiMasker(mask_img = self.dataset.mask,
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
memory_level = 0,
verbose=5)
else:
self.masker = NiftiMasker(
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
memory_level = 0,
verbose=5)
def __init__(self, mask=None, metric='wavelet', regu='tv', lbda=1, detrend=True,
low_pass=.1, high_pass=.01, t_r=1.05, smoothing_fwhm=6.,
memory='', memory_level=0, n_jobs=1, nb_vanishmoment=2,
norm=1, q=np.array(2), nbvoies=None,
distn=1, wtype=1, j1=2, j2=8):
self.metric = metric
self.mask = mask
self.n_jobs = n_jobs
self.nb_vanishmoment = nb_vanishmoment
self.norm = norm
self.q = q
self.nbvoies = nbvoies
self.distn = distn
self.wtype = wtype
self.j1 = j1
self.j2 = j2
self.regu = regu
self.lbda = lbda
if self.mask is None:
self.masker = NiftiMasker(detrend=detrend,
low_pass=low_pass,
high_pass=high_pass,
t_r=t_r,
smoothing_fwhm=smoothing_fwhm,
standardize=False,
memory_level=memory_level,
verbose=0)
else:
self.masker = NiftiMasker(mask_img=self.mask,
detrend=detrend,
low_pass=low_pass,
high_pass=high_pass,
t_r=t_r,
smoothing_fwhm=smoothing_fwhm,
standardize=False,
memory_level=memory_level,
verbose=0)
self.masker.fit(self.mask)
def fit(self, second_level_input, confounds=None, design_matrix=None):
""" Fit the second-level GLM
1. create design matrix
2. do a masker job: fMRI_data -> Y
3. fit regression to (Y, X)
Parameters
----------
second_level_input: list of `FirstLevelModel` objects or pandas
DataFrame or list of Niimg-like objects.
Giving FirstLevelModel objects will allow to easily compute
the second level contast of arbitrary first level contrasts thanks
to the first_level_contrast argument of the compute_contrast
method. Effect size images will be computed for each model to
contrast at the second level.
If a pandas DataFrame, then they have to contain subject_label,
map_name and effects_map_path. It can contain multiple maps that
would be selected during contrast estimation with the argument
first_level_contrast of the compute_contrast function. The
DataFrame will be sorted based on the subject_label column to avoid
order inconsistencies when extracting the maps. So the rows of the
automatically computed design matrix, if not provided, will
correspond to the sorted subject_label column.
If list of Niimg-like objects then this is taken literally as Y
for the model fit and design_matrix must be provided.
confounds: pandas DataFrame, optional
Must contain a subject_label column. All other columns are
considered as confounds and included in the model. If
design_matrix is provided then this argument is ignored.
The resulting second level design matrix uses the same column
names as in the given DataFrame for confounds. At least two columns
are expected, "subject_label" and at least one confound.
design_matrix: pandas DataFrame, optional
Design matrix to fit the GLM. The number of rows
in the design matrix must agree with the number of maps derived
from second_level_input.
Ensure that the order of maps given by a second_level_input
list of Niimgs matches the order of the rows in the design matrix.
"""
# Check parameters
# check first level input
if isinstance(second_level_input, list):
if len(second_level_input) < 2:
raise ValueError('A second level model requires a list with at'
'least two first level models or niimgs')
# Check FirstLevelModel objects case
if isinstance(second_level_input[0], FirstLevelModel):
models_input = enumerate(second_level_input)
for model_idx, first_level_model in models_input:
if (first_level_model.labels_ is None
or first_level_model.results_ is None):
raise ValueError(
'Model %s at index %i has not been fit yet'
'' % (first_level_model.subject_label, model_idx))
if not isinstance(first_level_model, FirstLevelModel):
raise ValueError(' object at idx %d is %s instead of'
' FirstLevelModel object' %
(model_idx, type(first_level_model)))
if confounds is not None:
if first_level_model.subject_label is None:
raise ValueError(
'In case confounds are provided, first level '
'objects need to provide the attribute '
'subject_label to match rows appropriately.'
'Model at idx %d does not provide it. '
'To set it, you can do '
'first_level_model.subject_label = "01"'
'' % (model_idx))
# Check niimgs case
elif isinstance(second_level_input[0], (str, Nifti1Image)):
if design_matrix is None:
raise ValueError('List of niimgs as second_level_input'
' require a design matrix to be provided')
for model_idx, niimg in enumerate(second_level_input):
if not isinstance(niimg, (str, Nifti1Image)):
raise ValueError(' object at idx %d is %s instead of'
' Niimg-like object' %
(model_idx, type(niimg)))
# Check pandas dataframe case
elif isinstance(second_level_input, pd.DataFrame):
for col in ['subject_label', 'map_name', 'effects_map_path']:
if col not in second_level_input.columns:
raise ValueError('second_level_input DataFrame must have'
' columns subject_label, map_name and'
' effects_map_path')
# Make sure subject_label contain strings
second_level_columns = second_level_input.columns.tolist()
labels_index = second_level_columns.index('subject_label')
labels_dtype = second_level_input.dtypes[labels_index]
if not isinstance(labels_dtype, np.object):
raise ValueError('subject_label column must be of dtype '
'object instead of dtype %s' % labels_dtype)
elif isinstance(second_level_input, (str, Nifti1Image)):
if design_matrix is None:
raise ValueError('List of niimgs as second_level_input'
' require a design matrix to be provided')
second_level_input = check_niimg(niimg=second_level_input,
ensure_ndim=4)
else:
raise ValueError('second_level_input must be a list of'
' `FirstLevelModel` objects, a pandas DataFrame'
' or a list Niimg-like objects. Instead %s '
'was provided' % type(second_level_input))
# check confounds
if confounds is not None:
if not isinstance(confounds, pd.DataFrame):
raise ValueError('confounds must be a pandas DataFrame')
if 'subject_label' not in confounds.columns:
raise ValueError('confounds DataFrame must contain column'
'"subject_label"')
if len(confounds.columns) < 2:
raise ValueError('confounds should contain at least 2 columns'
'one called "subject_label" and the other'
'with a given confound')
# Make sure subject_label contain strings
labels_index = confounds.columns.tolist().index('subject_label')
labels_dtype = confounds.dtypes[labels_index]
if not isinstance(labels_dtype, np.object):
raise ValueError('subject_label column must be of dtype '
'object instead of dtype %s' % labels_dtype)
# check design matrix
if design_matrix is not None:
if not isinstance(design_matrix, pd.DataFrame):
raise ValueError('design matrix must be a pandas DataFrame')
# sort a pandas dataframe by subject_label to avoid inconsistencies
# with the design matrix row order when automatically extracting maps
if isinstance(second_level_input, pd.DataFrame):
columns = second_level_input.columns.tolist()
column_index = columns.index('subject_label')
sorted_matrix = sorted(second_level_input.values,
key=lambda x: x[column_index])
sorted_input = pd.DataFrame(sorted_matrix, columns=columns)
second_level_input = sorted_input
self.second_level_input_ = second_level_input
self.confounds_ = confounds
# Report progress
t0 = time.time()
if self.verbose > 0:
sys.stderr.write("Fitting second level model. "
"Take a deep breath\r")
# Select sample map for masker fit and get subjects_label for design
if isinstance(second_level_input, pd.DataFrame):
sample_map = second_level_input['effects_map_path'][0]
labels = second_level_input['subject_label']
subjects_label = labels.values.tolist()
elif isinstance(second_level_input, Nifti1Image):
sample_map = mean_img(second_level_input)
elif isinstance(second_level_input[0], FirstLevelModel):
sample_model = second_level_input[0]
sample_condition = sample_model.design_matrices_[0].columns[0]
sample_map = sample_model.compute_contrast(
sample_condition, output_type='effect_size')
labels = [model.subject_label for model in second_level_input]
subjects_label = labels
else:
# In this case design matrix had to be provided
sample_map = mean_img(second_level_input)
# Create and set design matrix, if not given
if design_matrix is None:
design_matrix = make_second_level_design_matrix(
subjects_label, confounds)
self.design_matrix_ = design_matrix
# Learn the mask. Assume the first level imgs have been masked.
if not isinstance(self.mask, NiftiMasker):
self.masker_ = NiftiMasker(mask_img=self.mask,
smoothing_fwhm=self.smoothing_fwhm,
memory=self.memory,
verbose=max(0, self.verbose - 1),
memory_level=self.memory_level)
else:
self.masker_ = clone(self.mask)
for param_name in ['smoothing_fwhm', 'memory', 'memory_level']:
our_param = getattr(self, param_name)
if our_param is None:
continue
if getattr(self.masker_, param_name) is not None:
warn('Parameter %s of the masker overriden' % param_name)
setattr(self.masker_, param_name, our_param)
self.masker_.fit(sample_map)
# Report progress
if self.verbose > 0:
sys.stderr.write("\nComputation of second level model done in "
"%i seconds\n" % (time.time() - t0))
return self
class SecondLevelModel(BaseEstimator, TransformerMixin, CacheMixin):
""" Implementation of the General Linear Model for multiple subject
fMRI data
Parameters
----------
mask: Niimg-like, NiftiMasker or MultiNiftiMasker object, optional,
Mask to be used on data. If an instance of masker is passed,
then its mask will be used. If no mask is given,
it will be computed automatically by a MultiNiftiMasker with default
parameters. Automatic mask computation assumes first level imgs have
already been masked.
smoothing_fwhm: float, optional
If smoothing_fwhm is not None, it gives the size in millimeters of the
spatial smoothing to apply to the signal.
memory: string, optional
Path to the directory used to cache the masking process and the glm
fit. By default, no caching is done. Creates instance of joblib.Memory.
memory_level: integer, optional
Rough estimator of the amount of memory used by caching. Higher value
means more memory for caching.
verbose : integer, optional
Indicate the level of verbosity. By default, nothing is printed.
If 0 prints nothing. If 1 prints final computation time.
If 2 prints masker computation details.
n_jobs : integer, optional
The number of CPUs to use to do the computation. -1 means
'all CPUs', -2 'all CPUs but one', and so on.
minimize_memory : boolean, optional
Gets rid of some variables on the model fit results that are not
necessary for contrast computation and would only be useful for
further inspection of model details. This has an important impact
on memory consumption. True by default.
"""
def __init__(self,
mask=None,
smoothing_fwhm=None,
memory=Memory(None),
memory_level=1,
verbose=0,
n_jobs=1,
minimize_memory=True):
self.mask = mask
self.smoothing_fwhm = smoothing_fwhm
if isinstance(memory, _basestring):
self.memory = Memory(memory)
else:
self.memory = memory
self.memory_level = memory_level
self.verbose = verbose
self.n_jobs = n_jobs
self.minimize_memory = minimize_memory
self.second_level_input_ = None
self.confounds_ = None
def fit(self, second_level_input, confounds=None, design_matrix=None):
""" Fit the second-level GLM
1. create design matrix
2. do a masker job: fMRI_data -> Y
3. fit regression to (Y, X)
Parameters
----------
second_level_input: list of `FirstLevelModel` objects or pandas
DataFrame or list of Niimg-like objects.
Giving FirstLevelModel objects will allow to easily compute
the second level contast of arbitrary first level contrasts thanks
to the first_level_contrast argument of the compute_contrast
method. Effect size images will be computed for each model to
contrast at the second level.
If a pandas DataFrame, then they have to contain subject_label,
map_name and effects_map_path. It can contain multiple maps that
would be selected during contrast estimation with the argument
first_level_contrast of the compute_contrast function. The
DataFrame will be sorted based on the subject_label column to avoid
order inconsistencies when extracting the maps. So the rows of the
automatically computed design matrix, if not provided, will
correspond to the sorted subject_label column.
If list of Niimg-like objects then this is taken literally as Y
for the model fit and design_matrix must be provided.
confounds: pandas DataFrame, optional
Must contain a subject_label column. All other columns are
considered as confounds and included in the model. If
design_matrix is provided then this argument is ignored.
The resulting second level design matrix uses the same column
names as in the given DataFrame for confounds. At least two columns
are expected, "subject_label" and at least one confound.
design_matrix: pandas DataFrame, optional
Design matrix to fit the GLM. The number of rows
in the design matrix must agree with the number of maps derived
from second_level_input.
Ensure that the order of maps given by a second_level_input
list of Niimgs matches the order of the rows in the design matrix.
"""
# Check parameters
# check first level input
if isinstance(second_level_input, list):
if len(second_level_input) < 2:
raise ValueError('A second level model requires a list with at'
'least two first level models or niimgs')
# Check FirstLevelModel objects case
if isinstance(second_level_input[0], FirstLevelModel):
models_input = enumerate(second_level_input)
for model_idx, first_level_model in models_input:
if (first_level_model.labels_ is None
or first_level_model.results_ is None):
raise ValueError(
'Model %s at index %i has not been fit yet'
'' % (first_level_model.subject_label, model_idx))
if not isinstance(first_level_model, FirstLevelModel):
raise ValueError(' object at idx %d is %s instead of'
' FirstLevelModel object' %
(model_idx, type(first_level_model)))
if confounds is not None:
if first_level_model.subject_label is None:
raise ValueError(
'In case confounds are provided, first level '
'objects need to provide the attribute '
'subject_label to match rows appropriately.'
'Model at idx %d does not provide it. '
'To set it, you can do '
'first_level_model.subject_label = "01"'
'' % (model_idx))
# Check niimgs case
elif isinstance(second_level_input[0], (str, Nifti1Image)):
if design_matrix is None:
raise ValueError('List of niimgs as second_level_input'
' require a design matrix to be provided')
for model_idx, niimg in enumerate(second_level_input):
if not isinstance(niimg, (str, Nifti1Image)):
raise ValueError(' object at idx %d is %s instead of'
' Niimg-like object' %
(model_idx, type(niimg)))
# Check pandas dataframe case
elif isinstance(second_level_input, pd.DataFrame):
for col in ['subject_label', 'map_name', 'effects_map_path']:
if col not in second_level_input.columns:
raise ValueError('second_level_input DataFrame must have'
' columns subject_label, map_name and'
' effects_map_path')
# Make sure subject_label contain strings
second_level_columns = second_level_input.columns.tolist()
labels_index = second_level_columns.index('subject_label')
labels_dtype = second_level_input.dtypes[labels_index]
if not isinstance(labels_dtype, np.object):
raise ValueError('subject_label column must be of dtype '
'object instead of dtype %s' % labels_dtype)
elif isinstance(second_level_input, (str, Nifti1Image)):
if design_matrix is None:
raise ValueError('List of niimgs as second_level_input'
' require a design matrix to be provided')
second_level_input = check_niimg(niimg=second_level_input,
ensure_ndim=4)
else:
raise ValueError('second_level_input must be a list of'
' `FirstLevelModel` objects, a pandas DataFrame'
' or a list Niimg-like objects. Instead %s '
'was provided' % type(second_level_input))
# check confounds
if confounds is not None:
if not isinstance(confounds, pd.DataFrame):
raise ValueError('confounds must be a pandas DataFrame')
if 'subject_label' not in confounds.columns:
raise ValueError('confounds DataFrame must contain column'
'"subject_label"')
if len(confounds.columns) < 2:
raise ValueError('confounds should contain at least 2 columns'
'one called "subject_label" and the other'
'with a given confound')
# Make sure subject_label contain strings
labels_index = confounds.columns.tolist().index('subject_label')
labels_dtype = confounds.dtypes[labels_index]
if not isinstance(labels_dtype, np.object):
raise ValueError('subject_label column must be of dtype '
'object instead of dtype %s' % labels_dtype)
# check design matrix
if design_matrix is not None:
if not isinstance(design_matrix, pd.DataFrame):
raise ValueError('design matrix must be a pandas DataFrame')
# sort a pandas dataframe by subject_label to avoid inconsistencies
# with the design matrix row order when automatically extracting maps
if isinstance(second_level_input, pd.DataFrame):
columns = second_level_input.columns.tolist()
column_index = columns.index('subject_label')
sorted_matrix = sorted(second_level_input.values,
key=lambda x: x[column_index])
sorted_input = pd.DataFrame(sorted_matrix, columns=columns)
second_level_input = sorted_input
self.second_level_input_ = second_level_input
self.confounds_ = confounds
# Report progress
t0 = time.time()
if self.verbose > 0:
sys.stderr.write("Fitting second level model. "
"Take a deep breath\r")
# Select sample map for masker fit and get subjects_label for design
if isinstance(second_level_input, pd.DataFrame):
sample_map = second_level_input['effects_map_path'][0]
labels = second_level_input['subject_label']
subjects_label = labels.values.tolist()
elif isinstance(second_level_input, Nifti1Image):
sample_map = mean_img(second_level_input)
elif isinstance(second_level_input[0], FirstLevelModel):
sample_model = second_level_input[0]
sample_condition = sample_model.design_matrices_[0].columns[0]
sample_map = sample_model.compute_contrast(
sample_condition, output_type='effect_size')
labels = [model.subject_label for model in second_level_input]
subjects_label = labels
else:
# In this case design matrix had to be provided
sample_map = mean_img(second_level_input)
# Create and set design matrix, if not given
if design_matrix is None:
design_matrix = make_second_level_design_matrix(
subjects_label, confounds)
self.design_matrix_ = design_matrix
# Learn the mask. Assume the first level imgs have been masked.
if not isinstance(self.mask, NiftiMasker):
self.masker_ = NiftiMasker(mask_img=self.mask,
smoothing_fwhm=self.smoothing_fwhm,
memory=self.memory,
verbose=max(0, self.verbose - 1),
memory_level=self.memory_level)
else:
self.masker_ = clone(self.mask)
for param_name in ['smoothing_fwhm', 'memory', 'memory_level']:
our_param = getattr(self, param_name)
if our_param is None:
continue
if getattr(self.masker_, param_name) is not None:
warn('Parameter %s of the masker overriden' % param_name)
setattr(self.masker_, param_name, our_param)
self.masker_.fit(sample_map)
# Report progress
if self.verbose > 0:
sys.stderr.write("\nComputation of second level model done in "
"%i seconds\n" % (time.time() - t0))
return self
def compute_contrast(self,
second_level_contrast=None,
first_level_contrast=None,
second_level_stat_type=None,
output_type='z_score'):
"""Generate different outputs corresponding to
the contrasts provided e.g. z_map, t_map, effects and variance.
Parameters
----------
second_level_contrast: str or array of shape (n_col), optional
Where ``n_col`` is the number of columns of the design matrix,
The string can be a formula compatible with the linear constraint
of the Patsy library. Basically one can use the name of the
conditions as they appear in the design matrix of
the fitted model combined with operators /\*+- and numbers.
Please check the patsy documentation for formula examples:
http://patsy.readthedocs.io/en/latest/API-reference.html#patsy.DesignInfo.linear_constraint
The default (None) is accepted if the design matrix has a single
column, in which case the only possible contrast array([1]) is
applied; when the design matrix has multiple columns, an error is
raised.
first_level_contrast: str or array of shape (n_col) with respect to
FirstLevelModel, optional
In case a list of FirstLevelModel was provided as
second_level_input, we have to provide a contrast to apply to
the first level models to get the corresponding list of images
desired, that would be tested at the second level. In case a
pandas DataFrame was provided as second_level_input this is the
map name to extract from the pandas dataframe map_name column.
It has to be a 't' contrast.
second_level_stat_type: {'t', 'F'}, optional
Type of the second level contrast
output_type: str, optional
Type of the output map. Can be 'z_score', 'stat', 'p_value',
'effect_size' or 'effect_variance'
Returns
-------
output_image: Nifti1Image
The desired output image
"""
if self.second_level_input_ is None:
raise ValueError('The model has not been fit yet')
# first_level_contrast check
if isinstance(self.second_level_input_[0], FirstLevelModel):
if first_level_contrast is None:
raise ValueError('If second_level_input was a list of '
'FirstLevelModel, then first_level_contrast '
'is mandatory. It corresponds to the '
'second_level_contrast argument of the '
'compute_contrast method of FirstLevelModel')
# check contrast definition
if second_level_contrast is None:
if self.design_matrix_.shape[1] == 1:
second_level_contrast = np.ones([1])
else:
raise ValueError('No second-level contrast is specified.')
if isinstance(second_level_contrast, np.ndarray):
con_val = second_level_contrast
if np.all(con_val == 0):
raise ValueError('Contrast is null')
else:
design_info = DesignInfo(self.design_matrix_.columns.tolist())
constraint = design_info.linear_constraint(second_level_contrast)
con_val = constraint.coefs
# check output type
if isinstance(output_type, _basestring):
if output_type not in [
'z_score', 'stat', 'p_value', 'effect_size',
'effect_variance'
]:
raise ValueError(
'output_type must be one of "z_score", "stat"'
', "p_value", "effect_size" or "effect_variance"')
else:
raise ValueError('output_type must be one of "z_score", "stat",'
' "p_value", "effect_size" or "effect_variance"')
# Get effect_maps appropriate for chosen contrast
effect_maps = _infer_effect_maps(self.second_level_input_,
first_level_contrast)
# Check design matrix X and effect maps Y agree on number of rows
if len(effect_maps) != self.design_matrix_.shape[0]:
raise ValueError(
'design_matrix does not match the number of maps considered. '
'%i rows in design matrix do not match with %i maps' %
(self.design_matrix_.shape[0], len(effect_maps)))
# Fit an Ordinary Least Squares regression for parametric statistics
Y = self.masker_.transform(effect_maps)
if self.memory:
mem_glm = self.memory.cache(run_glm, ignore=['n_jobs'])
else:
mem_glm = run_glm
labels, results = mem_glm(Y,
self.design_matrix_.values,
n_jobs=self.n_jobs,
noise_model='ols')
# We save memory if inspecting model details is not necessary
if self.minimize_memory:
for key in results:
results[key] = SimpleRegressionResults(results[key])
self.labels_ = labels
self.results_ = results
# We compute contrast object
if self.memory:
mem_contrast = self.memory.cache(compute_contrast)
else:
mem_contrast = compute_contrast
contrast = mem_contrast(self.labels_, self.results_, con_val,
second_level_stat_type)
# We get desired output from contrast object
estimate_ = getattr(contrast, output_type)()
# Prepare the returned images
output = self.masker_.inverse_transform(estimate_)
contrast_name = str(con_val)
output.header['descrip'] = ('%s of contrast %s' %
(output_type, contrast_name))
return output
from kmapper import KeplerMapper, Cover
from sklearn.cluster import DBSCAN
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from umap.umap_ import UMAP
from dyneusr import DyNeuGraph
from dyneusr.tools import visualize_mapper_stages
from dyneusr.mapper.utils import optimize_dbscan
# Fetch dataset, extract time-series from ventral temporal (VT) mask
dataset = fetch_haxby()
masker = NiftiMasker(dataset.mask_vt[0],
standardize=True,
detrend=True,
smoothing_fwhm=4.0,
low_pass=0.09,
high_pass=0.008,
t_r=2.5,
memory="nilearn_cache")
X = masker.fit_transform(dataset.func[0])
# Encode labels as integers
df = pd.read_csv(dataset.session_target[0], sep=" ")
target, labels = pd.factorize(df.labels.values)
y = pd.DataFrame({l: (target == i).astype(int) for i, l in enumerate(labels)})
# Extract sessions 4-5
mask_sessions = df.chunks.add(1).isin([4, 5])
X = X[mask_sessions]
y = y.loc[mask_sessions, :]
target = target[mask_sessions]
###########################################################################
# Real data loading
t_r = 0.735
n_times_valid = args.n_time_frames - hrf_time_frames + 1
h = double_gamma_hrf(t_r, hrf_time_frames)
D = (np.eye(n_times_valid, k=-1) - np.eye(n_times_valid, k=0))[:, :-1]
H = make_toeplitz(h, n_times_valid).T
# load data
sub1_img = 'data/6025086_20227_MNI_RS.nii.gz'
sub2_img = 'data/6025837_20227_MNI_RS.nii.gz'
masker = NiftiMasker(standardize=True,
detrend=True,
low_pass=0.1,
high_pass=0.01,
t_r=t_r,
memory='__cache_dir__') # noqa: E128
masker.fit([sub1_img, sub2_img])
y_train = masker.inverse_transform(masker.transform(sub1_img)).get_data()
y_test = masker.inverse_transform(masker.transform(sub2_img)).get_data()
# reduce dimensionality
start_ = 10
mask_roi = (slice(start_, start_ + nx), slice(start_, start_ + ny),
slice(start_, start_ + nz), slice(0, args.n_time_frames))
y_train = y_train[mask_roi]
y_test = y_test[mask_roi]
# lbda-max scale data
from group_parcellation import (
make_parcels, reproducibility_selection, parcel_selection,
parcel_cv, rate_atlas)
###############################################################################
# Get the data
contrasts = ['horizontal vs vertical checkerboard',
'left vs right button press',
'button press vs calculation and sentence listening/reading',
'auditory processing vs visual processing',
'auditory&visual calculation vs sentences',
'sentence reading vs checkerboard']
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
grp_mask = load(nifti_masker.mask_img).get_data()
affine = load(nifti_masker.mask_img).get_affine()
# Create the data matrix
n_contrasts, n_subjects = len(contrasts), 40
subjects = ['S%02d' % i for i in range(n_subjects)]
n_voxels = grp_mask.sum()
X = np.zeros((n_voxels, n_contrasts, n_subjects))
for nc, contrast in enumerate(contrasts):
imgs = datasets.fetch_localizer_contrasts(
[contrast], n_subjects=n_subjects,
data_dir='/tmp/')['cmaps']
X[:, nc, :] = nifti_masker.fit_transform(imgs).T
dummy_classifier = DummyClassifier()
# Make a data splitting object for cross validation
from sklearn.cross_validation import LeaveOneLabelOut, cross_val_score
cv = LeaveOneLabelOut(session_labels)
mask_names = ['mask_vt', 'mask_face', 'mask_house']
mask_scores = {}
mask_chance_scores = {}
for mask_name in mask_names:
print "Working on mask %s" % mask_name
# For decoding, standardizing is often very important
masker = NiftiMasker(mask_img=data_files[mask_name][0], standardize=True)
masked_timecourses = masker.fit_transform(
data_files.func[0])[resting_state == False]
mask_scores[mask_name] = {}
mask_chance_scores[mask_name] = {}
for category in categories:
print "Processing %s %s" % (mask_name, category)
classification_target = stimuli[resting_state == False] == category
mask_scores[mask_name][category] = cross_val_score(
classifier,
masked_timecourses,
classification_target,
cv=cv,
scoring="f1")
plotting.plot_roi(resampled_mask_visual,
title='Visual regions mask extracted from atlas',
cut_coords=(8, -80, 9),
colorbar=True,
cmap='Paired')
###############################################################################
# Define a masker
# ---------------
# We define a nilearn masker that will be used to handle relevant data.
# For more information, visit :
# 'http://nilearn.github.io/manipulating_images/masker_objects.html'
#
from nilearn.input_data import NiftiMasker
roi_masker = NiftiMasker(mask_img=resampled_mask_visual).fit()
###############################################################################
# Prepare the data
# ----------------
# For each subject, for each task and conditions, our dataset contains two
# independent acquisitions, similar except for one acquisition parameter, the
# encoding phase used that was either Antero-Posterior (AP) or
# Postero-Anterior (PA). Although this induces small differences
# in the final data, we will take advantage of these pseudo-duplicates to
# create a training and a testing set that contains roughly the same signals
# but acquired independently.
#
# The training set, used to learn alignment from source subject toward target:
# * source train: AP contrasts for subject sub-01
The reduction process from 4D-images to feature vectors comes with the
loss of spatial structure (see Figure 1). It however allows to discard
uninformative voxels, such as the ones outside of the brain. Such voxels
that only carry noise and scanner artifacts would reduce SNR and affect
the quality of the estimation. The selected voxels form a brain mask.
Such a mask is often given along with the datasets or can be computed
with software tools such as FSL or SPM.
Nifti_masker is used for applying a mask to extract time-series from Niimg-like objects.
NiftiMasker is useful when preprocessing (detrending, standardization, resampling, etc.)
of in-mask voxels is necessary. Use case: working with time series of resting-state or task maps.
"""
nifti_masker = NiftiMasker( # Applying a mask to extract time-series from Niimg-like objects.
smoothing_fwhm=5,
memory='nilearn_cache',
memory_level=1) # cache options
cmap_filenames = localizer_dataset.cmaps
fmri_masked = nifti_masker.fit_transform(cmap_filenames)
# Get Anova (parametric F-scores)
# F regression is a linear model for testing the individual effect of each of many regressors. This is a scoring function to be used in a feature seletion procedure, not a free standing feature selection procedure.
_, pvals_anova = f_regression(
fmri_masked,
tested_var, # Univariate linear regression tests.
center=False) # do not remove intercept
pvals_anova *= fmri_masked.shape[1]
pvals_anova[np.isnan(pvals_anova)] = 1
pvals_anova[pvals_anova > 1] = 1
neg_log_pvals_anova = -np.log10(pvals_anova)
###########################################################################
############################## Scatter plots ##############################
###########################################################################
if 'scatter_plots' in args.analysis[0]:
# retrieve default atlas (= set of ROI)
atlas = datasets.fetch_atlas_harvard_oxford(params.atlas)
labels = atlas['labels']
maps = nilearn.image.load_img(atlas['maps'])
# extract data
for index_mask in range(len(labels) - 1):
mask = math_img('img > 50', img=index_img(maps, index_mask))
masker = NiftiMasker(mask_img=mask,
memory='nilearn_cache',
verbose=5)
masker.fit()
for analysis in analysis_parameters['scatter_plots']:
for subject in subjects:
subject = Subjects().get_subject(int(subject))
model1 = [
os.path.join(
paths.path2derivatives, source,
analysis['input_data_folder1'], language,
analysis['model1_folder'],
analysis['model1'] + '_' + subject + '.nii.gz')
]
model2 = [
os.path.join(
paths.path2derivatives, source,
labels = np.recfromcsv(data.session_target[0], delimiter=" ")
# scikit-learn >= 0.14 supports text labels. You can replace this line by:
# target = labels['labels']
_, target = np.unique(labels['labels'], return_inverse=True)
### Keep only data corresponding to faces or cat ##############################
condition_mask = np.logical_or(labels['labels'] == 'face',
labels['labels'] == 'cat')
target = target[condition_mask]
### Prepare the data: apply the mask ##########################################
from nilearn.input_data import NiftiMasker
# For decoding, standardizing is often very important
nifti_masker = NiftiMasker(mask=data.mask_vt[0], standardize=True)
# We give the nifti_masker a filename and retrieve a 2D array ready
# for machine learning with scikit-learn
fmri_masked = nifti_masker.fit_transform(data.func[0])
# Restrict the classification to the face vs house discrimination
fmri_masked = fmri_masked[condition_mask]
### Prediction ################################################################
# Here we use a Support Vector Classification, with a linear kernel
from sklearn.svm import SVC
svc = SVC(kernel='linear')
behavioral = pd.read_csv(stim, sep="\t")
#grab conditional labels
y = behavioral["Label"]
# In[ ]:
#restrict data to our target analysis
condition_mask = behavioral["Label"].isin(['HF_HS_receipt', "h20_receipt"])
y = y[condition_mask]
#confirm we have the # of condtions needed
print(y.unique())
masker = NiftiMasker(mask_img=imag_mask, standardize=True, memory="nilearn_cache", memory_level=6)
X = masker.fit_transform(dataset)
# Apply our condition_mask
X = X[condition_mask]
from sklearn.svm import SVC
svc = SVC(kernel='linear')
from sklearn.feature_selection import SelectKBest, f_classif
feature_selection = SelectKBest(f_classif, k=500)
# We have our classifier (SVC), our feature selection (SelectKBest), and now,
# we can plug them together in a *pipeline* that performs the two operations
# successively:
from sklearn.pipeline import Pipeline
anova_svc = Pipeline([('anova', feature_selection), ('svc', svc)])
for subject in subject_list:
mask = (df.contrast == contrast).values *\
(df.subject == subject).values *\
(df.acquisition == 'ap')
if len(df[mask]) == 0:
print(subject, contrast)
ap_paths.append(df[mask].path.values[-1])
mask = (df.contrast == contrast).values *\
(df.subject == subject).values *\
(df.acquisition == 'pa')
if len(df[mask]) == 0:
print(subject, contrast)
pa_paths.append(df[mask].path.values[-1])
# image masking
masker = NiftiMasker(
mask_img=mask_gm, memory=write_dir, smoothing_fwhm=None).fit()
X1 = masker.transform(ap_paths).reshape(
n_contrasts, int(n_subjects * n_voxels))
X2 = masker.transform(pa_paths).reshape(
n_contrasts, int(n_subjects * n_voxels))
# learn a dictionary of elements
n_components = 20
alpha = .6
X1[np.isnan(X1)] = 0
X2[np.isnan(X2)] = 0
dictionary1, components_1 = make_dictionary(
X1, n_components=n_components, alpha=alpha, write_dir=write_dir,
contrasts=contrasts, method='multitask', l1_ratio=.25)
dictionary2, components_2 = make_dictionary(
import numpy as np
from scipy import linalg
import matplotlib.pyplot as plt
from nilearn import datasets
from nilearn.input_data import NiftiMasker
n_subjects = 50 # more subjects requires more memory and more time
### Load Oasis dataset ########################################################
oasis_dataset = datasets.fetch_oasis_vbm(n_subjects=n_subjects)
gray_matter_map_filenames = oasis_dataset.gray_matter_maps
age = oasis_dataset.ext_vars['age'].astype(float)
### Preprocess data ###########################################################
nifti_masker = NiftiMasker(standardize=False,
smoothing_fwhm=0,
memory='nilearn_cache') # cache options
# remove features with too low between-subject variance
gm_maps_masked = nifti_masker.fit_transform(gray_matter_map_filenames)
gm_maps_masked[:, gm_maps_masked.var(0) < 0.01] = 0.
# final masking
new_images = nifti_masker.inverse_transform(gm_maps_masked)
gm_maps_masked = nifti_masker.fit_transform(new_images)
n_samples, n_features = gm_maps_masked.shape
print n_samples, "subjects, ", n_features, "features"
### Inference with massively univariate model #################################
from nilearn.mass_univariate import permuted_ols
print "Massively univariate model"
neg_log_pvals, all_scores, _ = permuted_ols(
from nilearn.image import concat_imgs
import joblib
import time
RES_NAME = 'nips3mm_serial'
WRITE_DIR = op.join(os.getcwd(), RES_NAME)
if not op.exists(WRITE_DIR):
os.mkdir(WRITE_DIR)
##############################################################################
# load+preprocess data
##############################################################################
mask_img = 'grey10_icbm_3mm_bin.nii.gz'
nifti_masker = NiftiMasker(mask_img=mask_img,
smoothing_fwhm=False,
standardize=False)
nifti_masker.fit()
mask_nvox = nifti_masker.mask_img_.get_data().sum()
print('Loading data...')
X_task, labels = joblib.load('preload_HT_3mm')
labels = np.int32(labels)
# contrasts are IN ORDER -> shuffle!
new_inds = np.arange(0, X_task.shape[0])
np.random.shuffle(new_inds)
X_task = X_task[new_inds]
y = labels[new_inds]
import matplotlib.pyplot as plt
from nilearn import datasets
from nilearn.input_data import NiftiMasker
from nilearn.image import get_data
############################################################################
# Load Localizer contrast
n_samples = 20
localizer_dataset = datasets.fetch_localizer_calculation_task(
n_subjects=n_samples)
tested_var = np.ones((n_samples, 1))
############################################################################
# Mask data
nifti_masker = NiftiMasker(smoothing_fwhm=5,
memory='nilearn_cache',
memory_level=1) # cache options
cmap_filenames = localizer_dataset.cmaps
fmri_masked = nifti_masker.fit_transform(cmap_filenames)
############################################################################
# Anova (parametric F-scores)
from sklearn.feature_selection import f_regression
_, pvals_anova = f_regression(fmri_masked, tested_var,
center=False) # do not remove intercept
pvals_anova *= fmri_masked.shape[1]
pvals_anova[np.isnan(pvals_anova)] = 1
pvals_anova[pvals_anova > 1] = 1
neg_log_pvals_anova = -np.log10(pvals_anova)
neg_log_pvals_anova_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_anova)
class Simulator:
def __init__(self, brain_mask=None, output_dir=None): # no scoring param
# self.resource_folder = os.path.join(os.getcwd(),'resources')
if output_dir is None:
self.output_dir = os.path.join(os.getcwd())
else:
self.output_dir = output_dir
if isinstance(brain_mask, str):
brain_mask = nib.load(brain_mask)
elif brain_mask is None:
brain_mask = nib.load(resolve_mni_path(MNI_Template)['mask'])
elif ~isinstance(brain_mask, nib.nifti1.Nifti1Image):
raise ValueError(
"brain_mask is not a string or a nibabel instance")
self.brain_mask = brain_mask
self.nifti_masker = NiftiMasker(mask_img=self.brain_mask)
def gaussian(self, mu, sigma, i_tot):
""" create a 3D gaussian signal normalized to a given intensity
Args:
mu: average value of the gaussian signal (usually set to 0)
sigma: standard deviation
i_tot: sum total of activation (numerical integral over the gaussian returns this value)
"""
x, y, z = np.mgrid[0:self.brain_mask.shape[0],
0:self.brain_mask.shape[1],
0:self.brain_mask.shape[2]]
# Need an (N, 3) array of (x, y) pairs.
xyz = np.column_stack([x.flat, y.flat, z.flat])
covariance = np.diag(sigma**2)
g = multivariate_normal.pdf(xyz, mean=mu, cov=covariance)
# Reshape back to a 3D grid.
g = g.reshape(x.shape).astype(float)
# select only the regions within the brain mask
g = np.multiply(self.brain_mask.get_data(), g)
# adjust total intensity of gaussian
g = np.multiply(i_tot / np.sum(g), g)
return g
def sphere(self, r, p):
""" create a sphere of given radius at some point p in the brain mask
Args:
r: radius of the sphere
p: point (in coordinates of the brain mask) of the center of the sphere
"""
dims = self.brain_mask.shape
x, y, z = np.ogrid[-p[0]:dims[0] - p[0], -p[1]:dims[1] - p[1],
-p[2]:dims[2] - p[2]]
mask = x * x + y * y + z * z <= r * r
activation = np.zeros(dims)
activation[mask] = 1
activation = np.multiply(activation, self.brain_mask.get_data())
activation = nib.Nifti1Image(activation, affine=np.eye(4))
# return the 3D numpy matrix of zeros containing the sphere as a region of ones
return activation.get_data()
def normal_noise(self, mu, sigma):
""" produce a normal noise distribution for all all points in the brain mask
Args:
mu: average value of the gaussian signal (usually set to 0)
sigma: standard deviation
"""
self.nifti_masker.fit(self.brain_mask)
vlength = int(np.sum(self.brain_mask.get_data()))
if sigma != 0:
n = np.random.normal(mu, sigma, vlength)
else:
n = [mu] * vlength
m = self.nifti_masker.inverse_transform(n)
# return the 3D numpy matrix of zeros containing the brain mask filled with noise produced over a normal distribution
return m.get_data()
def to_nifti(self, m):
""" convert a numpy matrix to the nifti format and assign to it the brain_mask's affine matrix
Args:
m: the 3D numpy matrix we wish to convert to .nii
"""
if not (type(m) == np.ndarray and len(m.shape) >= 3): # try 4D
# if not (type(m) == np.ndarray and len(m.shape) == 3):
raise ValueError(
"ERROR: need 3D np.ndarray matrix to create the nifti file")
m = m.astype(np.float32)
ni = nib.Nifti1Image(m, affine=self.brain_mask.affine)
return ni
def n_spheres(self, radius, center):
""" generate a set of spheres in the brain mask space
Args:
radius: vector of radius. Will create multiple spheres if len(radius) > 1
centers: a vector of sphere centers of the form [px, py, pz] or [[px1, py1, pz1], ..., [pxn, pyn, pzn]]
"""
# initialize useful values
dims = self.brain_mask.get_data().shape
# Initialize Spheres with options for multiple radii and centers of the spheres (or just an int and a 3D list)
if isinstance(radius, int):
radius = [radius]
if center is None:
center = [[dims[0] / 2, dims[1] / 2, dims[2] / 2] * len(radius)
] # default value for centers
elif isinstance(center, list) and isinstance(center[0],
int) and len(radius) == 1:
centers = [center]
if (type(radius)) is list and (type(center) is
list) and (len(radius) == len(center)):
A = np.zeros_like(self.brain_mask.get_data())
for i in range(len(radius)):
A = np.add(A, self.sphere(radius[i], center[i]))
return A
else:
raise ValueError(
"Data type for sphere or radius(ii) or center(s) not recognized."
)
def create_data(self,
levels,
sigma,
radius=5,
center=None,
reps=1,
output_dir=None):
""" create simulated data with integers
Args:
levels: vector of intensities or class labels
sigma: amount of noise to add
radius: vector of radius. Will create multiple spheres if len(radius) > 1
center: center(s) of sphere(s) of the form [px, py, pz] or [[px1, py1, pz1], ..., [pxn, pyn, pzn]]
reps: number of data repetitions useful for trials or subjects
output_dir: string path of directory to output data. If None, no data will be written
**kwargs: Additional keyword arguments to pass to the prediction algorithm
"""
# Create reps
nlevels = len(levels)
y = levels
rep_id = [1] * len(levels)
for i in range(reps - 1):
y = y + levels
rep_id.extend([i + 2] * nlevels)
# Initialize Spheres with options for multiple radii and centers of the spheres (or just an int and a 3D list)
A = self.n_spheres(radius, center)
# for each intensity
A_list = []
for i in y:
A_list.append(np.multiply(A, i))
# generate a different gaussian noise profile for each mask
mu = 0 # values centered around 0
N_list = []
for i in range(len(y)):
N_list.append(self.normal_noise(mu, sigma))
# add noise and signal together, then convert to nifti files
NF_list = []
for i in range(len(y)):
NF_list.append(self.to_nifti(np.add(N_list[i], A_list[i])))
NF_list = Brain_Data(NF_list)
# Assign variables to object
self.data = NF_list
self.y = pd.DataFrame(data=y)
self.rep_id = pd.DataFrame(data=rep_id)
dat = self.data
dat.Y = self.y
# Write Data to files if requested
if output_dir is not None and isinstance(output_dir, six.string_types):
NF_list.write(os.path.join(output_dir, 'data.nii.gz'))
self.y.to_csv(os.path.join(output_dir, 'y.csv'),
index=None,
header=False)
self.rep_id.to_csv(os.path.join(output_dir, 'rep_id.csv'),
index=None,
header=False)
return dat
def create_cov_data(self,
cor,
cov,
sigma,
mask=None,
reps=1,
n_sub=1,
output_dir=None):
""" create continuous simulated data with covariance
Args:
cor: amount of covariance between each voxel and Y variable
cov: amount of covariance between voxels
sigma: amount of noise to add
radius: vector of radius. Will create multiple spheres if len(radius) > 1
center: center(s) of sphere(s) of the form [px, py, pz] or [[px1, py1, pz1], ..., [pxn, pyn, pzn]]
reps: number of data repetitions
n_sub: number of subjects to simulate
output_dir: string path of directory to output data. If None, no data will be written
**kwargs: Additional keyword arguments to pass to the prediction algorithm
"""
if mask is None:
# Initialize Spheres with options for multiple radii and centers of the spheres (or just an int and a 3D list)
A = self.n_spheres(10, None) # parameters are (radius, center)
mask = nib.Nifti1Image(A.astype(np.float32),
affine=self.brain_mask.affine)
# Create n_reps with cov for each voxel within sphere
# Build covariance matrix with each variable correlated with y amount 'cor' and each other amount 'cov'
flat_sphere = self.nifti_masker.fit_transform(mask)
n_vox = np.sum(flat_sphere == 1)
cov_matrix = np.ones([n_vox + 1, n_vox + 1]) * cov
cov_matrix[0, :] = cor # set covariance with y
cov_matrix[:, 0] = cor # set covariance with all other voxels
np.fill_diagonal(cov_matrix, 1) # set diagonal to 1
mv_sim = np.random.multivariate_normal(np.zeros([n_vox + 1]),
cov_matrix,
size=reps)
print(mv_sim)
y = mv_sim[:, 0]
self.y = y
mv_sim = mv_sim[:, 1:]
new_dat = np.ones([mv_sim.shape[0], flat_sphere.shape[1]])
new_dat[:, np.where(flat_sphere == 1)[1]] = mv_sim
self.data = self.nifti_masker.inverse_transform(
np.add(new_dat,
np.random.standard_normal(size=new_dat.shape) *
sigma)) # add noise scaled by sigma
self.rep_id = [1] * len(y)
if n_sub > 1:
self.y = list(self.y)
for s in range(1, n_sub):
self.data = nib.concat_images(
[
self.data,
self.nifti_masker.inverse_transform(
np.add(
new_dat,
np.random.standard_normal(size=new_dat.shape) *
sigma))
],
axis=3) # add noise scaled by sigma
noise_y = list(y + np.random.randn(len(y)) * sigma)
self.y = self.y + noise_y
self.rep_id = self.rep_id + [s + 1] * len(mv_sim[:, 0])
self.y = np.array(self.y)
# # Old method in 4 D space - much slower
# x,y,z = np.where(A==1)
# cov_matrix = np.ones([len(x)+1,len(x)+1]) * cov
# cov_matrix[0,:] = cor # set covariance with y
# cov_matrix[:,0] = cor # set covariance with all other voxels
# np.fill_diagonal(cov_matrix,1) # set diagonal to 1
# mv_sim = np.random.multivariate_normal(np.zeros([len(x)+1]),cov_matrix, size=reps) # simulate data from multivariate covar
# self.y = mv_sim[:,0]
# mv_sim = mv_sim[:,1:]
# A_4d = np.resize(A,(reps,A.shape[0],A.shape[1],A.shape[2]))
# for i in xrange(len(x)):
# A_4d[:,x[i],y[i],z[i]]=mv_sim[:,i]
# A_4d = np.rollaxis(A_4d,0,4) # reorder shape of matrix so that time is in 4th dimension
# self.data = self.to_nifti(np.add(A_4d,np.random.standard_normal(size=A_4d.shape)*sigma)) # add noise scaled by sigma
# self.rep_id = ??? # need to add this later
# Write Data to files if requested
if output_dir is not None:
if isinstance(output_dir, six.string_types):
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
self.data.to_filename(
os.path.join(
output_dir, 'maskdata_cor' + str(cor) + "_cov" +
str(cov) + '_sigma' + str(sigma) + '.nii.gz'))
y_file = open(os.path.join(output_dir, 'y.csv'), 'wb')
wr = csv.writer(y_file, quoting=csv.QUOTE_ALL)
wr.writerow(self.y)
rep_id_file = open(os.path.join(output_dir, 'rep_id.csv'),
'wb')
wr = csv.writer(rep_id_file, quoting=csv.QUOTE_ALL)
wr.writerow(self.rep_id)
def create_ncov_data(self,
cor,
cov,
sigma,
masks=None,
reps=1,
n_sub=1,
output_dir=None):
""" create continuous simulated data with covariance
Args:
cor: amount of covariance between each voxel and Y variable (an int or a vector)
cov: amount of covariance between voxels (an int or a matrix)
sigma: amount of noise to add
mask: region(s) where we will have activations (list if more than one)
reps: number of data repetitions
n_sub: number of subjects to simulate
output_dir: string path of directory to output data. If None, no data will be written
**kwargs: Additional keyword arguments to pass to the prediction algorithm
"""
if masks is None:
# Initialize Spheres with options for multiple radii and centers of the spheres (or just an int and a 3D list)
A = self.n_spheres(10, None) # parameters are (radius, center)
masks = nib.Nifti1Image(A.astype(np.float32),
affine=self.brain_mask.affine)
if type(masks) is nib.nifti1.Nifti1Image:
masks = [masks]
if type(cor) is float or type(cor) is int:
cor = [cor]
if type(cov) is float or type(cor) is int:
cov = [cov]
if not len(cor) == len(masks):
raise ValueError(
"cor matrix has incompatible dimensions for mask list of length "
+ str(len(masks)))
if not len(cov) == len(masks) or len(masks) == 0 or not len(
cov[0]) == len(masks):
raise ValueError(
"cov matrix has incompatible dimensions for mask list of length "
+ str(len(masks)))
# Create n_reps with cov for each voxel within sphere
# Build covariance matrix with each variable correlated with y amount 'cor' and each other amount 'cov'
flat_masks = self.nifti_masker.fit_transform(masks)
print("Building correlation/covariation matrix...")
n_vox = np.sum(
flat_masks == 1, axis=1
) # this is a list, each entry contains number voxels for given mask
if 0 in n_vox:
raise ValueError(
"one or more processing mask does not fit inside the brain mask"
)
cov_matrix = np.zeros([np.sum(n_vox) + 1,
np.sum(n_vox) + 1]) # one big covariance matrix
for i, nv in enumerate(n_vox):
cstart = np.sum(n_vox[:i]) + 1
cstop = cstart + nv
cov_matrix[0, cstart:cstop] = cor[i] # set covariance with y
cov_matrix[cstart:cstop,
0] = cor[i] # set covariance with all other voxels
for j in range(len(masks)):
rstart = np.sum(n_vox[:j]) + 1
rstop = rstart + nv
cov_matrix[cstart:cstop, rstart:rstop] = cov[i][
j] # set covariance of this mask's voxels with each of other masks
np.fill_diagonal(cov_matrix, 1) # set diagonal to 1
# these operations happen in one vector that we'll later split into the separate regions
print("Generating multivariate normal distribution...")
mv_sim_l = np.random.multivariate_normal(np.zeros([np.sum(n_vox) + 1]),
cov_matrix,
size=reps)
print(mv_sim_l)
self.y = mv_sim_l[:, 0]
mv_sim = mv_sim_l[:, 1:]
new_dats = np.ones([mv_sim.shape[0], flat_masks.shape[1]])
for rep in range(reps):
for mask_i in range(len(masks)):
start = int(np.sum(n_vox[:mask_i]))
stop = int(start + n_vox[mask_i])
print(rep, start, stop)
new_dats[rep, np.where(
flat_masks[mask_i, :] == 1)] = mv_sim[rep, start:stop]
noise = np.random.standard_normal(size=new_dats.shape[1]) * sigma
self.data = self.nifti_masker.inverse_transform(
np.add(new_dats, noise)) # append 3d simulated data to list
self.rep_id = [1] * len(self.y)
print("Generating subject-level noise...")
print("y == " + str(self.y.shape))
if n_sub > 1:
self.y = list(self.y)
y = list(self.y)
for s in range(1, n_sub):
# ask Luke about this new version
noise = np.random.standard_normal(
size=new_dats.shape[1]) * sigma
next_subj = self.nifti_masker.inverse_transform(
np.add(new_dats, noise))
self.data = nib.concat_images([self.data, next_subj], axis=3)
y += list(self.y + np.random.randn(len(self.y)) * sigma)
print("y == " + str(len(y)))
self.rep_id += [s + 1] * len(mv_sim[:, 0])
self.y = np.array(y)
print("Saving to " + str(output_dir))
print("dat == " + str(self.data.shape))
print("y == " + str(self.y.shape))
if output_dir is not None:
if type(output_dir) is str:
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
self.data.to_filename(
os.path.join(
output_dir, 'simulated_data_' + str(sigma) + 'sigma_' +
str(n_sub) + 'subj.nii.gz'))
y_file = open(os.path.join(output_dir, 'y.csv'), 'wb')
wr = csv.writer(y_file, quoting=csv.QUOTE_ALL)
wr.writerow(self.y)
rep_id_file = open(os.path.join(output_dir, 'rep_id.csv'),
'wb')
wr = csv.writer(rep_id_file, quoting=csv.QUOTE_ALL)
wr.writerow(self.rep_id)
from nilearn.input_data import NiftiMasker masker = NiftiMasker() masker.fit(func_file)
## 使用感兴趣区域选择的体素，使得体素数目较少
###############################################
haxby_dataset = datasets.fetch_haxby()
labels = np.recfromcsv(haxby_dataset.session_target[0], delimiter=" ")
target = labels['labels']
# Keep only data corresponding to faces or cats
condition_mask = np.logical_or(labels['labels'] == b'face',
labels['labels'] == b'cat')
#准备好了标签Y
target = target[condition_mask]
#模版文件的路径
mask_filename = haxby_dataset.mask_vt[0]
#加载模版并标准化
nifti_masker = NiftiMasker(mask_img=mask_filename, standardize=True)
func_filename = haxby_dataset.func[0]
fmri_masked = nifti_masker.fit_transform(func_filename)
#准备好了特征
fmri_masked = fmri_masked[condition_mask]
#使用SVM分类和预测
svc = SVC(kernel='linear')
#训练模型
#svc.fit(fmri_masked, target)
#预测
#prediction = svc.predict(fmri_masked)
#使用训练的数据预测结果很可能达到100%；
def map_threshold(stat_img,
mask_img=None,
threshold=.001,
height_control='fpr',
cluster_threshold=0):
""" Threshold the provided map
Parameters
----------
stat_img : Niimg-like object,
statistical image (presumably in z scale)
mask_img : Niimg-like object, optional,
mask image
threshold: float, optional
cluster forming threshold (either a p-value or z-scale value)
height_control: string, optional
false positive control meaning of cluster forming
threshold: 'fpr'|'fdr'|'bonferroni'|'none'
cluster_threshold : float, optional
cluster size threshold
Returns
-------
thresholded_map : Nifti1Image,
the stat_map theresholded at the prescribed voxel- and cluster-level
threshold: float,
the voxel-level threshold used actually
"""
# Masking
if mask_img is None:
masker = NiftiMasker(mask_strategy='background').fit(stat_img)
else:
masker = NiftiMasker(mask_img=mask_img).fit()
stats = np.ravel(masker.transform(stat_img))
n_voxels = np.size(stats)
# Thresholding
if height_control == 'fpr':
z_th = norm.isf(threshold)
elif height_control == 'fdr':
z_th = fdr_threshold(stats, threshold)
elif height_control == 'bonferroni':
z_th = norm.isf(threshold / n_voxels)
else: # Brute-force thresholding
z_th = threshold
stats *= (stats > z_th)
# embed it back to 3D grid
stat_map = masker.inverse_transform(stats).get_data()
# Extract connected components above threshold
label_map, n_labels = label(stat_map > z_th)
labels = label_map[masker.mask_img_.get_data() > 0]
for label_ in range(1, n_labels + 1):
if np.sum(labels == label_) < cluster_threshold:
stats[labels == label_] = 0
return masker.inverse_transform(stats), z_th
def denoise(img_file, tsv_file, out_path, col_names=False, hp_filter=False, lp_filter=False, out_figure_path=False):
nii_ext = '.nii.gz'
FD_thr = [.5]
sc_range = np.arange(-1, 3)
constant = 'constant'
# read in files
img = load_niimg(img_file)
# get file info
img_name = os.path.basename(img.get_filename())
file_base = img_name[0:img_name.find('.')]
save_img_file = pjoin(out_path, file_base + \
'_NR' + nii_ext)
data = img.get_data()
df_orig = pandas.read_csv(tsv_file, '\t', na_values='n/a')
df = copy.deepcopy(df_orig)
Ntrs = df.as_matrix().shape[0]
print('# of TRs: ' + str(Ntrs))
assert (Ntrs == data.shape[len(data.shape) - 1])
# select columns to use as nuisance regressors
if col_names:
df = df[col_names]
str_append = ' [SELECTED regressors in CSV]'
else:
col_names = df.columns.tolist()
str_append = ' [ALL regressors in CSV]'
# fill in missing nuisance values with mean for that variable
for col in df.columns:
if sum(df[col].isnull()) > 0:
print('Filling in ' + str(sum(df[col].isnull())) + ' NaN value for ' + col)
df[col] = df[col].fillna(np.mean(df[col]))
print('# of Confound Regressors: ' + str(len(df.columns)) + str_append)
# implement HP filter in regression
TR = img.header.get_zooms()[-1]
frame_times = np.arange(Ntrs) * TR
if hp_filter:
hp_filter = float(hp_filter)
assert (hp_filter > 0)
period_cutoff = 1. / hp_filter
df = make_first_level_design_matrix(frame_times, period_cut=period_cutoff, add_regs=df.as_matrix(),
add_reg_names=df.columns.tolist())
# fn adds intercept into dm
hp_cols = [col for col in df.columns if 'drift' in col]
print('# of High-pass Filter Regressors: ' + str(len(hp_cols)))
else:
# add in intercept column into data frame
df[constant] = 1
print('No High-pass Filter Applied')
dm = df.as_matrix()
# prep data
data = np.reshape(data, (-1, Ntrs))
data_mean = np.mean(data, axis=1)
Nvox = len(data_mean)
# setup and run regression
model = regression.OLSModel(dm)
results = model.fit(data.T)
if not hp_filter:
results_orig_resid = copy.deepcopy(results.resid) # save for rsquared computation
# apply low-pass filter
if lp_filter:
# input to butterworth fn is time x voxels
low_pass = float(lp_filter)
Fs = 1. / TR
if low_pass >= Fs / 2:
raise ValueError('Low pass filter cutoff if too close to the Nyquist frequency (%s)' % (Fs / 2))
temp_img_file = pjoin(out_path, file_base + \
'_temp' + nii_ext)
temp_img = nb.Nifti1Image(np.reshape(results.resid.T + np.reshape(data_mean, (Nvox, 1)), img.shape).astype('float32'),
img.affine, header=img.header)
temp_img.to_filename(temp_img_file)
results.resid = butterworth(results.resid, sampling_rate=Fs, low_pass=low_pass, high_pass=None)
print('Low-pass Filter Applied: < ' + str(low_pass) + ' Hz')
# add mean back into data
clean_data = results.resid.T + np.reshape(data_mean, (Nvox, 1)) # add mean back into residuals
# save out new data file
print('Saving output file...')
clean_data = np.reshape(clean_data, img.shape).astype('float32')
new_img = nb.Nifti1Image(clean_data, img.affine, header=img.header)
new_img.to_filename(save_img_file)
######### generate Rsquared map for confounds only
if hp_filter:
# first remove low-frequency information from data
hp_cols.append(constant)
model_first = regression.OLSModel(df[hp_cols].as_matrix())
results_first = model_first.fit(data.T)
results_first_resid = copy.deepcopy(results_first.resid)
del results_first, model_first
# compute sst - borrowed from matlab
sst = np.square(np.linalg.norm(results_first_resid -
np.mean(results_first_resid, axis=0), axis=0))
# now regress out 'true' confounds to estimate their Rsquared
nr_cols = [col for col in df.columns if 'drift' not in col]
model_second = regression.OLSModel(df[nr_cols].as_matrix())
results_second = model_second.fit(results_first_resid)
# compute sse - borrowed from matlab
sse = np.square(np.linalg.norm(results_second.resid, axis=0))
del results_second, model_second, results_first_resid
elif not hp_filter:
# compute sst - borrowed from matlab
sst = np.square(np.linalg.norm(data.T -
np.mean(data.T, axis=0), axis=0))
# compute sse - borrowed from matlab
sse = np.square(np.linalg.norm(results_orig_resid, axis=0))
del results_orig_resid
# compute rsquared of nuisance regressors
zero_idx = scipy.logical_and(sst == 0, sse == 0)
sse[zero_idx] = 1
sst[zero_idx] = 1 # would be NaNs - become rsquared = 0
rsquare = 1 - np.true_divide(sse, sst)
rsquare[np.isnan(rsquare)] = 0
######### Visualizing DM & outputs
fontsize = 12
fontsize_title = 14
def_img_size = 8
if not out_figure_path:
out_figure_path = save_img_file[0:save_img_file.find('.')] + '_figures'
if not os.path.isdir(out_figure_path):
os.mkdir(out_figure_path)
png_append = '_' + img_name[0:img_name.find('.')] + '.png'
print('Output directory: ' + out_figure_path)
# DM corr matrix
cm = df[df.columns[0:-1]].corr()
curr_sz = copy.deepcopy(def_img_size)
if cm.shape[0] > def_img_size:
curr_sz = curr_sz + ((cm.shape[0] - curr_sz) * .3)
mtx_scale = curr_sz * 100
mask = np.zeros_like(cm, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
fig, ax = plt.subplots(figsize=(curr_sz, curr_sz))
cmap = sns.diverging_palette(220, 10, as_cmap=True)
sns.heatmap(cm, mask=mask, cmap=cmap, center=0, vmax=cm[cm < 1].max().max(), vmin=cm[cm < 1].min().min(),
square=True, linewidths=.5, cbar_kws={"shrink": .6})
ax.set_xticklabels(ax.get_xticklabels(), rotation=60, ha='right', fontsize=fontsize)
ax.set_yticklabels(cm.columns.tolist(), rotation=-30, va='bottom', fontsize=fontsize)
ax.set_title('Nuisance Corr. Matrix', fontsize=fontsize_title)
plt.tight_layout()
file_corr_matrix = 'Corr_matrix_regressors' + png_append
fig.savefig(pjoin(out_figure_path, file_corr_matrix))
plt.close(fig)
del fig, ax
# DM of Nuisance Regressors (all)
tr_label = 'TR (Volume #)'
fig, ax = plt.subplots(figsize=(curr_sz - 4.1, def_img_size))
x_scale_html = ((curr_sz - 4.1) / def_img_size) * 890
reporting.plot_design_matrix(df, ax=ax)
ax.set_title('Nuisance Design Matrix', fontsize=fontsize_title)
ax.set_xticklabels(ax.get_xticklabels(), rotation=60, ha='right', fontsize=fontsize)
ax.set_yticklabels(ax.get_yticklabels(), fontsize=fontsize)
ax.set_ylabel(tr_label, fontsize=fontsize)
plt.tight_layout()
file_design_matrix = 'Design_matrix' + png_append
fig.savefig(pjoin(out_figure_path, file_design_matrix))
plt.close(fig)
del fig, ax
# FD timeseries plot
FD = 'FD'
poss_names = ['FramewiseDisplacement', FD, 'framewisedisplacement', 'fd']
fd_idx = [df_orig.columns.__contains__(i) for i in poss_names]
if np.sum(fd_idx) > 0:
FD_name = poss_names[fd_idx == True]
if sum(df_orig[FD_name].isnull()) > 0:
df_orig[FD_name] = df_orig[FD_name].fillna(np.mean(df_orig[FD_name]))
y = df_orig[FD_name].as_matrix()
Nremove = []
sc_idx = []
for thr_idx, thr in enumerate(FD_thr):
idx = y >= thr
sc_idx.append(copy.deepcopy(idx))
for iidx in np.where(idx)[0]:
for buffer in sc_range:
curr_idx = iidx + buffer
if curr_idx >= 0 and curr_idx <= len(idx):
sc_idx[thr_idx][curr_idx] = True
Nremove.append(np.sum(sc_idx[thr_idx]))
Nplots = len(FD_thr)
sns.set(font_scale=1.5)
sns.set_style('ticks')
fig, axes = plt.subplots(Nplots, 1, figsize=(def_img_size * 1.5, def_img_size / 2), squeeze=False)
sns.despine()
bound = .4
fd_mean = np.mean(y)
for curr in np.arange(0, Nplots):
axes[curr, 0].plot(y)
axes[curr, 0].plot((-bound, Ntrs + bound), FD_thr[curr] * np.ones((1, 2))[0], '--', color='black')
axes[curr, 0].scatter(np.arange(0, Ntrs), y, s=20)
if Nremove[curr] > 0:
info = scipy.ndimage.measurements.label(sc_idx[curr])
for cluster in np.arange(1, info[1] + 1):
temp = np.where(info[0] == cluster)[0]
axes[curr, 0].axvspan(temp.min() - bound, temp.max() + bound, alpha=.5, color='red')
axes[curr, 0].set_ylabel('Framewise Disp. (' + FD + ')')
axes[curr, 0].set_title(FD + ': ' + str(100 * Nremove[curr] / Ntrs)[0:4]
+ '% of scan (' + str(Nremove[curr]) + ' volumes) would be scrubbed (FD thr.= ' +
str(FD_thr[curr]) + ')')
plt.text(Ntrs + 1, FD_thr[curr] - .01, FD + ' = ' + str(FD_thr[curr]), fontsize=fontsize)
plt.text(Ntrs, fd_mean - .01, 'avg = ' + str(fd_mean), fontsize=fontsize)
axes[curr, 0].set_xlim((-bound, Ntrs + 8))
plt.tight_layout()
axes[curr, 0].set_xlabel(tr_label)
file_fd_plot = FD + '_timeseries' + png_append
fig.savefig(pjoin(out_figure_path, file_fd_plot))
plt.close(fig)
del fig, axes
print(FD + ' timeseries plot saved')
else:
print(FD + ' not found: ' + FD + ' timeseries not plotted')
file_fd_plot = None
# Carpet and DVARS plots - before & after nuisance regression
# need to create mask file to input to DVARS function
mask_file = pjoin(out_figure_path, 'mask_temp.nii.gz')
nifti_masker = NiftiMasker(mask_strategy='epi', standardize=False)
nifti_masker.fit(img)
nifti_masker.mask_img_.to_filename(mask_file)
# create 2 or 3 carpet plots, depending on if LP filter is also applied
Ncarpet = 2
total_sz = int(16)
carpet_scale = 840
y_labels = ['Input (voxels)', 'Output \'cleaned\'']
imgs = [img, new_img]
img_files = [img_file, save_img_file]
color = ['red', 'salmon']
labels = ['input', 'cleaned']
if lp_filter:
Ncarpet = 3
total_sz = int(20)
carpet_scale = carpet_scale * (9/8)
y_labels = ['Input', 'Clean Pre-LP', 'Clean LP']
imgs.insert(1, temp_img)
img_files.insert(1, temp_img_file)
color.insert(1, 'firebrick')
labels.insert(1, 'clean pre-LP')
labels[-1] = 'clean LP'
dvars = []
print('Computing dvars...')
for in_file in img_files:
temp = nac.compute_dvars(in_file=in_file, in_mask=mask_file)[1]
dvars.append(np.hstack((temp.mean(), temp)))
del temp
small_sz = 2
fig = plt.figure(figsize=(def_img_size * 1.5, def_img_size + ((Ncarpet - 2) * 1)))
row_used = 0
if np.sum(fd_idx) > 0: # if FD data is available
row_used = row_used + small_sz
ax0 = plt.subplot2grid((total_sz, 1), (0, 0), rowspan=small_sz)
ax0.plot(y)
ax0.scatter(np.arange(0, Ntrs), y, s=10)
curr = 0
if Nremove[curr] > 0:
info = scipy.ndimage.measurements.label(sc_idx[curr])
for cluster in np.arange(1, info[1] + 1):
temp = np.where(info[0] == cluster)[0]
ax0.axvspan(temp.min() - bound, temp.max() + bound, alpha=.5, color='red')
ax0.set_ylabel(FD)
for side in ["top", "right", "bottom"]:
ax0.spines[side].set_color('none')
ax0.spines[side].set_visible(False)
ax0.set_xticks([])
ax0.set_xlim((-.5, Ntrs - .5))
ax0.spines["left"].set_position(('outward', 10))
ax_d = plt.subplot2grid((total_sz, 1), (row_used, 0), rowspan=small_sz)
for iplot in np.arange(len(dvars)):
ax_d.plot(dvars[iplot], color=color[iplot], label=labels[iplot])
ax_d.set_ylabel('DVARS')
for side in ["top", "right", "bottom"]:
ax_d.spines[side].set_color('none')
ax_d.spines[side].set_visible(False)
ax_d.set_xticks([])
ax_d.set_xlim((-.5, Ntrs - .5))
ax_d.spines["left"].set_position(('outward', 10))
ax_d.legend(fontsize=fontsize - 2)
row_used = row_used + small_sz
st = 0
carpet_each = int((total_sz - row_used) / Ncarpet)
for idx, img_curr in enumerate(imgs):
ax_curr = plt.subplot2grid((total_sz, 1), (row_used + st, 0), rowspan=carpet_each)
fig = plotting.plot_carpet(img_curr, figure=fig, axes=ax_curr)
ax_curr.set_ylabel(y_labels[idx])
for side in ["bottom", "left"]:
ax_curr.spines[side].set_position(('outward', 10))
if idx < len(imgs)-1:
ax_curr.spines["bottom"].set_visible(False)
ax_curr.set_xticklabels('')
ax_curr.set_xlabel('')
st = st + carpet_each
file_carpet_plot = 'Carpet_plots' + png_append
fig.savefig(pjoin(out_figure_path, file_carpet_plot))
plt.close()
del fig, ax0, ax_curr, ax_d, dvars
os.remove(mask_file)
print('Carpet/DVARS plots saved')
if lp_filter:
os.remove(temp_img_file)
del temp_img
# Display T-stat maps for nuisance regressors
# create mean img
img_size = (img.shape[0], img.shape[1], img.shape[2])
mean_img = nb.Nifti1Image(np.reshape(data_mean, img_size), img.affine)
mx = []
for idx, col in enumerate(df.columns):
if not 'drift' in col and not constant in col:
con_vector = np.zeros((1, df.shape[1]))
con_vector[0, idx] = 1
con = results.Tcontrast(con_vector)
mx.append(np.max(np.absolute([con.t.min(), con.t.max()])))
mx = .8 * np.max(mx)
t_png = 'Tstat_'
file_tstat = []
for idx, col in enumerate(df.columns):
if not 'drift' in col and not constant in col:
con_vector = np.zeros((1, df.shape[1]))
con_vector[0, idx] = 1
con = results.Tcontrast(con_vector)
m_img = nb.Nifti1Image(np.reshape(con, img_size), img.affine)
title_str = col + ' Tstat'
fig = plotting.plot_stat_map(m_img, mean_img, threshold=3, colorbar=True, display_mode='z', vmax=mx,
title=title_str,
cut_coords=7)
file_temp = t_png + col + png_append
fig.savefig(pjoin(out_figure_path, file_temp))
file_tstat.append({'name': col, 'file': file_temp})
plt.close()
del fig, file_temp
print(title_str + ' map saved')
# Display R-sq map for nuisance regressors
m_img = nb.Nifti1Image(np.reshape(rsquare, img_size), img.affine)
title_str = 'Nuisance Rsq'
mx = .95 * rsquare.max()
fig = plotting.plot_stat_map(m_img, mean_img, threshold=.2, colorbar=True, display_mode='z', vmax=mx,
title=title_str,
cut_coords=7)
file_rsq_map = 'Rsquared' + png_append
fig.savefig(pjoin(out_figure_path, file_rsq_map))
plt.close()
del fig
print(title_str + ' map saved')
######### html report
templateLoader = jinja2.FileSystemLoader(searchpath="/")
templateEnv = jinja2.Environment(loader=templateLoader)
templateVars = {"img_file": img_file,
"save_img_file": save_img_file,
"Ntrs": Ntrs,
"tsv_file": tsv_file,
"col_names": col_names,
"hp_filter": hp_filter,
"lp_filter": lp_filter,
"file_design_matrix": file_design_matrix,
"file_corr_matrix": file_corr_matrix,
"file_fd_plot": file_fd_plot,
"file_rsq_map": file_rsq_map,
"file_tstat": file_tstat,
"x_scale": x_scale_html,
"mtx_scale": mtx_scale,
"file_carpet_plot": file_carpet_plot,
"carpet_scale": carpet_scale
}
TEMPLATE_FILE = pjoin(os.getcwd(), "report_template.html")
template = templateEnv.get_template(TEMPLATE_FILE)
outputText = template.render(templateVars)
html_file = pjoin(out_figure_path, img_name[0:img_name.find('.')] + '.html')
with open(html_file, "w") as f:
f.write(outputText)
print('')
print('HTML report: ' + html_file)
return new_img
# Restrict to faces and houses
condition_mask = np.logical_or(y == b'face', y == b'house')
y = y[condition_mask]
# We have 2 conditions
n_conditions = np.size(np.unique(y))
#############################################################################
# Prepare the fMRI data
from nilearn.input_data import NiftiMasker
mask_filename = haxby_dataset.mask
# For decoding, standardizing is often very important
nifti_masker = NiftiMasker(mask_img=mask_filename,
sessions=session,
smoothing_fwhm=4,
standardize=True,
memory="nilearn_cache",
memory_level=1)
func_filename = haxby_dataset.func[0]
X = nifti_masker.fit_transform(func_filename)
# Apply our condition_mask
X = X[condition_mask]
session = session[condition_mask]
#############################################################################
# Build the decoder
# Define the prediction function to be used.
# Here we use a Support Vector Classification, with a linear kernel
from sklearn.svm import SVC
svc = SVC(kernel='linear')
def plot_melodic_components(
melodic_dir,
in_file,
tr=None,
out_file="melodic_reportlet.svg",
compress="auto",
report_mask=None,
noise_components_file=None,
):
"""
Plots the spatiotemporal components extracted by FSL MELODIC
from functional MRI data.
Parameters
----------
melodic_dir : str
Path pointing to the outputs of MELODIC
in_file : str
Path pointing to the reference fMRI dataset. This file
will be used to extract the TR value, if the ``tr`` argument
is not set. This file will be used to calculate a mask
if ``report_mask`` is not provided.
tr : float
Repetition time in seconds
out_file : str
Path where the resulting SVG file will be stored
compress : ``'auto'`` or bool
Whether SVG should be compressed. If ``'auto'``, compression
will be executed if dependencies are installed (SVGO)
report_mask : str
Path to a brain mask corresponding to ``in_file``
noise_components_file : str
A CSV file listing the indexes of components classified as noise
by some manual or automated (e.g. ICA-AROMA) procedure. If a
``noise_components_file`` is provided, then components will be
plotted with red/green colors (correspondingly to whether they
are in the file -noise components, red-, or not -signal, green-).
When all or none of the components are in the file, a warning
is printed at the top.
"""
from nilearn.image import index_img, iter_img
import nibabel as nb
import numpy as np
import pylab as plt
import seaborn as sns
from matplotlib.gridspec import GridSpec
import os
sns.set_style("white")
current_palette = sns.color_palette()
in_nii = nb.load(in_file)
if not tr:
tr = in_nii.header.get_zooms()[3]
units = in_nii.header.get_xyzt_units()
if units:
if units[-1] == "msec":
tr = tr / 1000.0
elif units[-1] == "usec":
tr = tr / 1000000.0
elif units[-1] != "sec":
NIWORKFLOWS_LOG.warning("Unknown repetition time units "
"specified - assuming seconds")
else:
NIWORKFLOWS_LOG.warning(
"Repetition time units not specified - assuming seconds")
from nilearn.input_data import NiftiMasker
from nilearn.plotting import cm
if not report_mask:
nifti_masker = NiftiMasker(mask_strategy="epi")
nifti_masker.fit(index_img(in_nii, range(2)))
mask_img = nifti_masker.mask_img_
else:
mask_img = nb.load(report_mask)
mask_sl = []
for j in range(3):
mask_sl.append(transform_to_2d(mask_img.get_fdata(), j))
timeseries = np.loadtxt(os.path.join(melodic_dir, "melodic_mix"))
power = np.loadtxt(os.path.join(melodic_dir, "melodic_FTmix"))
stats = np.loadtxt(os.path.join(melodic_dir, "melodic_ICstats"))
n_components = stats.shape[0]
Fs = 1.0 / tr
Ny = Fs / 2
f = Ny * (np.array(list(range(1, power.shape[0] + 1)))) / (power.shape[0])
# Set default colors
color_title = "k"
color_time = current_palette[0]
color_power = current_palette[1]
classified_colors = None
warning_row = 0 # Do not allocate warning row
# Only if the components file has been provided, a warning banner will
# be issued if all or none of the components were classified as noise
if noise_components_file:
noise_components = np.loadtxt(noise_components_file,
dtype=int,
delimiter=",",
ndmin=1)
# Activate warning row if pertinent
warning_row = int(noise_components.size in (0, n_components))
classified_colors = {True: "r", False: "g"}
n_rows = int((n_components + (n_components % 2)) / 2)
fig = plt.figure(figsize=(6.5 * 1.5, (n_rows + warning_row) * 0.85))
gs = GridSpec(
n_rows * 2 + warning_row,
9,
width_ratios=[1, 1, 1, 4, 0.001, 1, 1, 1, 4],
height_ratios=[5] * warning_row + [1.1, 1] * n_rows,
)
if warning_row:
ax = fig.add_subplot(gs[0, :])
ncomps = "NONE of the"
if noise_components.size == n_components:
ncomps = "ALL"
ax.annotate(
"WARNING: {} components were classified as noise".format(ncomps),
xy=(0.0, 0.5),
xycoords="axes fraction",
xytext=(0.01, 0.5),
textcoords="axes fraction",
size=12,
color="#ea8800",
bbox=dict(boxstyle="round", fc="#f7dcb7", ec="#FC990E"),
)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
titlefmt = "C{id:d}{noise}: Tot. var. expl. {var:.2g}%".format
for i, img in enumerate(
iter_img(os.path.join(melodic_dir, "melodic_IC.nii.gz"))):
col = i % 2
row = i // 2
l_row = row * 2 + warning_row
is_noise = False
if classified_colors:
# If a noise components list is provided, assign red/green
is_noise = (i + 1) in noise_components
color_title = color_time = color_power = classified_colors[
is_noise]
data = img.get_fdata()
for j in range(3):
ax1 = fig.add_subplot(gs[l_row:l_row + 2, j + col * 5])
sl = transform_to_2d(data, j)
m = np.abs(sl).max()
ax1.imshow(sl,
vmin=-m,
vmax=+m,
cmap=cm.cold_white_hot,
interpolation="nearest")
ax1.contour(mask_sl[j], levels=[0.5], colors="k", linewidths=0.5)
plt.axis("off")
ax1.autoscale_view("tight")
if j == 0:
ax1.set_title(
titlefmt(id=i + 1,
noise=" [noise]" * is_noise,
var=stats[i, 1]),
x=0,
y=1.18,
fontsize=7,
horizontalalignment="left",
verticalalignment="top",
color=color_title,
)
ax2 = fig.add_subplot(gs[l_row, 3 + col * 5])
ax3 = fig.add_subplot(gs[l_row + 1, 3 + col * 5])
ax2.plot(
np.arange(len(timeseries[:, i])) * tr,
timeseries[:, i],
linewidth=min(200 / len(timeseries[:, i]), 1.0),
color=color_time,
)
ax2.set_xlim([0, len(timeseries[:, i]) * tr])
ax2.axes.get_yaxis().set_visible(False)
ax2.autoscale_view("tight")
ax2.tick_params(axis="both", which="major", pad=0)
sns.despine(left=True, bottom=True)
for tick in ax2.xaxis.get_major_ticks():
tick.label.set_fontsize(6)
tick.label.set_color(color_time)
ax3.plot(
f[0:],
power[0:, i],
color=color_power,
linewidth=min(100 / len(power[0:, i]), 1.0),
)
ax3.set_xlim([f[0], f.max()])
ax3.axes.get_yaxis().set_visible(False)
ax3.autoscale_view("tight")
ax3.tick_params(axis="both", which="major", pad=0)
for tick in ax3.xaxis.get_major_ticks():
tick.label.set_fontsize(6)
tick.label.set_color(color_power)
sns.despine(left=True, bottom=True)
plt.subplots_adjust(hspace=0.5)
fig.savefig(
out_file,
dpi=300,
format="svg",
transparent=True,
bbox_inches="tight",
pad_inches=0.01,
)
fig.clf()
#Retrieve the behavioral targets, that we are going to predict in the decoding
y_mask = labels['labels']
subs = labels['subs']
# ---STEP 3---
#feature selection
#To keep only data corresponding to app food or unapp food, we create a mask of the samples belonging to the condition.
condition_mask = np.logical_or(y_mask == b'app',y_mask == b'unapp')
print(condition_mask.shape)
y = y_mask[condition_mask]
print(y)
n_conditions = np.size(np.unique(y))
#prepare the fxnl data. CHANGED IMAG_MASK TO IMG_MASK_NI1. CAN ONLY TAKE NIFTI1?
nifti_masker = NiftiMasker(mask_img=img_mask_ni1,
smoothing_fwhm=4,standardize=True,
memory="nilearn_cache",memory_level=1)
fmri_trans = nifti_masker.fit_transform(fmri_subjs)
print(fmri_trans)
X = fmri_trans[condition_mask]
subs = subs[condition_mask]
# ---STEP 4---
#setting prediction & testing the classifer
svc = SVC(kernel='linear')
print(svc)
# Define the dimension reduction to be used.
# Here we use a classical univariate feature selection based on F-test, namely Anova. We set the number of features to be selected to 500
def p_roi_masking(substitution, ts_file_template, beta_file_template,
p_file_template, design_file_template, event_file_template,
p_level, brain_mask):
"""Apply a substitution pattern to timecourse, beta, and design file templates - and mask the data of the former two according to a roi. Subsequently scale the design by the mean beta.
Parameters
----------
substitution : dict
A dictionary containing the template replacement fields as keys and identifiers as values.
ts_file_template : string
Timecourse file template with replacement fields. The file should be in NIfTI format.
beta_file_template : string
Beta file template with replacement fields. The file should be in NIfTI format.
design_file_template : string
Design file template with replacement fields. The file should be in CSV format.
roi_path : string
Path to the region of interest file based on which to create a mask for the time course and beta files. The file should be in NIfTI format.
brain_mask : string
Path to the a mask file in the *exact same* coordinate space as the input image. This is very important, as the mask is needed to crop out artefactual p=0 values. These cannot just be filtered out nummerically, since it is possible that the GLM resturns p=0 for the most significant results.
Returns
-------
timecourse : array_like
Numpy array containing the mean timecourse in the region of interest.
design : array_like
Numpy array containing the regressor scaled by the mean beta value of the region of interest..
mask_map : data
Nibabel image of the mask
subplot_title : string
Title for the subplot, computed from the substitution fields.
"""
ts_file = path.abspath(
path.expanduser(ts_file_template.format(**substitution)))
beta_file = path.abspath(
path.expanduser(beta_file_template.format(**substitution)))
p_file = path.abspath(
path.expanduser(p_file_template.format(**substitution)))
design_file = path.abspath(
path.expanduser(design_file_template.format(**substitution)))
event_file = path.abspath(
path.expanduser(event_file_template.format(**substitution)))
brain_mask = path.abspath(path.expanduser(brain_mask))
try:
img = nib.load(p_file)
brain_mask = nib.load(brain_mask)
except (FileNotFoundError, nib.py3k.FileNotFoundError):
return None, None, None, None, None
data = img.get_data()
brain_mask = brain_mask.get_data()
header = img.header
affine = img.affine
shape = data.shape
data = data.flatten()
brain_mask = brain_mask.flatten()
brain_mask = brain_mask.astype(bool)
brain_data = data[brain_mask]
reject, nonzero_data, _, _ = multipletests(brain_data,
p_level,
method="fdr_bh")
brain_mask[brain_mask] = reject
brain_mask = brain_mask.astype(int)
mask = brain_mask.reshape(shape)
mask_map = nib.Nifti1Image(mask, affine, header)
masker = NiftiMasker(mask_img=mask_map)
try:
timecourse = masker.fit_transform(ts_file).T
betas = masker.fit_transform(beta_file).T
except ValueError:
return None, None, None, None, None
subplot_title = "\n ".join(
[str(substitution["subject"]),
str(substitution["session"])])
timecourse = np.mean(timecourse, axis=0)
design = pd.read_csv(design_file,
skiprows=5,
sep="\t",
header=None,
index_col=False)
design = design * np.mean(betas)
event_df = pd.read_csv(event_file, sep="\t")
return timecourse, design, mask_map, event_df, subplot_title
def fit(self, run_imgs, events=None, confounds=None, design_matrices=None):
""" Fit the GLM
For each run:
1. create design matrix X
2. do a masker job: fMRI_data -> Y
3. fit regression to (Y, X)
Parameters
----------
run_imgs: Niimg-like object or list of Niimg-like objects,
See http://nilearn.github.io/manipulating_images/input_output.html#inputing-data-file-names-or-image-objects
Data on which the GLM will be fitted. If this is a list,
the affine is considered the same for all.
events: pandas Dataframe or string or list of pandas DataFrames or
strings
fMRI events used to build design matrices. One events object
expected per run_img. Ignored in case designs is not None.
If string, then a path to a csv file is expected.
confounds: pandas Dataframe or string or list of pandas DataFrames or
strings
Each column in a DataFrame corresponds to a confound variable
to be included in the regression model of the respective run_img.
The number of rows must match the number of volumes in the
respective run_img. Ignored in case designs is not None.
If string, then a path to a csv file is expected.
design_matrices: pandas DataFrame or list of pandas DataFrames,
Design matrices that will be used to fit the GLM. If given it
takes precedence over events and confounds.
"""
# Check arguments
# Check imgs type
if events is not None:
_check_events_file_uses_tab_separators(events_files=events)
if not isinstance(run_imgs, (list, tuple)):
run_imgs = [run_imgs]
if design_matrices is None:
if events is None:
raise ValueError('events or design matrices must be provided')
if self.t_r is None:
raise ValueError('t_r not given to FirstLevelModel object'
' to compute design from events')
else:
design_matrices = _check_run_tables(run_imgs, design_matrices,
'design_matrices')
# Check that number of events and confound files match number of runs
# Also check that events and confound files can be loaded as DataFrame
if events is not None:
events = _check_run_tables(run_imgs, events, 'events')
if confounds is not None:
confounds = _check_run_tables(run_imgs, confounds, 'confounds')
# Learn the mask
if self.mask_img is False:
# We create a dummy mask to preserve functionality of api
ref_img = check_niimg(run_imgs[0])
self.mask_img = Nifti1Image(np.ones(ref_img.shape[:3]),
ref_img.affine)
if not isinstance(self.mask_img, NiftiMasker):
self.masker_ = NiftiMasker(mask_img=self.mask_img,
smoothing_fwhm=self.smoothing_fwhm,
target_affine=self.target_affine,
standardize=self.standardize,
mask_strategy='epi',
t_r=self.t_r,
memory=self.memory,
verbose=max(0, self.verbose - 2),
target_shape=self.target_shape,
memory_level=self.memory_level)
self.masker_.fit(run_imgs[0])
else:
if self.mask_img.mask_img_ is None and self.masker_ is None:
self.masker_ = clone(self.mask_img)
for param_name in [
'target_affine', 'target_shape', 'smoothing_fwhm',
't_r', 'memory', 'memory_level'
]:
our_param = getattr(self, param_name)
if our_param is None:
continue
if getattr(self.masker_, param_name) is not None:
warn('Parameter %s of the masker'
' overriden' % param_name)
setattr(self.masker_, param_name, our_param)
self.masker_.fit(run_imgs[0])
else:
self.masker_ = self.mask_img
# For each run fit the model and keep only the regression results.
self.labels_, self.results_, self.design_matrices_ = [], [], []
n_runs = len(run_imgs)
t0 = time.time()
for run_idx, run_img in enumerate(run_imgs):
# Report progress
if self.verbose > 0:
percent = float(run_idx) / n_runs
percent = round(percent * 100, 2)
dt = time.time() - t0
# We use a max to avoid a division by zero
if run_idx == 0:
remaining = 'go take a coffee, a big one'
else:
remaining = (100. - percent) / max(0.01, percent) * dt
remaining = '%i seconds remaining' % remaining
sys.stderr.write("Computing run %d out of %d runs (%s)\n" %
(run_idx + 1, n_runs, remaining))
# Build the experimental design for the glm
run_img = check_niimg(run_img, ensure_ndim=4)
if design_matrices is None:
n_scans = run_img.get_data().shape[3]
if confounds is not None:
confounds_matrix = confounds[run_idx].values
if confounds_matrix.shape[0] != n_scans:
raise ValueError('Rows in confounds does not match'
'n_scans in run_img at index %d' %
(run_idx, ))
confounds_names = confounds[run_idx].columns.tolist()
else:
confounds_matrix = None
confounds_names = None
start_time = self.slice_time_ref * self.t_r
end_time = (n_scans - 1 + self.slice_time_ref) * self.t_r
frame_times = np.linspace(start_time, end_time, n_scans)
design = make_first_level_design_matrix(
frame_times, events[run_idx], self.hrf_model,
self.drift_model, self.high_pass, self.drift_order,
self.fir_delays, confounds_matrix, confounds_names,
self.min_onset)
else:
design = design_matrices[run_idx]
self.design_matrices_.append(design)
# Mask and prepare data for GLM
if self.verbose > 1:
t_masking = time.time()
sys.stderr.write('Starting masker computation \r')
Y = self.masker_.transform(run_img)
if self.verbose > 1:
t_masking = time.time() - t_masking
sys.stderr.write('Masker took %d seconds \n' % t_masking)
if self.signal_scaling:
Y, _ = mean_scaling(Y, self.scaling_axis)
if self.memory:
mem_glm = self.memory.cache(run_glm, ignore=['n_jobs'])
else:
mem_glm = run_glm
# compute GLM
if self.verbose > 1:
t_glm = time.time()
sys.stderr.write('Performing GLM computation\r')
labels, results = mem_glm(Y,
design.values,
noise_model=self.noise_model,
bins=100,
n_jobs=self.n_jobs)
if self.verbose > 1:
t_glm = time.time() - t_glm
sys.stderr.write('GLM took %d seconds \n' % t_glm)
self.labels_.append(labels)
# We save memory if inspecting model details is not necessary
if self.minimize_memory:
for key in results:
results[key] = SimpleRegressionResults(results[key])
self.results_.append(results)
del Y
# Report progress
if self.verbose > 0:
sys.stderr.write(
"\nComputation of %d runs done in %i seconds\n\n" %
(n_runs, time.time() - t0))
return self
# on a homogeneous background
# Load Miyawaki dataset
from nilearn import datasets
miyawaki_dataset = datasets.fetch_miyawaki2008()
# print basic information on the dataset
print('First functional nifti image (4D) is located at: %s' %
miyawaki_dataset.func[0]) # 4D data
miyawaki_filename = miyawaki_dataset.func[0]
miyawaki_mean_img = image.mean_img(miyawaki_filename)
plot_epi(miyawaki_mean_img, title='Mean EPI image')
###############################################################################
# A NiftiMasker with the default strategy
masker = NiftiMasker()
masker.fit(miyawaki_filename)
# Plot the generated mask using the mask_img_ attribute
plot_roi(masker.mask_img_,
miyawaki_mean_img,
title="Mask from already masked data")
###############################################################################
# Plot the generated mask using the .generate_report method
report = masker.generate_report()
report
###############################################################################
# Computing a mask from raw EPI data
###############################################################################
dim=0, # title=subject,
colorbar=False,
view_type='filled_contours',
linewidths=2.)
axes.axis('off')
fig.savefig(os.path.join(write_dir, 'snapshot_%s.pdf' % name),
facecolor='k',
dpi=300)
# plt.close(fig)
db = data_parser(derivatives=SMOOTH_DERIVATIVES, conditions=CONTRASTS)
# db = db[db.task.isin(task_list)]
mask_gm = nib.load(os.path.join(DERIVATIVES, 'group', 'anat',
'gm_mask.nii.gz'))
masker = NiftiMasker(mask_img=mask_gm, memory=mem).fit()
write_dir = 'output'
if not os.path.exists(write_dir):
os.mkdir(write_dir)
"""
task_contrast = [('ArchiSocial', 'false_belief-mechanistic_video'),
('ArchiSocial', 'false_belief-mechanistic_audio'),
('ArchiSocial', 'triangle_mental-random'),
('hcp_social', 'mental-random')]
plot_contrasts(db, task_contrast, masker, write_dir, cut=-50, display_mode='x',
name='social')
#plot_contrasts(db, task_contrast, masker, write_dir, cut=20, display_mode='z')
task_contrast = [('HcpWm', 'body-avg'),
('HcpWm', 'face-avg'),
def plot_melodic_components(melodic_dir,
in_file,
tr=None,
out_file='melodic_reportlet.svg',
compress='auto',
report_mask=None,
noise_components_file=None):
from nilearn.image import index_img, iter_img
import nibabel as nb
import numpy as np
import seaborn as sns
from matplotlib.gridspec import GridSpec
import os
import re
from io import StringIO
sns.set_style("white")
current_palette = sns.color_palette()
in_nii = nb.load(in_file)
if not tr:
tr = in_nii.header.get_zooms()[3]
units = in_nii.header.get_xyzt_units()
if units:
if units[-1] == 'msec':
tr = tr / 1000.0
elif units[-1] == 'usec':
tr = tr / 1000000.0
elif units[-1] != 'sec':
NIWORKFLOWS_LOG.warning('Unknown repetition time units '
'specified - assuming seconds')
else:
NIWORKFLOWS_LOG.warning(
'Repetition time units not specified - assuming seconds')
from nilearn.input_data import NiftiMasker
from nilearn.plotting import cm
if not report_mask:
nifti_masker = NiftiMasker(mask_strategy='epi')
nifti_masker.fit(index_img(in_nii, range(2)))
mask_img = nifti_masker.mask_img_
else:
mask_img = nb.load(report_mask)
mask_sl = []
for j in range(3):
mask_sl.append(transform_to_2d(mask_img.get_data(), j))
timeseries = np.loadtxt(os.path.join(melodic_dir, "melodic_mix"))
power = np.loadtxt(os.path.join(melodic_dir, "melodic_FTmix"))
stats = np.loadtxt(os.path.join(melodic_dir, "melodic_ICstats"))
n_components = stats.shape[0]
Fs = 1.0 / tr
Ny = Fs / 2
f = Ny * (np.array(list(range(1, power.shape[0] + 1)))) / (power.shape[0])
n_rows = int((n_components + (n_components % 2)) / 2)
fig = plt.figure(figsize=(6.5 * 1.5, n_rows * 0.85))
gs = GridSpec(n_rows * 2,
9,
width_ratios=[
1,
1,
1,
4,
0.001,
1,
1,
1,
4,
],
height_ratios=[1.1, 1] * n_rows)
noise_components = None
if noise_components_file:
noise_components = np.loadtxt(noise_components_file,
dtype=int,
delimiter=',',
ndmin=1)
for i, img in enumerate(
iter_img(os.path.join(melodic_dir, "melodic_IC.nii.gz"))):
col = i % 2
row = int(i / 2)
l_row = row * 2
# Set default colors
color_title = 'k'
color_time = current_palette[0]
color_power = current_palette[1]
if noise_components is not None and noise_components.size > 0:
# If a noise components list is provided, assign red/green
color_title = color_time = color_power = ('r' if (
i + 1) in noise_components else 'g')
data = img.get_data()
for j in range(3):
ax1 = fig.add_subplot(gs[l_row:l_row + 2, j + col * 5])
sl = transform_to_2d(data, j)
m = np.abs(sl).max()
ax1.imshow(sl,
vmin=-m,
vmax=+m,
cmap=cm.cold_white_hot,
interpolation="nearest")
ax1.contour(mask_sl[j], levels=[0.5], colors='k', linewidths=0.5)
plt.axis("off")
ax1.autoscale_view('tight')
if j == 0:
ax1.set_title("C%d: Tot. var. expl. %.2g%%" %
(i + 1, stats[i, 1]),
x=0,
y=1.18,
fontsize=7,
horizontalalignment='left',
verticalalignment='top',
color=color_title)
ax2 = fig.add_subplot(gs[l_row, 3 + col * 5])
ax3 = fig.add_subplot(gs[l_row + 1, 3 + col * 5])
ax2.plot(np.arange(len(timeseries[:, i])) * tr,
timeseries[:, i],
linewidth=min(200 / len(timeseries[:, i]), 1.0),
color=color_time)
ax2.set_xlim([0, len(timeseries[:, i]) * tr])
ax2.axes.get_yaxis().set_visible(False)
ax2.autoscale_view('tight')
ax2.tick_params(axis='both', which='major', pad=0)
sns.despine(left=True, bottom=True)
for tick in ax2.xaxis.get_major_ticks():
tick.label.set_fontsize(6)
tick.label.set_color(color_time)
ax3.plot(f[0:],
power[0:, i],
color=color_power,
linewidth=min(100 / len(power[0:, i]), 1.0))
ax3.set_xlim([f[0], f.max()])
ax3.axes.get_yaxis().set_visible(False)
ax3.autoscale_view('tight')
ax3.tick_params(axis='both', which='major', pad=0)
for tick in ax3.xaxis.get_major_ticks():
tick.label.set_fontsize(6)
tick.label.set_color(color_power)
sns.despine(left=True, bottom=True)
plt.subplots_adjust(hspace=0.5)
image_buf = StringIO()
fig.savefig(image_buf,
dpi=300,
format='svg',
transparent=True,
bbox_inches='tight',
pad_inches=0.01)
fig.clf()
image_svg = image_buf.getvalue()
if compress is True or compress == 'auto':
image_svg = svg_compress(image_svg, compress)
image_svg = re.sub(' height="[0-9]+[a-z]*"', '', image_svg, count=1)
image_svg = re.sub(' width="[0-9]+[a-z]*"', '', image_svg, count=1)
image_svg = re.sub(' viewBox',
' preseveAspectRation="xMidYMid meet" viewBox',
image_svg,
count=1)
with open(out_file, 'w' if PY3 else 'wb') as f:
f.write(image_svg)
def roi_masking(substitution, ts_file_template, beta_file_template,
design_file_template, event_file_template, roi):
"""Apply a substitution pattern to timecourse, beta, and design file templates - and mask the data of the former two according to a roi. Subsequently scale the design by the mean beta.
Parameters
----------
substitution : dict
A dictionary containing the template replacement fields as keys and identifiers as values.
ts_file_template : string
Timecourse file template with replacement fields. The file should be in NIfTI format.
beta_file_template : string
Beta file template with replacement fields. The file should be in NIfTI format.
design_file_template : string
Design file template with replacement fields. The file should be in CSV format.
roi_path : string
Path to the region of interest file based on which to create a mask for the time course and beta files. The file should be in NIfTI format.
Returns
-------
timecourse : array_like
Numpy array containing the mean timecourse in the region of interest.
design : array_like
Numpy array containing the regressor scaled by the mean beta value of the region of interest..
mask_map : data
Nibabel image of the mask
subplot_title : string
Title for the subplot, computed from the substitution fields.
"""
ts_file = path.expanduser(ts_file_template.format(**substitution))
beta_file = path.expanduser(beta_file_template.format(**substitution))
design_file = path.expanduser(design_file_template.format(**substitution))
event_file = path.expanduser(event_file_template.format(**substitution))
masker = NiftiMasker(mask_img=roi)
if isinstance(roi, str):
mask_map = nib.load(roi)
else:
mask_map = roi
try:
timecourse = masker.fit_transform(ts_file).T
betas = masker.fit_transform(beta_file).T
design = pd.read_csv(design_file,
skiprows=5,
sep="\t",
header=None,
index_col=False)
event_df = pd.read_csv(event_file, sep="\t")
except ValueError:
print('Not found', ts_file, beta_file, design_file, event_file)
return None, None, None, None, None
subplot_title = "Subject {} | Session {}".format(
str(substitution["subject"]), str(substitution["session"]))
timecourse = np.mean(timecourse, axis=0)
design = design * np.mean(betas)
return timecourse, design, mask_map, event_df, subplot_title
#To keep only data corresponding to app food or unapp food, we create a mask of the samples belonging to the condition.
condition_mask = func_df["labels"].isin(['rest', 'app'])
#condition_mask = func_df["labels"].isin(['app', 'unapp', 'H2O'])
print(condition_mask.shape)
#y = y_mask[condition_mask]
y = y_mask[condition_mask]
print(y.shape)
n_conditions = np.size(np.unique(y))
print(n_conditions)
#n_conditions = np.size(np.unique(y))
print(y.unique())
#session = func_df[condition_mask].to_records(index=False)
#print(session.dtype.name)
nifti_masker = NiftiMasker(mask_img=imag_mask,
smoothing_fwhm=4,
standardize=True,
memory_level=0)
fmri_trans = nifti_masker.fit_transform(fmri_subjs)
print(fmri_trans)
X = fmri_trans[condition_mask]
subs = subs[condition_mask]
svc = SVC()
svc = SVC(kernel='linear', verbose=False)
print(svc)
from sklearn.feature_selection import SelectPercentile, f_classif
#feature_selection = SelectPercentile(f_classif, percentile=10)
feature_selection = SelectKBest(f_classif, k=1500)
np.warnings.filterwarnings('ignore')
anova_svc = Pipeline([('anova', feature_selection), ('svc', svc)])