def generate_fmri_data_for_subject(subject):
"""
Input : Take as input each fmri file. One file = One block
Load all fmri data and apply a global mask mak on it. The global mask is computed using the mask from each fmri run (block).
Applying a global mask for a subject uniformize the data.
Output: Output fmri_runs for a subject, corrected using a global mask
"""
fmri_filenames = sorted(
glob.glob(
os.path.join(paths.rootpath, "fmri-data/en", "sub-%03d" % subject,
"func", "resample*.nii")))
masks_filenames = sorted(
glob.glob(
os.path.join(paths.path2Data, "en/fmri_data/masks",
"sub_{}".format(subject), "resample*.pkl")))
masks = []
for file in masks_filenames:
with open(file, 'rb') as f:
mask = pickle.load(f)
masks.append(mask)
global_mask = math_img('img>0.5', img=mean_img(masks))
masker = MultiNiftiMasker(global_mask, detrend=True, standardize=True)
masker.fit()
fmri_runs = [masker.transform(f) for f in tqdm(fmri_filenames)]
print(fmri_runs[0].shape)
return fmri_runs
def glass_brain(r2_voxels, subject, current_ROI, ROI_name, name):
"""
Input : Masked results of r2score
Take masked data and project it again in a 3D space
Ouput : 3D glassbrain of r2score
"""
# Get one mask and fit it to the corresponding ROI
if current_ROI != -1 and current_ROI <= 5:
masks_ROIs_filenames = sorted(
glob.glob(os.path.join(paths.path2Data, "en/ROIs_masks/",
"*.nii")))
ROI_mask = masks_ROIs_filenames[current_ROI]
ROI_mask = NiftiMasker(ROI_mask, detrend=True, standardize=True)
ROI_mask.fit()
unmasked_data = ROI_mask.inverse_transform(r2_voxels)
# Get masks and fit a global mask
else:
masks = []
masks_filenames = sorted(
glob.glob(
os.path.join(paths.path2Data, "en/fmri_data/masks",
"sub_{}".format(subject), "resample*.pkl")))
for file in masks_filenames:
with open(file, 'rb') as f:
mask = pickle.load(f)
masks.append(mask)
global_mask = math_img('img>0.5', img=mean_img(masks))
masker = MultiNiftiMasker(global_mask, detrend=True, standardize=True)
masker.fit()
unmasked_data = masker.inverse_transform(r2_voxels)
display = plot_glass_brain(unmasked_data,
display_mode='lzry',
threshold='auto',
colorbar=True,
title='Sub_{}'.format(subject))
if not os.path.exists(
os.path.join(paths.path2Figures, 'glass_brain',
'Sub_{}'.format(subject), ROI_name)):
os.makedirs(
os.path.join(paths.path2Figures, 'glass_brain',
'Sub_{}'.format(subject), ROI_name))
display.savefig(
os.path.join(paths.path2Figures, 'glass_brain',
'Sub_{}'.format(subject), ROI_name,
'R_squared_test_{}.png'.format(name)))
print(
'Figure Path : ',
os.path.join(paths.path2Figures, 'glass_brain',
'Sub_{}'.format(subject), ROI_name,
'R_squared_test_{}.png'.format(name)))
display.close()
def compute_global_masker(rootdir, subjects):
# masks = [compute_epi_mask(glob.glob(op.join(rootdir, "fmri-data/en", "sub-%03d" % s, "func","*.nii"))) for s in subjects]
# global_mask = math_img('img>0.5', img=mean_img(masks))
# masker = MultiNiftiMasker(global_mask, detrend=True, standardize=True, memory='/volatile/tmp')
masker = MultiNiftiMasker(mask_img=op.join(
rootdir, "lpp-scripts3/inputs/ROIs/mask_ICV.nii"),
detrend=True,
standardize=True)
masker.fit()
return masker
def compute_all_subjects_mask():
""" Computes the mask of all the subjects and the sesssions
"""
masker = MultiNiftiMasker(mask_strategy='epi', memory=CACHE_DIR,
memory_level=2, n_jobs=10, verbose=5)
imgs = dataset.func1 + dataset.func2
masker.fit(imgs)
masker.mask_img_.to_filename('all_subjects.nii.gz')
plot_roi(masker.mask_img_)
def compute_global_masker(files): # [[path, path2], [path3, path4]]
# return a MultiNiftiMasker object
masks = [compute_epi_mask(f) for f in files]
global_mask = math_img(
'img>0.5',
img=mean_img(masks)) # take the average mask and threshold at 0.5
masker = MultiNiftiMasker(
global_mask, detrend=True, standardize=True
) # return a object that transforms a 4D barin into a 2D matrix of voxel-time and can do the reverse action
masker.fit()
return masker
def compute_global_masker(rootdir, subjects):
masks = [
compute_epi_mask(
glob.glob(
os.path.join(rootdir, "fmri-data/en", "sub-%03d" % s, "func",
"*.nii"))) for s in subjects
]
global_mask = math_img('img>0.5', img=mean_img(masks))
masker = MultiNiftiMasker(global_mask, detrend=True, standardize=True)
masker.fit()
return masker
def compute_global_masker(rootdir):
'''Define the mask that will be applied onto data'''
mask = op.join(rootdir, 'spm12/tpm/mask_ICV.nii')
global_mask = math_img('img>0', img=mask)
masker = MultiNiftiMasker(global_mask,
smoothing_fwhm=1.5,
high_pass=1 / 128,
t_r=2,
detrend=True,
standardize=True)
masker.fit()
return masker
def compute_all_subjects_mask():
""" Computes the mask of all the subjects and the sesssions
"""
masker = MultiNiftiMasker(mask_strategy='epi',
memory=CACHE_DIR,
memory_level=2,
n_jobs=10,
verbose=5)
imgs = dataset.func1 + dataset.func2
masker.fit(imgs)
masker.mask_img_.to_filename('all_subjects.nii.gz')
plot_roi(masker.mask_img_)
def generate_fmri_data_for_subject(subject, current_ROI):
"""
Input : Take as input each fmri file. One file = One block
Load all fmri data and apply a global mask mak on it. The global mask is computed using the mask from each fmri run (block).
Applying a global mask for a subject uniformize the data.
Output: Output fmri_runs for a subject, corrected using a global mask
"""
# Get all paths for fmri data
fmri_filenames = sorted(glob.glob(os.path.join(paths.rootpath,
"fmri-data/en",
"sub-%03d" % subject,
"func",
"resampled*.nii")))
# Process for All brain
if current_ROI == -1:
# Get paths for masks
masks_filenames = sorted(glob.glob(os.path.join(paths.path2Data,
"en/fmri_data/masks",
"sub_{}".format(subject),
"resample*.pkl")))
masks = []
for file in masks_filenames:
with open(file, 'rb') as f:
mask = pickle.load(f)
masks.append(mask)
# Compute a global mask for all subject. This way the data will be uniform
global_mask = math_img('img>0.5', img=mean_img(masks))
masker = MultiNiftiMasker(global_mask, detrend=True, standardize=True)
masker.fit()
# Apply the mask to each fmri run (block)
fmri_runs = [masker.transform(f) for f in tqdm(fmri_filenames)]
# Process for a specific ROI
else:
# get paths of ROIs masks
masks_ROIs_filenames = sorted(glob.glob(os.path.join(paths.path2Data,
"en/ROIs_masks/",
"*.nii")))
# Choose the mask
ROI_mask = masks_ROIs_filenames[current_ROI]
ROI_mask = NiftiMasker(ROI_mask, detrend=True, standardize=True)
ROI_mask.fit()
# Apply the mask to each fmri run (block)
fmri_runs = [ROI_mask.transform(f) for f in fmri_filenames]
return fmri_runs
def fetch_masker(masker_path,
language,
path_to_fmridata,
path_to_input,
smoothing_fwhm=None,
logger=None):
""" Fetch or compute if needed a global masker from all subjects of a
given language.
Arguments:
- masker_path: str
- language: str
- path_to_input: str
- path_to_fmridata: str
- smoothing_fwhm: int
- logger: Logger
"""
if os.path.exists(masker_path + '.nii.gz') and os.path.exists(masker_path +
'.yml'):
logger.report_state(" loading existing masker...")
params = read_yaml(masker_path + '.yml')
mask_img = nib.load(masker_path + '.nii.gz')
masker = MultiNiftiMasker()
masker.set_params(**params)
masker.fit([mask_img])
else:
logger.report_state(" recomputing masker...")
fmri_runs = {}
subjects = [
get_subject_name(id) for id in possible_subjects_id(language)
]
for subject in subjects:
_, fmri_paths = fetch_data(path_to_fmridata, path_to_input,
subject, language)
fmri_runs[subject] = fmri_paths
masker = compute_global_masker(list(fmri_runs.values()),
smoothing_fwhm=smoothing_fwhm)
params = masker.get_params()
params = {
key: params[key]
for key in [
'detrend', 'dtype', 'high_pass', 'low_pass', 'mask_strategy',
'memory_level', 'n_jobs', 'smoothing_fwhm', 'standardize',
't_r', 'verbose'
]
}
nib.save(masker.mask_img_, masker_path + '.nii.gz')
save_yaml(params, masker_path + '.yml')
return masker
def run(root_dir="/", dump_dir=None, data_set=None, n_jobs=1):
from nilearn.input_data import MultiNiftiMasker, NiftiMapsMasker
from joblib import Memory, Parallel, delayed
import nibabel
from tempfile import mkdtemp
if dump_dir is None:
dump_dir = mkdtemp(os.path.join(root_dir, 'tmp'))
mem = Memory(cachedir=os.path.join(root_dir, dump_dir))
print "Loading all paths and variables into memory"
df = get_all_paths(root_dir=root_dir, data_set=data_set)
target_affine_ = nibabel.load(df["func"][0]).get_affine()
target_shape_ = nibabel.load(df["func"][0]).shape[:-1]
print "preparing and running MultiNiftiMasker"
mnm = MultiNiftiMasker(mask_strategy="epi", memory=mem, n_jobs=n_jobs,
verbose=10, target_affine=target_affine_,
target_shape=target_shape_)
mask_img = mnm.fit(list(df["func"])).mask_img_
print "preparing and running NiftiMapsMasker"
nmm = NiftiMapsMasker(
maps_img=os.path.join("/usr/share/fsl/data/atlases/HarvardOxford/",
"HarvardOxford-cortl-prob-2mm.nii.gz"),
mask_img=mask_img, detrend=True, smoothing_fwhm=5, standardize=True,
low_pass=None, high_pass=None, memory=mem, verbose=10)
region_ts = Parallel(n_jobs=n_jobs)(
delayed(_data_fitting)(niimg, nmm, n_hv_confounds=5)
for niimg in list(df["func"]))
# joblib.dump(region_ts,
# os.path.join(dump_dir, "results.pkl"))
# region_signals = DataFrame({"region_signals": region_ts}, index=df.index)
# df.join(region_signals)
# return df
return region_ts
def compute_global_masker(files,
smoothing_fwhm=None
): # [[path, path2], [path3, path4]]
"""Returns a MultiNiftiMasker object from list (of list) of files.
Arguments:
- files: list (of list of str)
Returns:
- masker: MultiNiftiMasker
"""
masks = [compute_epi_mask(f) for f in files]
global_mask = math_img(
'img>0.5',
img=mean_img(masks)) # take the average mask and threshold at 0.5
masker = MultiNiftiMasker(global_mask,
detrend=True,
standardize=True,
smoothing_fwhm=smoothing_fwhm)
masker.fit()
return masker
def test_check_embedded_nifti_masker():
owner = OwningClass()
masker = check_embedded_nifti_masker(owner)
assert type(masker) is MultiNiftiMasker
for mask, multi_subject in ((MultiNiftiMasker(), True), (NiftiMasker(),
False)):
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner,
multi_subject=multi_subject)
assert type(masker) == type(mask)
for param_key in masker.get_params():
if param_key not in [
'memory', 'memory_level', 'n_jobs', 'verbose'
]:
assert (getattr(masker, param_key) == getattr(mask, param_key))
else:
assert (getattr(masker,
param_key) == getattr(owner, param_key))
# Check use of mask as mask_img
shape = (6, 8, 10, 5)
affine = np.eye(4)
mask = nibabel.Nifti1Image(np.ones(shape[:3], dtype=np.int8), affine)
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert masker.mask_img is mask
# Check attribute forwarding
data = np.zeros((9, 9, 9))
data[2:-2, 2:-2, 2:-2] = 10
imgs = nibabel.Nifti1Image(data, np.eye(4))
mask = MultiNiftiMasker()
mask.fit([[imgs]])
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert masker.mask_img is mask.mask_img_
# Check conflict warning
mask = NiftiMasker(mask_strategy='epi')
owner = OwningClass(mask=mask)
with pytest.warns(UserWarning):
check_embedded_nifti_masker(owner)
def test_check_embedded_nifti_masker():
owner = OwningClass()
masker = check_embedded_nifti_masker(owner)
assert_true(type(masker) is MultiNiftiMasker)
for mask, multi_subject in (
(MultiNiftiMasker(), True), (NiftiMasker(), False)):
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner,
multi_subject=multi_subject)
assert_equal(type(masker), type(mask))
for param_key in masker.get_params():
if param_key not in ['memory', 'memory_level', 'n_jobs',
'verbose']:
assert_equal(getattr(masker, param_key),
getattr(mask, param_key))
else:
assert_equal(getattr(masker, param_key),
getattr(owner, param_key))
# Check use of mask as mask_img
shape = (6, 8, 10, 5)
affine = np.eye(4)
mask = nibabel.Nifti1Image(np.ones(shape[:3], dtype=np.int8), affine)
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask)
# Check attribute forwarding
data = np.zeros((9, 9, 9))
data[2:-2, 2:-2, 2:-2] = 10
imgs = nibabel.Nifti1Image(data, np.eye(4))
mask = MultiNiftiMasker()
mask.fit([[imgs]])
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask.mask_img_)
# Check conflict warning
mask = NiftiMasker(mask_strategy='epi')
owner = OwningClass(mask=mask)
assert_warns(UserWarning, check_embedded_nifti_masker, owner)
def compute_global_masker(files): # [[path, path2], [path3, path4]]
# return a MultiNiftiMasker object
#spm_dir = '/neurospin/unicog/protocols/IRMf/Meyniel_MarkovGuess_2014'
#mask = join(spm_dir, 'spm12/tpm/mask_ICV.nii')
#global_mask = math_img('img>0', img=mask)
#masker = MultiNiftiMasker(mask_img=global_mask)
#masker.fit()
masks = [compute_epi_mask(f) for f in files]
global_mask = math_img(
'img>0.5',
img=mean_img(masks)) # take the average mask and threshold at 0.5
masker = MultiNiftiMasker(
global_mask,
detrend=params.pref.detrend,
standardize=params.pref.standardize
) # return a object that transforms a 4D barin into a 2D matrix of voxel-time and can do the reverse action
masker.fit()
return masker
sys.stderr.write(" Done (%.2fs).\n" % (time.time() - t0))
############################################################################
# Then we prepare and mask the data
# ----------------------------------
import numpy as np
from nilearn.input_data import MultiNiftiMasker
sys.stderr.write("Preprocessing data...")
t0 = time.time()
# Load and mask fMRI data
masker = MultiNiftiMasker(mask_img=miyawaki_dataset.mask,
detrend=True,
standardize=False)
masker.fit()
X_train = masker.transform(X_random_filenames)
X_test = masker.transform(X_figure_filenames)
# We load the visual stimuli from csv files
y_train = []
for y in y_random_filenames:
y_train.append(
np.reshape(np.loadtxt(y, dtype=np.int, delimiter=','),
(-1, ) + y_shape,
order='F'))
y_test = []
for y in y_figure_filenames:
y_test.append(
np.reshape(np.loadtxt(y, dtype=np.int, delimiter=','),
def create_raw_rest_data(imgs_list,
root,
raw_dir,
masker_params=None,
n_jobs=1,
mock=False,
memory=Memory(cachedir=None),
overwrite=False):
"""
Parameters
----------
memory
imgs_list: DataFrame with columns filename, confounds
root
raw_dir
masker_params
n_jobs
mock
Returns
-------
"""
if masker_params is None:
masker_params = {}
masker = MultiNiftiMasker(verbose=1,
memory=memory,
memory_level=1,
**masker_params)
if masker.mask_img is None:
masker.fit(imgs_list['filename'])
else:
masker.fit()
if 'confounds' in imgs_list.columns:
confounds = imgs_list['confounds']
imgs_list.rename(columns={'confounds': 'orig_confounds'})
else:
confounds = repeat(None)
if not os.path.exists(raw_dir):
os.makedirs(raw_dir)
filenames = Parallel(n_jobs=n_jobs)(delayed(_unmask_single_img)(
masker, imgs, confounds, root, raw_dir, mock=mock, overwrite=overwrite)
for imgs, confounds in zip(
imgs_list['filename'], confounds))
imgs_list = imgs_list.rename(columns={'filename': 'orig_filename'})
imgs_list = imgs_list.assign(filename=filenames)
imgs_list = imgs_list.assign(confounds=None)
if not mock:
imgs_list.to_csv(os.path.join(raw_dir, 'data.csv'), mode='w+')
mask_img_file = os.path.join(raw_dir, 'mask_img.nii.gz')
masker.mask_img_.to_filename(mask_img_file)
params = masker.get_params()
params.pop('memory')
params.pop('memory_level')
params.pop('n_jobs')
params.pop('verbose')
params['mask_img'] = mask_img_file
json.dump(params, open(os.path.join(raw_dir, 'masker.json'), 'w+'))
class MultiCovariance(BaseEstimator):
def __init__(self, estimator, smoothing_fwhm=None, mask=None,
detrend=None, standardize=None,
target_affine=None, target_shape=None,
low_pass=None, high_pass=None, t_r=None,
memory=Memory(cachedir=None), memory_level=0,
n_jobs=1, verbose=0):
self.estimator = estimator
self.mask = mask
self.memory = memory
self.memory_level = memory_level
self.n_jobs = n_jobs
self.verbose = verbose
self.low_pass = low_pass
self.high_pass = high_pass
self.t_r = t_r
self.smoothing_fwhm = smoothing_fwhm
self.target_affine = target_affine
self.target_shape = target_shape
self.standardize = standardize
self.detrend = detrend
def fit(self, niimgs=None, y=None, confounds=None, connectivity=None):
"""Compute the mask and the components
Parameters
----------
niimgs: list of filenames or NiImages
Data on which the PCA must be calculated. If this is a list,
the affine is considered the same for all.
"""
# Hack to support single-subject data:
if isinstance(niimgs, (basestring, nibabel.Nifti1Image)):
niimgs = [niimgs]
# This is a very incomplete hack, as it won't work right for
# single-subject list of 3D filenames
# First, learn the mask
if not isinstance(self.mask, MultiNiftiMasker):
self.masker_ = MultiNiftiMasker(mask=self.mask,
smoothing_fwhm=self.smoothing_fwhm,
target_affine=self.target_affine,
target_shape=self.target_shape,
low_pass=self.low_pass,
high_pass=self.high_pass,
t_r=self.t_r,
memory=self.memory,
memory_level=self.memory_level)
else:
try:
self.masker_ = clone(self.mask)
except TypeError as e:
# Workaround for a joblib bug: in joblib 0.6, a Memory object
# with cachedir = None cannot be cloned.
masker_memory = self.mask.memory
if masker_memory.cachedir is None:
self.mask.memory = None
self.masker_ = clone(self.mask)
self.mask.memory = masker_memory
self.masker_.memory = Memory(cachedir=None)
else:
# The error was raised for another reason
raise e
for param_name in ['target_affine', 'target_shape',
'smoothing_fwhm', 'low_pass', 'high_pass',
't_r', 'memory', 'memory_level']:
if getattr(self.masker_, param_name) is not None:
warnings.warn('Parameter %s of the masker overriden'
% param_name)
setattr(self.masker_, param_name,
getattr(self, param_name))
if self.masker_.mask is None:
self.masker_.fit(niimgs)
else:
self.masker_.fit()
self.mask_img_ = self.masker_.mask_img_
parameters = get_params(MultiNiftiMasker, self)
# Now compute the covariances
self.covariances_ = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
delayed(subject_covariance)(
self.estimator,
niimg,
self.masker_.mask_img_,
parameters,
memory=self.memory,
ref_memory_level=self.memory_level,
confounds=confounds,
connectivity=connectivity,
verbose=self.verbose
)
for niimg in niimgs)
return self
import nibabel
import os
import pylab as pl
import numpy as np
import time
# CanICA
from nilearn.decomposition.canica import CanICA
from nilearn.input_data import MultiNiftiMasker
# Masker:
masker = MultiNiftiMasker(smoothing_fwhm=6.,
memory="nilearn_cache",
memory_level=1)
masker.fit(dataset.func)
affine = masker.mask_img_.get_affine()
if not os.path.exists('canica.nii.gz'):
t0 = time.time()
canica = CanICA(n_components=n_components, mask=masker,
smoothing_fwhm=6.,
memory="nilearn_cache", memory_level=1,
threshold=None,
random_state=1)
canica.fit(dataset.func)
print('Canica: %f' % (time.time() - t0))
canica_components = masker.inverse_transform(canica.components_)
nibabel.save(canica_components, 'canica.nii.gz')
if not os.path.exists('canica.pdf'):
import nibabel
import os
import pylab as pl
import numpy as np
import time
# CanICA
from nilearn.decomposition.canica import CanICA
from nilearn.input_data import MultiNiftiMasker
# Masker:
masker = MultiNiftiMasker(smoothing_fwhm=6.,
memory="nilearn_cache",
memory_level=1)
masker.fit(dataset.func)
affine = masker.mask_img_.get_affine()
if not os.path.exists('canica.nii.gz'):
t0 = time.time()
canica = CanICA(n_components=n_components,
mask=masker,
smoothing_fwhm=6.,
memory="nilearn_cache",
memory_level=1,
threshold=None,
random_state=1)
canica.fit(dataset.func)
print('Canica: %f' % (time.time() - t0))
canica_components = masker.inverse_transform(canica.components_)
nibabel.save(canica_components, 'canica.nii.gz')
y_figure_filenames = miyawaki_dataset.label[:12]
y_shape = (10, 10)
sys.stderr.write(" Done (%.2fs).\n" % (time.time() - t0))
### Preprocess and mask #######################################################
import numpy as np
from nilearn.input_data import MultiNiftiMasker
sys.stderr.write("Preprocessing data...")
t0 = time.time()
# Load and mask fMRI data
masker = MultiNiftiMasker(mask_img=miyawaki_dataset.mask, detrend=True,
standardize=False)
masker.fit()
X_train = masker.transform(X_random_filenames)
X_test = masker.transform(X_figure_filenames)
# Load visual stimuli from csv files
y_train = []
for y in y_random_filenames:
y_train.append(np.reshape(np.loadtxt(y, dtype=np.int, delimiter=','),
(-1,) + y_shape, order='F'))
y_test = []
for y in y_figure_filenames:
y_test.append(np.reshape(np.loadtxt(y, dtype=np.int, delimiter=','),
(-1,) + y_shape, order='F'))
X_train = np.vstack([x[2:] for x in X_train])
CACHE_DIR = '/home/mr234268/data'
dataset = datasets.fetch_adni_rs_fmri()
func_files = dataset['func']
dx_group = dataset['dx_group']
n_sample = 140
idx = np.random.randint(len(func_files), size=n_sample)
func_files_sample = np.array(func_files)[idx]
multi_masker = MultiNiftiMasker(mask_strategy='epi',
memory=CACHE_DIR,
n_jobs=1,
memory_level=2)
multi_masker.fit(func_files_sample)
plot_img(multi_masker.mask_img_)
n_components = 40
canica = CanICA(mask=multi_masker,
n_components=n_components,
smoothing_fwhm=6.,
memory=CACHE_DIR,
memory_level=5,
threshold=3.,
verbose=10,
random_state=0)
canica.fit(func_files_sample)
# Retrieve the independent components in brain space
components_img = canica.masker_.inverse_transform(canica.components_)
# We first create a masker, giving it the options that we care # about. Here we use standardizing of the data, as it is often important # for decoding mask_filename = os.getcwd() + "/dataset/train/Patient_01/GT.nii.gz" scan_filename = os.getcwd() + "/dataset/train/Patient_01/Patient_01.nii.gz" masker = MultiNiftiMasker(mask_img=mask_filename, standardize=True) print(masker) # We give the masker a filename and retrieve a 2D array ready # for machine learning with scikit-learn masker.fit(scan_filename) #masker.transform(scan_filename) scan_masked = masker.fit_transform(scan_filename) # calculate mean image for the background mean_func_img = mean_img(scan_filename) ''' plot_roi(masker.mask_img_, mean_func_img, display_mode='y', cut_coords=4, title="Mask") show() ''' # maxes = np.max(labelArray, axis=0) # calculate mean image for the background # mean_func_img = mean_img(filename) # plot_roi(mask_img, mean_func_img, display_mode='y', cut_coords=4, title="Mask")
import joblib
from sklearn.base import clone
import nibabel
root_dir = "/media/Elements/volatile/new/salma"
mem = Memory(cachedir=os.path.join(root_dir,
("storage/workspace/brainpedia"
"/preproc/henson2010faces/dump/")))
print "Loading all paths and variables into memory"
df = get_all_paths(root_dir=root_dir,
data_set=["henson2010faces"])
target_affine_ = nibabel.load(df["func"][0]).get_affine()
target_shape_ = nibabel.load(df["func"][0]).shape[:-1]
print "preparing and running MultiNiftiMasker"
mnm = MultiNiftiMasker(mask_strategy="epi", memory=mem, n_jobs=1,
verbose=10, target_affine=target_affine_,
target_shape=target_shape_)
mask_img = mnm.fit(list(df["func"])).mask_img_
print "preparing and running NiftiMapsMasker"
nmm = NiftiMapsMasker(
maps_img=os.path.join("/usr/share/fsl/data/atlases/HarvardOxford/",
"HarvardOxford-cortl-prob-2mm.nii.gz"),
mask_img=mask_img, detrend=True, smoothing_fwhm=5, standardize=True,
low_pass=None, high_pass=None, memory=mem, verbose=10)
region_ts = [clone(nmm).fit_transform(niimg, n_hv_confounds=5)
for niimg in list(df["func"])]
joblib.dump(region_ts, "/home/storage/workspace/rphlypo/retreat/results/")
region_signals = DataFrame({"region_signals": region_ts}, index=df.index)
df.join(region_signals)
