def spatial_correlations(mm, atlas=None):
if atlas is None:
from nilearn.datasets import fetch_atlas_msdl
atlas = fetch_atlas_msdl()
from nilearn.input_data import NiftiMapsMasker
masker = NiftiMapsMasker(maps_img=atlas['maps'])
rsns_masked = masker.fit_transform(atlas['maps'])
mm_masked = masker.fit_transform([mm])
cc = np.corrcoef(mm_masked, rsns_masked)
return cc
def get_data_in_rois_method1(ROIs, subjects, contrasts, condir):
""" returns the average contratst in each ROI and for each subject """
masker = NiftiMapsMasker(ROIs)
print ROIs
values = np.zeros((len(subjects), len(contrasts), len(ROIs)))
for isub, sub in enumerate(subjects):
conlist = [op.join(sub, condir, x) for x in contrasts]
print conlist
res = masker.fit_transform(conlist)
values[isub, :] = masker.fit_transform(conlist)
#print values
return values
def get_data_in_rois_method1(ROIs, subjects, contrasts, condir):
""" returns the average contratst in each ROI and for each subject """
masker = NiftiMapsMasker(ROIs)
print ROIs
values = np.zeros((len(subjects), len(contrasts), len(ROIs)))
for isub, sub in enumerate(subjects):
conlist = [op.join(sub, condir, x) for x in contrasts]
print conlist
res = masker.fit_transform(conlist)
values[isub, :] = masker.fit_transform(conlist)
#print values
return values
def extract_rois_signals(preprocessing_folder ='pipeline_2', prefix= 'resampled_wr'):
dataset = load_dynacomp(preprocessing_folder = preprocessing_folder,prefix = prefix)
for idx, func in enumerate([dataset.func1, dataset.func2]):
for i in range(len(dataset.subjects)):
tic = time.clock()
print func[i]
output_path, _ = os.path.split(func[i])
print dataset.subjects[i]
maps_img = dict_to_list(dataset.rois[i])
#add mask, smoothing, filter and detrending
print 'Nifti'
masker = NiftiMapsMasker(maps_img=maps_img,
mask_img = dataset.mask,
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
resampling_target ='data',
memory_level = 0,
verbose=5)
#extract signal to x
print 'masker'
x = masker.fit_transform(func[i])
print x
np.save(os.path.join(PATH_TO_SAVE_DATA,'output' + str(i+1) +'_rois_filter'),x)
print time.clock() - tic
return x
def extract_data(images, masks):
""" given a set of brain images and a set of masks, extract the average signal inside each mask for each brain image.
Returns a dataframe with 3 columns: image, mask, value.
"""
masker = NiftiMapsMasker(masks)
values = masker.fit_transform(images)
nimgs, nmasks = values.shape
cp = op.commonpath(images)
labelsimages = [i.replace(cp, '') for i in images]
print(cp)
print(labelsimages)
cpmask = op.commonprefix(masks)
labelsrois = [i.replace(cpmask, '').replace('.nii.gz', '') for i in masks]
print(cpmask)
print(labelsrois)
df = pd.DataFrame(columns=['image', 'mask', 'value'])
row = 0
for iimg in range(nimgs):
for iroi in range(nmasks):
df.loc[row] = pd.Series({
'image': labelsimages[iimg],
'mask': labelsrois[iroi],
'value': values[iimg, iroi]
})
row = row + 1
return df
def extract_from_masker(dataset_like,dataset_mask, funci, timer =True):
tic = time.clock()
maps_img = dict_to_list(dataset_like)
#add mask, smoothing, filter and detrending
print 'Nifti'
masker = NiftiMapsMasker(maps_img=maps_img,
mask_img = dataset_mask,
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
resampling_target ='data',
memory_level = 0,
verbose=5)
#extract signal to x
print 'masker'
x = masker.fit_transform(funci)
if timer:
print time.clock() - tic
return x
def extract_one_signal(dataset):
for idx, func in enumerate([dataset.func1, dataset.func2]):
for i in range(len(dataset.subjects)):
tic = time.clock()
#maps_img = dict_to_list(func)
#add mask, smoothing, filter and detrending
maps_img = dict_to_list(dataset.rois[i])
masker = NiftiMapsMasker(maps_img=maps_img,
mask_img = dataset.mask,
low_pass = .1,
high_pass = .01,
smoothing_fwhm =6.,
t_r = 1.05,
detrend = True,
standardize = False,
resampling_target ='data',
memory_level = 0,
verbose=5)
#extract signal to x
x = masker.fit_transform(func[i])
print "loading time : "+ str(time.clock() - tic)
return x,maps_img
def get_data_in_roi(path_roi, data_file):
"""Using of the NiftiMapsMasker """
masker = NiftiMapsMasker([path_roi])
array_datas = np.zeros((len(data_file), 177))
for e, d in enumerate(data_file):
nifti_obj = nibabel.load(d)
data = masker.fit_transform(d)
array_datas[e - 1] = data.ravel()
return array_datas
def get_data_in_roi(path_roi, data_file):
"""Using of the NiftiMapsMasker """
masker = NiftiMapsMasker([path_roi])
array_datas = np.zeros((len(data_file), 177))
for e, d in enumerate(data_file):
nifti_obj = nibabel.load(d)
data = masker.fit_transform(d)
array_datas[e-1] = data.ravel()
return array_datas
def extract_parcellation_time_series(in_data, parcellation_name,
parcellations_dict, bp_freqs, tr):
'''
Depending on parcellation['is_probabilistic'] this function chooses either NiftiLabelsMasker or NiftiMapsMasker
to extract the time series of each parcel
if bp_freq: data is band passfiltered at (hp, lp), if (None,None): no filter, if (None, .1) only lp...
tr in ms (e.g. from freesurfer ImageInfo())
returns np.array with parcellation time series and saves this array also to parcellation_time_series_file, and
path to pickled masker object
'''
from nilearn.input_data import NiftiLabelsMasker, NiftiMapsMasker, NiftiSpheresMasker
import os, pickle
import numpy as np
if parcellations_dict[parcellation_name][
'is_probabilistic'] == True: # use probab. nilearn
masker = NiftiMapsMasker(
maps_img=parcellations_dict[parcellation_name]['nii_path'],
standardize=True)
elif parcellations_dict[parcellation_name]['is_probabilistic'] == 'sphere':
atlas = pickle.load(
open(parcellations_dict[parcellation_name]['nii_path']))
coords = atlas.rois
masker = NiftiSpheresMasker(coords,
radius=5,
allow_overlap=True,
standardize=True)
else: # 0/1 labels
masker = NiftiLabelsMasker(
labels_img=parcellations_dict[parcellation_name]['nii_path'],
standardize=True)
# add bandpass filter (only executes if freq not None
hp, lp = bp_freqs
masker.low_pass = lp
masker.high_pass = hp
if tr is not None:
masker.t_r = tr
else:
masker.t_r = None
masker.standardize = True
masker_file = os.path.join(os.getcwd(), 'masker.pkl')
with open(masker_file, 'w') as f:
pickle.dump(masker, f)
parcellation_time_series = masker.fit_transform(in_data)
parcellation_time_series_file = os.path.join(
os.getcwd(), 'parcellation_time_series.npy')
np.save(parcellation_time_series_file, parcellation_time_series)
return parcellation_time_series, parcellation_time_series_file, masker_file
def extract_timeseries_probabilistic(filename, maps, confounds=None):
"""Because the power parcellation is given in coordinates and not labels,
we dedicate an exclusive function to deal with it.
"""
maps_masker = NiftiMapsMasker(maps,
resampling_target="data",
standardize=True)
time_series = maps_masker.fit_transform(filename, confounds=confounds)
return time_series
def run_mini_pipeline():
atlas = datasets.fetch_atlas_msdl()
atlas_img = atlas['maps']
labels = pd.read_csv(atlas['labels'])['name']
masker = NiftiMapsMasker(maps_img=atlas_img, standardize=True,
memory='/tmp/nilearn', verbose=0)
data = datasets.fetch_adhd(number_subjects)
figures_folder = '../figures/'
count=0
for func_file, confound_file in zip(data.func, data.confounds):
# fit the data to the atlas mask, regress out confounds
time_series = masker.fit_transform(func_file, confounds=confound_file)
correlation = np.corrcoef(time_series.T)
#plotting starts here
plt.figure(figsize=(10, 10))
plt.imshow(correlation, interpolation="nearest")
x_ticks = plt.xticks(range(len(labels)), labels, rotation=90)
y_ticks = plt.yticks(range(len(labels)), labels)
corr_file = figures_folder+'subject_number_' + str(count) + '_correlation.pdf'
plt.savefig(corr_file)
atlas_region_coords = [plotting.find_xyz_cut_coords(img) for img in image.iter_img(atlas_img)]
threshold = 0.6
plotting.plot_connectome(correlation, atlas_region_coords, edge_threshold=threshold)
connectome_file = figures_folder+'subject_number_' + str(count) + '_connectome.pdf'
plt.savefig(connectome_file)
#graph setup
#binarize correlation matrix
correlation[correlation<threshold] = 0
correlation[correlation != 0] = 1
graph = nx.from_numpy_matrix(correlation)
partition=louvain.best_partition(graph)
values = [partition.get(node) for node in graph.nodes()]
plt.figure()
nx.draw_spring(graph, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=True)
graph_file = figures_folder+'subject_number_' + str(count) + '_community.pdf'
plt.savefig(graph_file)
count += 1
plt.close('all')
def get_data_in_rois_method2(ROIs, subjects, contrasts, condir, localizerf, threshold):
""" returns, for individual subjects, the average contrasts values in ROIs masked by individual localizers,
thresholded at a fixed theshold"""
values = np.zeros((len(subjects), len(contrasts), len(ROIs)))
for isub, sub in enumerate(subjects):
conlist = [op.join(sub, condir, x) for x in contrasts]
localizer_img = nibabel.load(op.join(sub, localizerf))
locmask = binarize_img(localizer_img, threshold)
masker = NiftiMapsMasker(ROIs, locmask)
values[isub, :] = masker.fit_transform(conlist)
return values
def get_data_in_rois_method2(ROIs, subjects, contrasts, condir, localizerf,
threshold):
""" returns, for individual subjects, the average contrasts values in ROIs masked by individual localizers,
thresholded at a fixed theshold"""
values = np.zeros((len(subjects), len(contrasts), len(ROIs)))
for isub, sub in enumerate(subjects):
conlist = [op.join(sub, condir, x) for x in contrasts]
localizer_img = nibabel.load(op.join(sub, localizerf))
locmask = binarize_img(localizer_img, threshold)
masker = NiftiMapsMasker(ROIs, locmask)
values[isub, :] = masker.fit_transform(conlist)
return values
def getConnectome(imgPath=None,
atlasPath=None,
viewInBrowser=False,
displayCovMatrix=False):
"""
Gets the connectome of a functional MRI scan
imgPath -> absolute or relative path to the .nii file
atlasPath -> download path for the reference MSDL atlas
viewInBrowser (optional, default=False) -> if True, opens up an interactive viewer in the browser
displayCovMatrix (optional, default=False) -> display the inverse covariance matrix
Returns a tuple of shape (estimator, atlas)
"""
# Download the reference atlas
atlas = datasets.fetch_atlas_msdl(data_dir=atlasPath)
# Loading atlas image stored in 'maps'
atlasFilename = atlas['maps']
# Get the time series for the fMRI scan
masker = NiftiMapsMasker(maps_img=atlasFilename,
standardize=True,
memory='nilearn_cache',
verbose=5)
timeSeries = masker.fit_transform(imgPath)
# Compute the connectome using sparse inverse covariance
estimator = GraphicalLassoCV()
estimator.fit(timeSeries)
if (displayCovMatrix):
labels = atlas['labels']
plotting.plot_matrix(estimator.covariance_,
labels=labels,
figure=(9, 7),
vmax=1,
vmin=-1,
title='Covariance')
plotting.plot_matrix(estimator.precision_,
labels=labels,
figure=(9, 7),
vmax=1,
vmin=-1,
title='Inverse covariance (Precision)')
#covPlot.get_figure().savefig('Covariance.png')
# precPlot.get_figure().savefig('Inverse Covariance.png')
if (viewInBrowser):
coords = atlas.region_coords
view = plotting.view_connectome(-estimator.precision_, coords, '60.0%')
#view.save_as_html(file_name='Connectome Test.html')
view.open_in_browser()
return (estimator, atlas)
def extract_parcellation_time_series(in_data, parcellation_name, parcellations_dict, bp_freqs, tr):
'''
Depending on parcellation['is_probabilistic'] this function chooses either NiftiLabelsMasker or NiftiMapsMasker
to extract the time series of each parcel
if bp_freq: data is band passfiltered at (hp, lp), if (None,None): no filter, if (None, .1) only lp...
tr in ms (e.g. from freesurfer ImageInfo())
returns np.array with parcellation time series and saves this array also to parcellation_time_series_file, and
path to pickled masker object
'''
from nilearn.input_data import NiftiLabelsMasker, NiftiMapsMasker, NiftiSpheresMasker
import os, pickle
import numpy as np
if parcellations_dict[parcellation_name]['is_probabilistic'] == True: # use probab. nilearn
masker = NiftiMapsMasker(maps_img=parcellations_dict[parcellation_name]['nii_path'], standardize=True)
elif parcellations_dict[parcellation_name]['is_probabilistic'] == 'sphere':
atlas = pickle.load(open(parcellations_dict[parcellation_name]['nii_path']))
coords = atlas.rois
masker = NiftiSpheresMasker(coords, radius=5, allow_overlap=True, standardize=True)
else: # 0/1 labels
masker = NiftiLabelsMasker(labels_img=parcellations_dict[parcellation_name]['nii_path'],
standardize=True)
# add bandpass filter (only executes if freq not None
hp, lp = bp_freqs
masker.low_pass = lp
masker.high_pass = hp
if tr is not None:
masker.t_r = tr
else:
masker.t_r = None
masker.standardize = True
masker_file = os.path.join(os.getcwd(), 'masker.pkl')
with open(masker_file, 'w') as f:
pickle.dump(masker, f)
parcellation_time_series = masker.fit_transform(in_data)
parcellation_time_series_file = os.path.join(os.getcwd(), 'parcellation_time_series.npy')
np.save(parcellation_time_series_file, parcellation_time_series)
return parcellation_time_series, parcellation_time_series_file, masker_file
def _fmri_roi_extract_image(data, atlas_path, atlas_type, radius, overlap_ok,mask = None):
if 'label' in atlas_type:
logging.debug('Labels Extract')
label_masker = NiftiLabelsMasker(atlas_path, mask_img=mask)
timeseries = label_masker.fit_transform(data)
if 'sphere' in atlas_type:
atlas_path = np.loadtxt(atlas_path)
logging.debug('Sphere Extract')
spheres_masker = NiftiSpheresMasker(atlas_path, float(radius),mask_img=mask, allow_overlap = overlap_ok)
timeseries = spheres_masker.fit_transform(data)
if 'maps' in atlas_type:
logging.debug('Maps Extract')
maps_masker = NiftiMapsMasker(atlas_path,mask_img=mask, allow_overlap = overlap_ok)
timeseries = maps_masker.fit_transform(data)
timeseries[timeseries == 0.0] = np.nan
return timeseries
def extract_parcellation_time_series(in_data, parcellation_name, parcellations_dict, bp_freqs, tr):
"""
Depending on parcellation['is_probabilistic'] this function chooses either NiftiLabelsMasker or NiftiMapsMasker
to extract the time series of each parcel
if bp_freq: data is band passfiltered at (hp, lp), if (None,None): no filter, if (None, .1) only lp...
tr in ms (e.g. from freesurfer ImageInfo())
returns np.array with parcellation time series and saves this array also to parcellation_time_series_file, and
path to pickled masker object
"""
from nilearn.input_data import NiftiLabelsMasker, NiftiMapsMasker
import os, pickle
import numpy as np
if parcellations_dict[parcellation_name]["is_probabilistic"]: # use probab. nilearn
masker = NiftiMapsMasker(maps_img=parcellations_dict[parcellation_name]["nii_path"])
else: # 0/1 labels
masker = NiftiLabelsMasker(labels_img=parcellations_dict[parcellation_name]["nii_path"])
# add bandpass filter (only executes if freq not None
hp, lp = bp_freqs
masker.low_pass = lp
masker.high_pass = hp
if tr is not None:
masker.t_r = float(tr) / 1000.0
else:
masker.t_r = None
masker.standardize = True
masker_file = os.path.join(os.getcwd(), "masker.pkl")
with open(masker_file, "w") as f:
pickle.dump(masker, f)
parcellation_time_series = masker.fit_transform(in_data)
parcellation_time_series_file = os.path.join(os.getcwd(), "parcellation_time_series.npy")
np.save(parcellation_time_series_file, parcellation_time_series)
return parcellation_time_series, parcellation_time_series_file, masker_file
prefix='resampled_wr')
# func1, func2
for idx, func in enumerate([dataset.func1, dataset.func2]):
# all the subjects
for i in range(len(dataset.subjects)):
tic = time.clock()
output_path, _ = os.path.split(func[i])
print dataset.subjects[i]
maps_img = dict_to_list(dataset.rois[i])
# add mask, smoothing, filtering and detrending
masker = NiftiMapsMasker(maps_img=maps_img,
mask_img=dataset.mask,
low_pass=.1,
high_pass=.01,
smoothing_fwhm=6.,
t_r=1.05,
detrend=True,
standardize=False,
resampling_target='data',
memory_level=0,
verbose=5)
output_path, _ = os.path.split(func[i])
# extract the signal to x
x = masker.fit_transform(func[i])
np.save(
os.path.join(output_path, 'func' + str(idx + 1) + '_rois_filter'),
x)
toc = time.clock()
print toc - tic
def get_data_in_roi(path_roi, data_file):
"""Using of the NiftiMapsMasker """
masker = NiftiMapsMasker([path_roi])
nifti_obj = nibabel.load(data_file)
data = masker.fit_transform(nifti_obj)
return data
dataset = load_dynacomp(preprocessing_folder='pipeline_2',
prefix='resampled_wr')
atlas = fetch_msdl_atlas()
# add mask, smoothing, filtering and detrending
masker = NiftiMapsMasker(maps_img=atlas['maps'],
mask_img=dataset.mask,
low_pass=.1,
high_pass=.01,
t_r=1.05,
smoothing_fwhm=6.,
detrend=True,
standardize=False,
resampling_target='data',
memory_level=0,
verbose=5)
for i in range(len(dataset.subjects)):
tic = time.clock()
output_path, _ = os.path.split(dataset.func1[i])
if not os.path.isfile(os.path.join(output_path, 'func1_msdl_filter.npy')):
print i, dataset.subjects[i]
output_path, _ = os.path.split(dataset.func1[i])
x = masker.fit_transform(dataset.func1[i])
np.save(os.path.join(output_path, 'func1_msdl_filter'), x)
x = masker.fit_transform(dataset.func2[i])
np.save(os.path.join(output_path, 'func2_msdl_filter'), x)
toc = time.clock()
print 'time: ', toc - tic
prepdir = "/oak/stanford/groups/russpold/data/ds000030/1.0.3/derivatives/fmriprep_0.4.4"
subs = [
x for x in os.listdir(prepdir)
if x.startswith('sub-') and not x.endswith(".html")
]
atlas = datasets.fetch_atlas_msdl()
atlas_filename = atlas['maps']
outdir = os.path.join(os.environ.get("SCRATCH"), "CNP_ts")
if not os.path.exists(outdir):
os.mkdir(outdir)
for sub in subs:
subnum = float(sub.split("-")[1])
outfile = os.path.join(outdir, "%s_MSDL.csv" % sub)
if os.path.exists(outfile):
continue
preprocd = os.path.join(
prepdir, sub, 'func',
'%s_task-rest_bold_space-MNI152NLin2009cAsym_preproc.nii.gz' % sub)
if not os.path.exists(preprocd):
continue
masker = NiftiMapsMasker(maps_img=atlas_filename,
standardize=True,
memory='nilearn_cache',
verbose=5)
time_series = masker.fit_transform(preprocd)
ts = pd.DataFrame(time_series)
ts.to_csv(outfile, index=False, header=False)
from nilearn.input_data import NiftiMapsMasker
from nilearn import datasets
import pandas as pd
import os
prepdir = "/oak/stanford/groups/russpold/data/ds000030/1.0.3/derivatives/fmriprep_0.4.4"
subs = [x for x in os.listdir(prepdir) if x.startswith('sub-') and not x.endswith(".html")]
atlas = datasets.fetch_atlas_msdl()
atlas_filename = atlas['maps']
outdir = os.path.join(os.environ.get("SCRATCH"),"CNP_ts")
if not os.path.exists(outdir):
os.mkdir(outdir)
for sub in subs:
subnum = float(sub.split("-")[1])
outfile = os.path.join(outdir,"%s_MSDL.csv"%sub)
if os.path.exists(outfile):
continue
preprocd = os.path.join(prepdir,sub,'func','%s_task-rest_bold_space-MNI152NLin2009cAsym_preproc.nii.gz'%sub)
if not os.path.exists(preprocd):
continue
masker = NiftiMapsMasker(maps_img=atlas_filename, standardize=True,memory='nilearn_cache', verbose=5)
time_series = masker.fit_transform(preprocd)
ts = pd.DataFrame(time_series)
ts.to_csv(outfile,index=False,header=False)
], dtype=float),
'DMN-LECN': np.empty([
len(subject_folders),
], dtype=float)
})
for subject_folder in subject_folders:
img = image.load_img(
glob(
op.join(
subject_folder,
'sub-*_task-rest_run-01_space-MNI152NLin2009cAsym_desc-preproc_bold-clean.nii*'
)))
#average timeseries extracted from each network
network_time_series = network_masker.fit_transform(img)
#calculate connectivity matrix from each subject
network_conmat = correlation_measure.fit_transform([network_time_series
])[0]
#grab connectivity values from locations in matrix
df.at[subject_folder, 'SN-DMN'] = network_conmat[0, 1]
df.at[subject_folder, 'SN-RECN'] = network_conmat[0, 2]
df.at[subject_folder, 'SN-LECN'] = network_conmat[0, 3]
df.at[subject_folder, 'DMN-RECN'] = network_conmat[1, 2]
df.at[subject_folder, 'DMN-LECN'] = network_conmat[1, 3]
#Add to the list of vectorized connectivity matrices
print(subject_folder)
print(network_conmat)
atlas_filename = atlas['maps']
# Loading atlas data stored in 'labels'
labels = atlas['labels']
# Apply atlas to my data
from nilearn.image import resample_to_img
Atlas = resample_to_img(atlas_filename, mask, interpolation='continuous')
# Gain the TimeSeries
from nilearn.input_data import NiftiMapsMasker
masker = NiftiMapsMasker(maps_img=Atlas,
standardize=True,
memory='nilearn_cache',
verbose=5)
time_series = masker.fit_transform(fMRIData)
############################################################################
# Build and display a correlation matrix
from nilearn.connectome import ConnectivityMeasure
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Display the correlation matrix
import numpy as np
from matplotlib import pyplot as plt
plt.figure(figsize=(10, 10))
# Mask out the major diagonal
np.fill_diagonal(correlation_matrix, 0)
plt.imshow(correlation_matrix,
interpolation="nearest",
at_check.append(plt.gcf())
plt.close()
# select matching regressor files
for f_name in func_imgs:
f=func_imgs.index(f_name)
if len(reg_dirs) > func_index:
reg_file = glob.glob(reg_dirs[func_index]+'/'+reg_prefix+f_name[len(root+func_type)+common+1:len(f_name)-4] + '*.txt')
else:
reg_file=[]
print('could not find matching regressor directory')
# extracting time series according to atlas
if func_imgs[f]:
time_series.append( masker_r.fit_transform(func_imgs[f]))
if reg_file:
time_serie_r = masker_r.fit_transform(func_imgs[f], confounds=reg_file)
regressors.append(np.loadtxt(reg_file[0]))
else:
time_serie_r=masker_r.fit_transform(func_imgs[f])
print('no confounds removed')
time_series_r.append(time_serie_r)
progress = 100*( (float(f)+1.)/len(func_imgs))
print(str(progress) + '% done in computing time series for '+func_type)
# update dictionary containing all data
labels = np.recfromcsv(csv_filename)
names = labels['name']
from nilearn.input_data import NiftiMapsMasker
masker = NiftiMapsMasker(maps_img=atlas_filename,
standardize=True,
memory='nilearn_cache',
verbose=5)
data = datasets.fetch_adhd(n_subjects=1)
# print basic information on the dataset
print('First subject functional nifti images (4D) are at: %s' %
data.func[0]) # 4D data
time_series = masker.fit_transform(data.func[0], confounds=data.confounds)
# Compute the sparse inverse covariance
from sklearn.covariance import GraphLassoCV
estimator = GraphLassoCV()
estimator.fit(time_series)
# Display the connectome matrix
from matplotlib import pyplot as plt
from nilearn import plotting
coords = np.vstack((labels['x'], labels['y'], labels['z'])).T
# Display the covariance
plt.figure(figsize=(10, 10))
mask_params = {
'mask_img': group_mask,
'detrend': True,
'standardize': True,
'high_pass': 0.01,
'low_pass': 0.1,
't_r': 1,
'smoothing_fwhm': 6.,
'verbose': 5
}
masker = NiftiMapsMasker(maps_img=maps_img, **mask_params)
# %% Generate npy files of timeseries for each subject per session
# we will use it later on, stratify to scripts etc.
# build a specific folder
try:
os.makedirs(output_dir)
except:
print('Folder already exist')
subject_ts = []
for sub in subject_list:
print(f' Analysing subject {sub}')
subject = sub.split('KPE')[1]
func = func_template.format(sub=subject, session=ses)
confound = confound_template.format(sub=subject, session=ses)
signals = masker.fit_transform(imgs=func, confounds=removeVars(confound))
save = np.save(output_dir + 'sub-' + subject + '_ses-' + ses, signals)
subject_ts.append(signals)
dataset = load_dynacomp(preprocessing_folder='pipeline_2',
prefix='resampled_wr')
atlas = fetch_msdl_atlas()
# add mask, smoothing, filtering and detrending
masker = NiftiMapsMasker(maps_img=atlas['maps'],
mask_img=dataset.mask,
low_pass=.1,
high_pass=.01,
t_r=1.05,
smoothing_fwhm=6.,
detrend=True,
standardize=False,
resampling_target='data',
memory_level=0,
verbose=5)
for i in range(len(dataset.subjects)):
tic = time.clock()
output_path, _ = os.path.split(dataset.func1[i])
if not os.path.isfile(os.path.join(output_path, 'func1_msdl_filter.npy')):
print i, dataset.subjects[i]
output_path, _ = os.path.split(dataset.func1[i])
x = masker.fit_transform(dataset.func1[i])
np.save(os.path.join(output_path, 'func1_msdl_filter') , x)
x = masker.fit_transform(dataset.func2[i])
np.save(os.path.join(output_path, 'func2_msdl_filter') , x)
toc = time.clock()
print 'time: ', toc - tic
'mask_img': gm_mask,
'detrend': True,
'standardize': True,
'high_pass': 0.01,
'low_pass': 0.1,
't_r': 2.53,
'smoothing_fwhm': 6.,
'verbose': 1
}
masker = NiftiMapsMasker(maps_img=maps_img, **mask_params)
subjects_timeseries = []
dx_groups = []
for label, func_img in zip(phenotypes['DX_GROUP'], func_imgs):
confounds = extract_confounds(func_img, mask_img=gm_mask, n_confounds=10)
signals = masker.fit_transform(func_img, confounds=confounds)
subjects_timeseries.append(signals)
dx_groups.append(label)
##############################################################################
# Functional Connectomes
# ----------------------
connectome_measure = connectome.ConnectivityMeasure(
cov_estimator=LedoitWolf(assume_centered=True),
kind='tangent',
vectorize=True)
# Vectorized connectomes across subject-specific timeseries
vec = connectome_measure.fit_transform(subjects_timeseries)
##############################################################################
# 6. Weighting based on collections
# 7. Distribution of #images per collection
# 8. Average over all images?
# 9. Nearest neighbor to go from images to labels
# 10. Get encoder maps for the most frequently occuring words
# 11. Normalize by frequency of different terms in baseline
# 12. Precompute baseline
# get data / list of files
nv_data = datasets.fetch_neurovault(max_images=None, mode='offline',
data_dir=data_dir)
images = nv_data['images']
images_meta = nv_data['images_meta']
collections = nv_data['collections_meta']
# export metadata to pandas
metadata = pd.DataFrame(images_meta)
# read Arthur Mensch's parcellations
maps = nib.load('components_512.nii.gz')
# reduce dimensionality
imgs = []
for ii, image in enumerate(images):
print('Resampling image %d' % ii)
imgs.append(read_resampled_img(image))
masker = NiftiMapsMasker(maps)
X = masker.fit_transform(imgs)
masker = NiftiMapsMasker(components_img, smoothing_fwhm=6,
standardize=True, detrend=True,
t_r=2.5, low_pass=0.1,
high_pass=0.01)
# In[ ]:
subjects_timeseries = {}
for subject_func in func:
# print (subject_func.split('\\'))
key = get_key(subject_func.split('\\')[-1])
subjects_timeseries[key] = masker.fit_transform(subject_func)
# subjects_timeseries.append(masker.fit_transform(subject_func))
#
# Visualizing extracted timeseries signals. We import matplotlib.pyplot
import matplotlib.pyplot as plt
# In[ ]:
subjects_timeseries
# In[ ]:
mask_img=mask,
smoothing_fwhm=None,
standardize=stdz,
detrend=detr,
low_pass=None,
high_pass=None,
t_r=TR,
resampling_target='data',
memory=mem_dir,
memory_level=5,
verbose=0)
# extracting time series according to atlas
if func_imgs[f]:
time_series.append(masker_r.fit_transform(func_imgs[f]))
if reg_file:
time_serie_r = masker_r.fit_transform(func_imgs[f],
confounds=reg_file)
regressors.append(np.loadtxt(reg_file[0]))
else:
time_serie_r = masker_r.fit_transform(func_imgs[f])
print('no confounds removed')
time_series_r.append(time_serie_r)
progress = np.round(100 * ((float(f) + 1.) / len(func_imgs)))
print(
str(progress) + '% done in computing time series for ' +
func_type)
dataset = load_dynacomp(preprocessing_folder='pipeline_2',
prefix='resampled_wr')
# func1, func2
for idx, func in enumerate([dataset.func1, dataset.func2]):
# all the subjects
for i in range(len(dataset.subjects)):
tic = time.clock()
output_path, _ = os.path.split(func[i])
print dataset.subjects[i]
maps_img = dict_to_list(dataset.rois[i])
# add mask, smoothing, filtering and detrending
masker = NiftiMapsMasker(maps_img=maps_img,
mask_img=dataset.mask,
low_pass=.1,
high_pass=.01,
smoothing_fwhm=6.,
t_r=1.05,
detrend=True,
standardize=False,
resampling_target='data',
memory_level=0,
verbose=5)
output_path, _ = os.path.split(func[i])
# extract the signal to x
x = masker.fit_transform(func[i])
np.save(os.path.join(output_path,
'func' + str(idx+1) + '_rois_filter'), x)
toc = time.clock()
print toc - tic
tproject.inputs.automask = True
else:
tproject.inputs.automask = False
tproject.inputs.mask = curmask
tproject.inputs.bandpass = tuple(bandpass)
if NoiseReg.shape[1] > 0:
tproject.inputs.ort = noise_fn
#tproject.inputs.censor = curcache + "/SpikeReg.txt"
#tproject.inputs.cenmode = 'NTRP'
tproject.inputs.out_file = errts_fn
tproject.run()
# get time-series
print('Regressed ' + str(NoiseReg.shape[1] + nAROMAComps) +
' parameters from ROI time-series...')
roits = masker.fit_transform(errts_fn)
np.savetxt(outfile, roits, delimiter='\t')
elapsed = time.time() - t
print('Elapsed time (s) for ' + pipelines[jj].outid + ': ' +
str(np.round(elapsed, 1)))
#store info into dataframe w/
idlist[ii, jj] = os.path.basename(curfunc).split('_')[0]
atlaslist[ii, jj] = atlas
ses[ii, jj] = curfunc.split('ses-')[1].split('/')[0]
task[ii, jj] = curfunc.split('task-')[1].split('_')[0]
run[ii, jj] = curfunc.split('run-')[1].split('_')[0]
ntr[ii, jj] = float(timepoints)
fdthr[ii, jj] = float(pipelines[jj].fdthr)
dvthr[ii, jj] = float(pipelines[jj].dvrthr)
ntrabovethr[ii, jj] = float(np.sum(SpikeReg == 1)) - n_init2drop
Script to test functions Created on Thu Mar 26 15:02:11 2015 @author: [email protected] """ from loader import load_dynacomp, list_of_dicts_to_key_list, dict_to_list from nilearn.input_data import NiftiMapsMasker import time # Load Dynacomp dataset dataset = load_dynacomp() # Dataset keys print 'keys\n', dataset.keys() # Dataset functional 1 print 'func1\n', dataset.func1 # Dataset behaviordata : prePerf print 'prePerf\n', list_of_dicts_to_key_list(dataset.behavior, 'prePerf') # Generate seed-masker for subject 0 maps_img = dict_to_list(dataset.rois[1]) tic = time.clock() masker = NiftiMapsMasker(maps_img, verbose=5) x = masker.fit_transform(dataset.func1[1]) toc = time.clock() print toc - tic
def extract_time_series(fmris,
subjects_list,
atlas,
confounds=None,
standardize=True,
verbose=5):
"""Extracting time series from a list of fmris
Arguments:
fmris {list} -- List of loaded fMRIs
subjects_list {list} -- List of subjects' IDs
atlas {str} -- Path to atlas
Keyword Arguments:
confounds {list<String>} -- List of confound's path (default: {None})
standardize {bool} -- Standardize time series (default: {True})
verbose {int} -- Verbosity (default: {5})
Returns:
{tuple} -- Returns time series and processed subjects's IDs
"""
subjects_time_series = []
processed_subjects = []
for i, fmri in enumerate(fmris):
subject_id = [s for s in subjects_list if str(s) in str(fmri)]
if confounds:
assert str(subject_id[0]) in confounds[i]
if not subject_id:
print(
f'{bcolors.WARNING}Found fmri without corresponding ID. Skipping \'{str(fmri)}\'{bcolors.ENDC}'
)
continue
confounds_message = ''
if confounds:
confounds_message = f'Using confounds {confounds[i]}'
else:
confounds_message = 'Using no confounds'
print(
f'{bcolors.OKBLUE}Loading {subject_id[0]}; {confounds_message}{bcolors.ENDC}'
)
processed_subjects.append(subject_id[0])
img = load_img(fmri.as_posix())
masker = None
if not 'basc' in atlas:
masker = NiftiMapsMasker(maps_img=atlas,
standardize=standardize,
verbose=verbose)
else:
masker = NiftiLabelsMasker(labels_img=atlas,
standardize=standardize,
verbose=verbose)
time_series = masker.fit_transform(
img, confounds=confounds[i] if confounds else None)
subjects_time_series.append(time_series)
return (subjects_time_series, processed_subjects)
def main(argv):
## this is input parsing
try:
opts, args = getopt.getopt(argv, "hi:", ["ifile="])
except getopt.GetoptError:
print('single_subject_hitting_time3.py -i <sub_data>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('single_subject_hitting_time3.py -i <sub_data>')
sys.exit()
elif opt in ("-i", "--ifile"):
sub_data = arg
print('sub_data is "', sub_data)
## atlas 3
atlas = "Schaefer200Yeo17Pauli" # msdl or haox or mmp
schaefer_atlas = datasets.fetch_atlas_schaefer_2018(
n_rois=200,
yeo_networks=17,
resolution_mm=1,
data_dir=None,
base_url=None,
resume=True,
verbose=1) #atlas_filename = "MMP1_rois.nii" #Glasser et al., 2016
schaefer_filename = schaefer_atlas.maps
schaefer_labels = schaefer_atlas.labels
schaefer_masker = NiftiLabelsMasker(labels_img=schaefer_filename,
standardize=True,
memory='nilearn_cache',
verbose=5)
pauli_atlas = datasets.fetch_atlas_pauli_2017()
pauli_filename = pauli_atlas.maps
pauli_labels = pauli_atlas.labels
pauli_masker = NiftiMapsMasker(maps_img=pauli_filename,
standardize=True,
verbose=5)
all_labels = np.hstack([schaefer_labels, pauli_labels])
print(all_labels)
correlation_measure = ConnectivityMeasure(kind='correlation')
#n_rois=len(schaefer_labels) + len(pauli_labels)
#p_corr_all = np.zeros([n_rois, n_rois,len(sub_data)])
#H_all = np.zeros([n_rois, n_rois,len(sub_data)])
# generate subject number and position from sub_data
subnum = sub_data.split(os.sep)[-4]
#subnum_fmt = "{:06}".format(int(subnum))
out_base = os.sep.join(sub_data.split(os.sep)[:-3])
out_dir = out_base + os.sep + "deriv" + os.sep + "snag"
if not os.path.exists(out_dir):
os.makedirs(out_dir)
#extract time series from a atlas(es)
file_base = "_".join(sub_data.split(os.sep)[-1].split("_")[:-2])
adj_out_file = out_dir + os.sep + file_base + "_timeseries-corr_" + atlas + "_data_filt"
if not (pathlib.Path(adj_out_file).exists()):
#func_dir_in = sub_data #+ os.sep + 'restEPI' #directory with func images
#funcs_filenames = glob.glob(func_dir_in + os.sep + '*.nii') #find all funcs in this directory
confounds = high_variance_confounds(sub_data)
#schafer cortical atlas
schaefer_time_series = schaefer_masker.fit_transform(
sub_data, confounds=confounds) #cortical segments
print("schaefer ts shape: ")
print(schaefer_time_series.shape)
#subcortical atlas
pauli_time_series = pauli_masker.fit_transform(
sub_data, confounds=confounds) #subccortical segments
print("pauli ts shape: ")
print(pauli_time_series.shape)
#stack time series and determine adjacency matrix from the resulting set of time series
full_ts_set = np.hstack((schaefer_time_series, pauli_time_series))
print("concatenated ts shape: ")
print(full_ts_set.shape)
correlation_matrix = correlation_measure.fit_transform([full_ts_set
])[0]
np.savetxt(adj_out_file, correlation_matrix, delimiter=",")
print(correlation_matrix.shape[0], correlation_matrix.shape[1])
else:
correlation_matrix = genfromtxt(
adj_out_file, delimiter=','
) #load the file if the correlation matrix was pre-computed
correlation_matrix = abs(
correlation_matrix
) #absolute value to make all transition probabilities positive
np.fill_diagonal(correlation_matrix, 0) #set self connections to zero
#p_corr_all[:,:,sub_ind] = correlation_matrix.copy() #stack correlation matrices for later analysis
#build hitting time matrix
H_out_file = out_dir + os.sep + file_base + "_normedH_" + atlas + "_corr" #file where hitting-time matrix will be saved
print(H_out_file)
if not (pathlib.Path(H_out_file).exists()
): #compute hitting time matrix if it isn't already saved
H = hitting_matrix(correlation_matrix)
#H_all[:,:,sub_ind] = H
np.savetxt(H_out_file, H, delimiter=",")
print("saved " + H_out_file)
def get_data_in_roi(path_roi, data_file):
"""Using of the NiftiMapsMasker """
masker = NiftiMapsMasker([path_roi])
nifti_obj = nibabel.load(data_file)
data = masker.fit_transform(nifti_obj)
return data
# Loading atlas data stored in 'labels'
labels = atlas['labels']
# Load the functional datasets
data = datasets.fetch_adhd(n_subjects=1)
print('First subject resting-state nifti image (4D) is located at: %s' %
data.func[0])
############################################################################
# Extract the time series
from nilearn.input_data import NiftiMapsMasker
masker = NiftiMapsMasker(maps_img=atlas_filename, standardize=True,
memory='nilearn_cache', verbose=5)
time_series = masker.fit_transform(data.func[0],
confounds=data.confounds)
############################################################################
# `time_series` is now a 2D matrix, of shape (number of time points x
# number of regions)
print(time_series.shape)
############################################################################
# Build and display a correlation matrix
from nilearn.connectome import ConnectivityMeasure
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Display the correlation matrix
import numpy as np
from matplotlib import pyplot as plt
msdl_maps = msdl.maps
msdl_labels = msdl.labels
msdl_networks = msdl.networks
msdl_coordinates = msdl.region_coords
'''Now let's build our masker'''
from nilearn.input_data import NiftiMapsMasker
'''create masker to extract functional data within atlas parcels'''
masker = NiftiMapsMasker(maps_img=msdl['maps'], standardize=True,
memory='nilearn_cache')
'''calculate the correlation matrix for each of the four subjects'''
#Control
rest_cn = np.array(masker.fit_transform(rest_img_cn_sub_10228))
cn_matrix = calc_correlation_matrix(rest_cn)
#Schizophrenia
rest_sz = np.array(masker.fit_transform(rest_img_sz_sub_50006))
sz_matrix = calc_correlation_matrix(rest_sz)
#ADHD
rest_adhd = np.array(masker.fit_transform(rest_img_adhd_sub_70001))
adhd_matrix = calc_correlation_matrix(rest_adhd)
#Bipolar
rest_bp = np.array(masker.fit_transform(rest_img_bp_sub_60001))
bp_matrix = calc_correlation_matrix(rest_bp)
'''calculate the correlation matrix for the test subjects'''
test_rest_cn = np.array(masker.fit_transform(rest_img_cn_sub_10249))
test_cn_matrix = calc_correlation_matrix(rest_cn)
atlas4d_data = atlas4d.get_data()
atlas3d_data = np.sum(atlas4d_data, axis=3)
atlas3d = nib.Nifti1Image(atlas3d_data, atlas4d.get_affine())
n_subjects = len(func_files)
subjects = []
cov_feat = []
for subject_n in range(n_subjects):
filename = func_files[subject_n]
print("Processing file %s" % filename)
print("-- Computing region signals ...")
masker = NiftiMapsMasker(atlas["maps"],
resampling_target="maps", standardize=False,
memory=CACHE_DIR, memory_level=1, verbose=0)
region_ts = masker.fit_transform(filename)
subjects.append(region_ts)
print("-- Computing covariances")
cov_matrix = np.cov(region_ts.T)
cov_feat.append(cov_matrix[np.tril_indices(len(cov_matrix))])
from sklearn.svm import SVC
from sklearn.cross_validation import StratifiedShuffleSplit
cov_feat = np.array(cov_feat)
nb_iter = 100
pg_counter = 0
groups = [['AD', 'Normal'], ['AD', 'EMCI'], ['AD', 'LMCI'],
['EMCI', 'LMCI'], ['EMCI', 'Normal'], ['LMCI', 'Normal']]
score = np.zeros((nb_iter, len(groups)))
images = sorted(glob(filter))
if images == []:
print('Empty list :' + filter)
sys.exit(3)
labels = basenames(images)
u = [x.split('_') for x in labels]
subj = [x[1] for x in u]
con = [x[0] for x in u]
ROIs = sorted(glob(op.join(mask_dir, '*.nii')))
roi_names = basenames(ROIs)
# extract data
masker = NiftiMapsMasker(ROIs)
values = masker.fit_transform(images)
# save it into a pandas DataFrame
df = pd.DataFrame(columns=['subject', 'con', 'ROI', 'beta'])
n1, n2 = values.shape
k = 0
for i1 in range(n1):
for i2 in range(n2):
df.loc[k] = pd.Series({'subject': subj[i1],
'con': con[i1],
'ROI': roi_names[i2],
'beta': values[i1, i2]})
k = k + 1
df.to_csv(output, index=False)