def _fetch_msdl():
""" The AAL atlas does not contain a background label.
To make the API consistent we fix it here.
"""
msdl = datasets.fetch_atlas_msdl()
msdl['labels'] = ['Background'] + msdl['labels']
return msdl
def load_atlas(atlas_location=None, download_path=DEFAULT_DOWNLOAD_PATH):
"""Loading a provided atlas
Keyword Arguments:
atlas_location {str} -- path or url to the atlas (default: {None})
download_path {[type]} -- download path for the atlas(default: {'./downloaded_atlas.nii.gz'})
Returns:
{Nibabel Image} -- Atlas's path
"""
print(f'{bcolors.OKBLUE}Loading atlas{bcolors.ENDC}')
atlas_filename = ''
if not atlas_location:
atlas = datasets.fetch_atlas_msdl()
atlas_filename = atlas['maps']
else:
if is_url(atlas_location):
print(
f'{bcolors.OKBLUE}Beginning atlas download with urllib2...{bcolors.ENDC}'
)
urllib.request.urlretrieve(atlas_location, download_path)
atlas_filename = download_path
elif 'MIST' in atlas_location:
print(f'{bcolors.OKBLUE}Getting MIST atlases...{bcolors.ENDC}')
atlas = datasets.fetch_atlas_basc_multiscale_2015(version='sym')
atlas_filename = atlas['scale{}'.format(
atlas_location.split('_')[1].zfill(3))]
else:
atlas_filename = atlas_location
return atlas_filename
def get_nilearn_adhd_data(n_subjects, nilearn_download_dir):
# Load the functional datasets
datasets.get_data_dirs(data_dir=nilearn_download_dir)
adhd_data = datasets.fetch_adhd(n_subjects=n_subjects,
data_dir=nilearn_download_dir)
msdl_data = datasets.fetch_atlas_msdl(data_dir=nilearn_download_dir)
masker = input_data.NiftiMapsMasker(msdl_data.maps,
resampling_target="data",
t_r=2.5,
detrend=True,
low_pass=.1,
high_pass=.01,
memory='nilearn_cache',
memory_level=1)
pooled_subjects = []
adhd_labels = [] # 1 if ADHD, 0 if control
age = []
for func_file, confound_file, phenotypic in zip(adhd_data.func,
adhd_data.confounds,
adhd_data.phenotypic):
time_series = masker.fit_transform(func_file, confounds=confound_file)
pooled_subjects.append(time_series)
adhd_labels.append(phenotypic['adhd'])
age.append(phenotypic['age'])
correlation_measure = ConnectivityMeasure(kind='correlation')
corr_mat = correlation_measure.fit_transform(pooled_subjects)
print('Correlations are stacked in an array of shape {0}'.format(
corr_mat.shape))
beh = np.zeros((n_subjects, 2))
beh[:, 0] = adhd_labels
beh[:, 1] = age
return corr_mat, beh
def test_extract_timeseries():
current_dir = split(__file__)[0]
filename_func = join(current_dir, 'data', 'func.nii.gz')
filename_confounds = join(current_dir, 'data', 'confounds.txt')
time_serie = extract_timeseries(filename_func,
atlas=fetch_atlas_msdl().maps)
assert_equal(time_serie.shape, (5, 39))
assert_almost_equal(mean(time_serie), -1.05343771823e-13)
assert_almost_equal(std(time_serie), 5.253714931447222)
time_serie = extract_timeseries(filename_func,
atlas=fetch_atlas_msdl().maps,
confounds=filename_confounds)
assert_equal(time_serie.shape, (5, 39))
assert_almost_equal(mean(time_serie), -1.05567147082e-13)
assert_almost_equal(std(time_serie), 1.8468688363637491e-13)
def test_make_masker_from_atlas():
atlas = fetch_atlas_basc_multiscale_2015().scale007
masker = make_masker_from_atlas(atlas)
assert_true(isinstance(masker, NiftiLabelsMasker))
assert_equal(masker.labels_img.shape, (53, 64, 52))
atlas = fetch_atlas_msdl().maps
masker = make_masker_from_atlas(atlas)
assert_true(isinstance(masker, NiftiMapsMasker))
assert_equal(masker.maps_img.shape, (40, 48, 35, 39))
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 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_single_timeseries(subject_id, atlas='msdl'):
atlas = datasets.fetch_atlas_msdl()
atlas_file = atlas['maps']
labels = atlas['labels']
masker = input_data.NiftiMapsMasker(maps_img=atlas_file,
standardize=True,
memory='nilearn_cache',
verbose=5)
subject = get_filepaths([subject_id])[0]
timeseries = masker.fit_transform(subject)
return timeseries
def viz_connectome (regressor,imagename:str):
'''
The plotting.plot_connectome nilearn tool allows to visualize the nodes and connections among regions of the brain
based on the selected regressor (for this project we use the mean). This value will define the strength of the connectivity
'''
# List of colors
colors_df=pd.read_excel(open('colors_8.xlsx','rb'))
colors_df['lower_color'] = map(lambda x: x.lower(), colors_df['color'])
# Plot the tangent matrix
# The labels of the MSDL Atlas that we are using
# Data from the atlas used (in the given example MSDL)
atlas = datasets.fetch_atlas_msdl()
# Loading atlas data stored in 'labels'
labels = atlas['labels']
# Loading atlas coordinates
coords = atlas.region_coords
# Plot of the connectome based on the nilearn plotting.plot_connectome package
fig = plt.figure(figsize=(6,7))
display=plotting.plot_connectome(regressor,coords,node_size =40,
edge_threshold="99.5%", display_mode="ortho", title="Tangent-ASD", alpha=1,
colorbar=True, annotate=False)
values =list(colors_df["color"])
keys = labels
colors_labels = dict(zip(keys, values))
patchList = []
fontP = FontProperties()
fontP.set_size('small')
for key in colors_labels:
data_key = mpatches.Patch(color=colors_labels[key], label=key)
patchList.append(data_key)
plt.legend(handles=patchList,prop=fontP, loc='upper center', bbox_to_anchor=(0.5, -0.05),
ncol=8, fancybox=True, shadow=True)
#depends on the data to viz
plt.savefig(imagename+".png", dpi=300)
plt.close(fig)
plt.show()
def get_timeseries(subject_ids, atlas='msdl'):
atlas = datasets.fetch_atlas_msdl()
atlas_file = atlas['maps']
labels = atlas['labels']
masker = input_data.NiftiMapsMasker(maps_img=atlas_file,
standardize=True,
memory='nilearn_cache',
verbose=5)
timeseries = []
subjects = get_filepaths(subject_ids)
for subject in subjects:
timeseries.append(masker.fit_transform(subject))
return timeseries
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 plot_connectivity_matrix(matrix_data,matrix_name:str):
'''
The connectivity_matrix nilearn implementation allows the visualization of the matrices based on the atlas and matrix selected.
'''
# Plot the tangent matrix
# The labels of the MSDL Atlas that we are using
# Data from the atlas used (in the given example MSDL)
atlas = datasets.fetch_atlas_msdl()
# Loading atlas data stored in 'labels'
labels = atlas['labels']
# Loading atlas coordinates
coords = atlas.region_coords
font = {'family': 'serif',
'color': 'black',
'weight': 'bold',
'size': 12}
tt = plt.figure(1,figsize=(7,6))
np.fill_diagonal(matrix_data, 0)
plt.imshow(matrix_data, interpolation='None', cmap='RdYlBu_r', vmax=.000002, vmin=-.000002)
plt.yticks(range(len(atlas.labels)),labels, fontsize=10, weight='bold');
plt.xticks( range(len(atlas.labels)), labels, rotation=90, fontsize=10, weight='bold');
plt.title(str(matrix_name)+'_msdl',fontdict=font)
plt.colorbar(shrink=0.8)
tt2 = plt.figure(2)
view=plotting.view_connectome(matrix_data,coords, node_size=5.0, edge_threshold='99.5%')
plt.show()
return view
from nilearn.datasets import fetch_atlas_msdl, fetch_cobre
from nilearn.input_data import NiftiMapsMasker
from nilearn.connectome import vec_to_sym_matrix
from nilearn.plotting import plot_matrix
from posce import PopulationShrunkCovariance
# fetch atlas
msdl = fetch_atlas_msdl()
# fetch rfMRI scans from cobre dataset
cobre = fetch_cobre(n_subjects=20)
# extract timeseries
masker = NiftiMapsMasker(msdl.maps,
detrend=True,
standardize=True,
verbose=1,
memory=".")
masker.fit()
ts = [masker.transform(f) for f in cobre.func]
# compute PoSCE on the same dataset
posce = PopulationShrunkCovariance(shrinkage=1e-2)
posce.fit(ts)
connectivities = posce.transform(ts)
# plot the first shrunk covariance
cov = vec_to_sym_matrix(connectivities[0])
plot_matrix(cov)
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')
elif atlas_name == 'msdl_lang' :
atlas_filename='/media/vd239549/LaCie/victor/nilearn_data/msdl_atlas/msdl_lang/msdl_lang.nii'
labels = np.recfromcsv('/media/vd239549/LaCie/victor/nilearn_data/msdl_atlas/msdl_lang/msdl_lang_rois_labels.csv')
#rois = np.vstack((labels['name'],labels['netname'])).T
#coords = np.vstack((labels['x'], labels['y'], labels['z'])).T
rois = labels['name'].T
n_r = len(rois)
l=360./n_r#roi label size in figures
visu = atlas_filename
all_ntwks = range(n_r)
networks = {'All ROIs':all_ntwks}
else :
print ('unknown atlas, msdl used as default atlas')
atlas_name = 'msdl'
atlas = datasets.fetch_atlas_msdl(data_dir=atlas_dir)
atlas_filename, labels = atlas.maps, atlas.labels
labels = np.recfromcsv(atlas.labels)
#rois = np.vstack((labels['name'],labels['netname'])).T
#coords = np.vstack((labels['x'], labels['y'], labels['z'])).T
rois = labels['name'].T
n_r = len(rois)
l=360./n_r#roi label size in figures
visu = atlas_filename
all_ntwks = range(n_r)
networks = {'Auditory': [0,1],'striate' : [2],'DMN': [3,4,5,6],'Occ post' :[7],
'Motor': [8],'Attentional' : [9,10,11,12,14,15,16,17,18],
'Basal' : [13],'Visual secondary' : [19,20,21], 'Salience':[22,23,24],
'Temporal(STS)':[25,26],'Langage':[27,28,29,30,31],'Cereb':[32],
'Dors PCC': [33],'cing ins' :[34,35,36],'Ant IPS': [37,38],'All ROIs':all_ntwks}
def _get_roi_info(parc):
if parc == "msdl":
atlas = datasets.fetch_atlas_msdl()
roi_file = atlas['maps']
df_labels = pd.DataFrame({"roi_labels": atlas['labels']})
if isinstance(df_labels["roi_labels"][0], bytes):
df_labels["roi_labels"] = df_labels.roi_labels.apply(bytes.decode)
roi_names = df_labels["roi_labels"].values
roi_type = "maps"
elif parc == "gordon":
atlas_dir = "/parcs/Gordon/Parcels"
roi_file = os.path.join(atlas_dir, "Parcels_MNI_111.nii")
labs_df = pd.read_excel(os.path.join(atlas_dir, "Parcels.xlsx"))
roi_names = labs_df.ParcelID.values
roi_type = "labels"
elif parc == "basc197":
atlas = datasets.fetch_atlas_basc_multiscale_2015(version='sym')
roi_file = atlas['scale197']
roi_names = np.arange(1, 198).astype(int)
roi_type = "labels"
elif parc == "basc444":
atlas = datasets.fetch_atlas_basc_multiscale_2015(version='sym')
roi_file = atlas['scale444']
roi_names = np.arange(1, 445).astype(int)
roi_type = "labels"
elif parc == "schaefer200":
atlas_dir = "/parcs/Schaefer"
schaefer_cols = "roi community c1 c2 c3 c4".split(" ")
roi_file = os.path.join(atlas_dir, "Schaefer2018_200Parcels_17Networks_order_FSLMNI152_1mm.nii.gz")
labs_df = pd.read_csv(os.path.join(atlas_dir, "Schaefer2018_200Parcels_17Networks_order.txt"), sep="\t",
names=schaefer_cols)
roi_names = labs_df.roi
roi_type = "labels"
elif parc == "schaefer400":
atlas_dir = "/parcs/Schaefer"
schaefer_cols = "roi community c1 c2 c3 c4".split(" ")
roi_file = os.path.join(atlas_dir, "Schaefer2018_400Parcels_17Networks_order_FSLMNI152_1mm.nii.gz")
labs_df = pd.read_csv(os.path.join(atlas_dir, "Schaefer2018_400Parcels_17Networks_order.txt"), sep="\t",
names=schaefer_cols)
roi_names = labs_df.roi
roi_type = "labels"
elif parc == "yeo17":
atlas = datasets.fetch_atlas_yeo_2011()
roi_file = atlas['thick_17']
yeo_cols = "roi roi_labels c1 c2 c3 c4".split(" ")
df_labels = pd.read_csv(atlas["colors_17"], sep=r"\s*", engine="python", names=yeo_cols, skiprows=1)
roi_names = df_labels["roi_labels"].values
roi_type = "labels"
elif parc == "yeo17thin":
atlas = datasets.fetch_atlas_yeo_2011()
roi_file = atlas['thin_17']
yeo_cols = "roi roi_labels c1 c2 c3 c4".split(" ")
df_labels = pd.read_csv(atlas["colors_17"], sep=r"\s*", engine="python", names=yeo_cols, skiprows=1)
roi_names = df_labels["roi_labels"].values
roi_type = "labels"
elif parc == "yeo17split":
atlas_dir = "/parcs/Yeo_splithemi"
roi_file = os.path.join(atlas_dir, "yeo_2011_thick17_splithemi.nii.gz")
labs_df = pd.read_csv(os.path.join(atlas_dir, "yeo_2011_thick17_splithemi.tsv"), sep="\t")
roi_names = labs_df.full_roi_name.values
roi_type = "labels"
elif parc == "yeo7":
atlas = datasets.fetch_atlas_yeo_2011()
roi_file = atlas['thick_7']
yeo_cols = "roi roi_labels c1 c2 c3 c4".split(" ")
df_labels = pd.read_csv(atlas["colors_7"], sep=r"\s*", engine="python", names=yeo_cols, skiprows=1)
roi_names = df_labels["roi_labels"].values
roi_type = "labels"
else:
raise Exception("Parcellation not known {}".format(parc))
return roi_file, roi_names, roi_type
def get_atlas_info(atlas, res=None):
"""
Gather all information from a specified atlas, including the path to the atlas maps, as well as labels
and their indexes.
Parameters
----------
atlas : str
Atlas dataset to be downloaded through nilearn's dataset_fetch_atlas functionality.
res: str
Specific version of atlas to be downloaded. Only necessary for Harvard-Oxford and Talairach.
Please check nilearns respective documentation at
https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_harvard_oxford.html or
https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_talairach.html
Returns
-------
atlas_info_df : pandas dataframe
A pandas dataframe containing information about the ROIs and their indexes included in a given atlas.
atl_ds.maps : str
Path to the atlas maps.
Examples
--------
>>> get_atlas_info('aal')
atlas_info_df
atl_ds.maps
"""
if atlas == 'aal':
atl_ds = datasets.fetch_atlas_aal()
elif atlas == 'harvard_oxford':
if res is None:
print(
'Please provide the specific version of the Harvard-Oxford atlas you would like to use.'
)
else:
atl_ds = datasets.fetch_atlas_harvard_oxford(res)
elif atlas == 'destriuex':
atl_ds = datasets.fetch_atlas_destrieux_2009()
elif atlas == 'msdl':
atl_ds = datasets.fetch_atlas_msdl()
elif atlas == 'talairach':
if res is None:
print(
'Please provide the level of the Talairach atlas you would like to use.'
)
else:
atl_ds = datasets.fetch_atlas_talairach(level_name=res)
elif atlas == 'pauli_2017':
atl_ds = datasets.fetch_atlas_pauli_2017()
index = []
labels = []
for ind, label in enumerate(atl_ds.labels):
index.append(ind)
if atlas == 'destriuex':
labels.append(label[1])
else:
labels.append(label)
atlas_info_df = pd.DataFrame({'index': index, 'label': labels})
return atlas_info_df, atl_ds.maps
def get_atlas_rois(atlas, roi_idx, hemisphere, res=None, path=None):
"""
Extract ROIs from a given atlas.
Parameters
----------
atlas : str
Atlas dataset to be downloaded through nilearn's dataset_fetch_atlas functionality.
roi_idx: list
List of int of the ROI(s) you want to extract from the atlas. If not sure, use get_atlas_info.
hemisphere: list
List of str, that is hemispheres of the ROI(s) you want to extract. Can be ['left'], ['right'] or ['left', 'right'].
res: str
Specific version of atlas to be downloaded. Only necessary for Harvard-Oxford and Talairach.
Please check nilearns respective documentation at
https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_harvard_oxford.html or
https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_talairach.html
path: str
Path to where the extracted ROI(s) will be saved to. If None, ROI(s) will be saved in the current
working directory.
Returns
-------
list_rois: list
A list of the extracted ROIs.
Examples
--------
>>> get_atlas_rois('aal', [1, 2, 3], ['left', 'right'], path='/home/urial/Desktop')
list_rois
"""
if atlas == 'aal':
atl_ds = datasets.fetch_atlas_aal()
elif atlas == 'harvard_oxford':
if res is None:
print(
'Please provide the specific version of the Harvard-Oxford atlas you would like to use.'
)
else:
atl_ds = datasets.fetch_atlas_harvard_oxford(res)
elif atlas == 'destriuex':
atl_ds = datasets.fetch_atlas_destrieux_2009()
elif atlas == 'msdl':
atl_ds = datasets.fetch_atlas_msdl()
elif atlas == 'talairach':
if res is None:
print(
'Please provide the level of the Talairach atlas you would like to use.'
)
else:
atl_ds = datasets.fetch_atlas_talairach(level_name=res)
elif atlas == 'pauli_2017':
atl_ds = datasets.fetch_atlas_pauli_2017()
if roi_idx is None:
print('Please provide the indices of the ROIs you want to extract.')
elif hemisphere is None:
print(
'Please provide the hemisphere(s) from which you want to extract ROIs.'
)
for label in roi_idx:
for hemi in hemisphere:
roi_ex = Node(PickAtlas(), name='roi_ex')
roi_ex.inputs.atlas = atl_ds.maps
roi_ex.inputs.labels = label
roi_ex.inputs.hemi = hemi
if path is None:
roi_ex.inputs.output_file = '%s_%s_%s.nii.gz' % (
atlas, str(label), hemi)
roi_ex.run()
list_rois = glob('%s_*.nii.gz' % atlas)
elif path:
roi_ex.inputs.output_file = opj(
path, '%s_%s_%s.nii.gz' % (atlas, str(label), hemi))
roi_ex.run()
list_rois = glob(opj(path, '%s_*.nii.gz' % atlas))
print('The following ROIs were extracted: ')
print('\n'.join(map(str, list_rois)))
return list_rois
def __init__(self, atlas_name=''):
from nilearn import datasets
msdl = datasets.fetch_atlas_msdl()
self.dataset = getattr(smith, atlas_name)
def DownloadAAL3(PATH):
import os
from nilearn import datasets
if os.path.isfile(PATH + '/AAL3_for_SPM12.tar.gz'):
print('The atlas AAL3 has already been downloaded')
else:
os.system('wget https://www.oxcns.org/AAL3_for_SPM12.tar.gz -P ' +
PATH)
if os.path.exists(PATH + '/AAL3'):
print('The atlas AAL3 has already been unzipped')
else:
os.system('tar -zxvf ' + PATH + '/AAL3_for_SPM12.tar.gz -C ' + PATH)
if os.path.exists(PATH + '/AAL3/AAL3.mat'):
print('The atlas labels AAL have already been downloaded')
else:
os.system(
'wget https://www.dropbox.com/s/eeullhxfv8tk6fg/AAL3.mat?dl=1 -P '
+ PATH + '/AAL3')
os.system('mv ' + PATH + '/AAL3/AAL3.mat?dl=1 ' + PATH +
'/AAL3/AAL3.mat')
###################
A_HOx = '/home/lxmera/nilearn_data/fsl/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr25-2mm.nii.gz'
if os.path.isfile(A_HOx):
print('The atlas Harvard-Oxford has already been downloaded')
else:
###############################
if os.path.exists('/home/lxmera'):
datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm')
else:
print('####################################')
print('# #')
print('# CAMBIA EL USUARIO #')
print('# #')
print('####################################')
mat2 = A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat'
if os.path.isfile(mat2):
print('The atlas labels Harvard-Oxford have already been downloaded')
else:
os.system(
'wget https://www.dropbox.com/s/t0keqsapcbdl10b/labelsHof.mat?dl=1 -P '
+ A_HOx[:A_HOx.rfind('/')])
os.system('mv ' + A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat?dl=1 ' +
A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat')
A_MSDL = '/home/lxmera/nilearn_data/msdl_atlas/MSDL_rois/msdl_rois.nii'
if os.path.isfile(A_MSDL):
print('The atlas MSDL has already been downloaded')
else:
###############################
if os.path.exists('/home/lxmera'):
datasets.fetch_atlas_msdl()
else:
print('####################################')
print('# #')
print('# CAMBIA EL USUARIO #')
print('# #')
print('####################################')
mat3 = A_MSDL[:A_MSDL.rfind('/')] + '/labelsMSDL.mat'
if os.path.isfile(mat3):
print('The atlas labels MSDL have already been downloaded')
else:
os.system(
'wget https://www.dropbox.com/s/j18tleliudcx2yn/labelsMSDL.mat?dl=1 -P '
+ A_MSDL[:A_MSDL.rfind('/')])
os.system('mv ' + A_MSDL[:A_MSDL.rfind('/')] +
'/labelsMSDL.mat?dl=1 ' + A_MSDL[:A_MSDL.rfind('/')] +
'/labelsMSDL.mat')
atlas = PATH + '/AAL3/AAL3.nii.gz'
mat = PATH + '/AAL3/AAL3.mat'
return atlas, mat, A_HOx, mat2, A_MSDL, mat3
from camcan.preprocessing import extract_timeseries
from nilearn.datasets import (fetch_atlas_basc_multiscale_2015,
fetch_atlas_msdl)
import joblib
from joblib import Parallel, delayed, Memory
# path to the Cam-CAN data set
CAMCAN_PREPROCESSED = '/home/mehdi/data/camcan/camcan_preproc'
CAMCAN_PATIENTS_EXCLUDED = '/home/mehdi/data/camcan/camcan_preproc/'\
'excluded_subjects.csv'
CAMCAN_TIMESERIES = '/home/mehdi/data/camcan/camcan_timeseries'
# path to the atlases
ATLASES = [
fetch_atlas_msdl().maps,
fetch_atlas_basc_multiscale_2015().scale064,
fetch_atlas_basc_multiscale_2015().scale122,
fetch_atlas_basc_multiscale_2015().scale197
]
ATLASES_DESCR = ['msdl', 'basc064', 'basc122', 'basc197']
# path for the caching
CACHE_TIMESERIES = '/home/mehdi/data/camcan/cache/timeseries'
if not os.path.exists(CACHE_TIMESERIES):
os.makedirs(CACHE_TIMESERIES)
MEMORY = Memory(CACHE_TIMESERIES)
N_JOBS = 20
dataset = load_camcan_rest(data_dir=CAMCAN_PREPROCESSED,
patients_excluded=CAMCAN_PATIENTS_EXCLUDED)
PATH_TO_DATA = ['/home/lemaitre/Documents/data/INST/*']
SUBJECTS_EXCLUDED = ('/home/lemaitre/Documents/data/'
'inst_excluded_subjects.csv')
PATH_OUTPUT = '/home/lemaitre/Documents/data/INST_time_series'
subjects_path = []
for pdata in PATH_TO_DATA:
subjects_path += glob.glob(pdata)
subjects_path = sorted(subjects_path)
subjects_path = [sp for sp in subjects_path if isdir(sp)]
PATH_TO_RESTING_STATE = 'session_1/rest_1/rest_res2standard.nii.gz'
PATH_TO_MOTION_CORRECTION = 'session_1/rest_1/rest_mc.1D'
# path to the atlases
ATLASES = [fetch_atlas_msdl().maps,
fetch_atlas_basc_multiscale_2015().scale064,
fetch_atlas_basc_multiscale_2015().scale122,
fetch_atlas_basc_multiscale_2015().scale197,
fetch_atlas_harvard_oxford(atlas_name='cort-prob-2mm').maps,
fetch_atlas_craddock_2012().scorr_mean,
fetch_coords_power_2011()]
ATLASES_DESCR = ['msdl', 'basc064', 'basc122', 'basc197',
'harvard_oxford_cort_prob_2mm', 'craddock_scorr_mean',
'power_2011']
# load the list of patient to exclude
excluded_subjects = pd.read_csv(
SUBJECTS_EXCLUDED,
dtype={'subject_id': object})['subject_id'].tolist()
# using connectome measure object
mean_correlation_matrix = connectome_measure.mean_
# grab center coordinates for atlas labels
coordinates = plotting.find_parcellation_cut_coords(labels_img=yeo['thick_17'])
# plot connectome with 80% edge strength in the connectivity
plotting.plot_connectome(mean_correlation_matrix, coordinates,
edge_threshold="80%",
title='Yeo Atlas 17 thick (func)')
##########################################################################
# Load probabilistic atlases - extracting coordinates on brain maps
# -----------------------------------------------------------------
msdl = datasets.fetch_atlas_msdl()
##########################################################################
# Iterate over fetched atlases to extract coordinates - probabilistic
# -------------------------------------------------------------------
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')
# extract time series from all subjects and concatenate them
time_series = []
for func, confounds in zip(data.func, data.confounds):
time_series.append(masker.fit_transform(func, confounds=confounds))
# Display covariance matrix
plotting.plot_matrix(cov, cmap=plotting.cm.bwr,
vmin=-1, vmax=1, title="%s / covariance" % title,
labels=labels)
# Display precision matrix
plotting.plot_matrix(prec, cmap=plotting.cm.bwr,
vmin=-span, vmax=span, title="%s / precision" % title,
labels=labels)
##############################################################################
# Fetching datasets
# ------------------
from nilearn import datasets
msdl_atlas_dataset = datasets.fetch_atlas_msdl()
adhd_dataset = datasets.fetch_adhd(n_subjects=n_subjects)
# print basic information on the dataset
print('First subject functional nifti image (4D) is at: %s' %
adhd_dataset.func[0]) # 4D data
##############################################################################
# Extracting region signals
# --------------------------
from nilearn import image
from nilearn import input_data
# A "memory" to avoid recomputation
from sklearn.externals.joblib import Memory
source = config['source']
if source == 'craddock':
components = fetch_craddock_parcellation().parcellate400
data = np.ones_like(check_niimg(components).get_data())
mask = new_img_like(components, data)
label_masker = NiftiLabelsMasker(labels_img=components,
smoothing_fwhm=0,
mask_img=mask).fit()
maps_img = label_masker.inverse_transform(maps)
else:
mask = fetch_mask()
masker = MultiNiftiMasker(mask_img=mask).fit()
if source == 'msdl':
components = fetch_atlas_msdl()['maps']
components = masker.transform(components)
elif source in ['hcp_rs', 'hcp_rs_concat', 'hcp_rs_positive']:
data = fetch_atlas_modl()
if source == 'hcp_rs':
components_imgs = [data.nips2017_components64]
elif source == 'hcp_rs_concat':
components_imgs = [
data.nips2017_components16, data.nips2017_components64,
data.nips2017_components256
]
else:
components_imgs = [
data.positive_components16, data.positive_components64,
data.positive_components512
]
def test_fetch_atlas_msdl():
dataset = datasets.fetch_atlas_msdl(data_dir=tmpdir, verbose=0)
assert_true(isinstance(dataset.labels, _basestring))
assert_true(isinstance(dataset.maps, _basestring))
assert_equal(len(url_request.urls), 1)
def test_fetch_atlas_msdl():
dataset = datasets.fetch_atlas_msdl(data_dir=tmpdir, verbose=0)
assert_true(isinstance(dataset.labels, _basestring))
assert_true(isinstance(dataset.maps, _basestring))
assert_equal(len(url_request.urls), 1)
of functional regions in rest.
The key to extract signals is to use the
:class:`nilearn.input_data.NiftiMapsMasker` that can transform nifti
objects to time series using a probabilistic atlas.
As the MSDL atlas comes with (x, y, z) MNI coordinates for the different
regions, we can visualize the matrix as a graph of interaction in a
brain. To avoid having too dense a graph, we represent only the 20% edges
with the highest values.
"""
############################################################################
# Retrieve the atlas and the data
from nilearn import datasets
atlas = datasets.fetch_atlas_msdl()
# Loading atlas image stored in 'maps'
atlas_filename = atlas['maps']
# 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,
def main(
workdir,
outdir,
atlas,
kernel,
sparsity,
affinity,
approach,
gradients,
subcort,
neurosynth,
neurosynth_file,
sleuth_file,
nimare_dataset,
roi_mask,
term,
topic,
):
workdir = op.join(workdir, "tmp")
if op.isdir(workdir):
shutil.rmtree(workdir)
os.makedirs(workdir)
atlas_name = "atlas-{0}".format(atlas)
kernel_name = "kernel-{0}".format(kernel)
sparsity_name = "sparsity-{0}".format(sparsity)
affinity_name = "affinity-{0}".format(affinity)
approach_name = "approach-{0}".format(approach)
gradients_name = "gradients-{0}".format(gradients)
dset = None
# handle neurosynth dataset, if called
if neurosynth:
if neurosynth_file is None:
ns_data_dir = op.join(workdir, "neurosynth")
dataset_file = op.join(ns_data_dir, "neurosynth_dataset.pkl.gz")
# download neurosynth dataset if necessary
if not op.isfile(dataset_file):
neurosynth_download(ns_data_dir)
else:
dataset_file = neurosynth_file
dset = Dataset.load(dataset_file)
dataset_name = "dataset-neurosynth"
# handle sleuth text file, if called
if sleuth_file is not None:
dset = convert_sleuth_to_dataset(sleuth_file, target="mni152_2mm")
dataset_name = "dataset-{0}".format(op.basename(sleuth_file).split(".")[0])
if nimare_dataset is not None:
dset = Dataset.load(nimare_dataset)
dataset_name = "dataset-{0}".format(op.basename(nimare_dataset).split(".")[0])
if dset:
# slice studies, if needed
if roi_mask is not None:
roi_ids = dset.get_studies_by_mask(roi_mask)
print(
"{}/{} studies report at least one coordinate in the "
"ROI".format(len(roi_ids), len(dset.ids))
)
dset_sel = dset.slice(roi_ids)
dset = dset_sel
dataset_name = "dataset-neurosynth_mask-{0}".format(
op.basename(roi_mask).split(".")[0]
)
if term is not None:
labels = ["Neurosynth_TFIDF__{label}".format(label=label) for label in [term]]
term_ids = dset.get_studies_by_label(labels=labels, label_threshold=0.1)
print(
"{}/{} studies report association "
"with the term {}".format(len(term_ids), len(dset.ids), term)
)
dset_sel = dset.slice(term_ids)
dset = dset_sel
# img_inds = np.nonzero(dset.masker.mask_img.get_fdata()) # unused
# vox_locs = np.unravel_index(img_inds, dset.masker.mask_img.shape) # unused
dataset_name = "dataset-neurosynth_term-{0}".format(term)
if topic is not None:
topics = [
"Neurosynth_{version}__{topic}".format(version=topic[0], topic=topic)
for topic in topic[1:]
]
topics_ids = []
for topic in topics:
topic_ids = dset.annotations.id[np.where(dset.annotations[topic])[0]].tolist()
topics_ids.extend(topic_ids)
print(
"{}/{} studies report association "
"with the term {}".format(len(topic_ids), len(dset.ids), topic)
)
topics_ids_unique = np.unique(topics_ids)
print("{} unique ids".format(len(topics_ids_unique)))
dset_sel = dset.slice(topics_ids_unique)
dset = dset_sel
# img_inds = np.nonzero(dset.masker.mask_img.get_fdata()) # unused
# vox_locs = np.unravel_index(img_inds, dset.masker.mask_img.shape) # unused
dataset_name = "dataset-neurosynth_topic-{0}".format("_".join(topic[1:]))
if (
neurosynth
or (sleuth_file is not None)
or (nimare_dataset is not None)
):
# set kernel for MA smoothing
if kernel == "peaks2maps":
print("Running peak2maps")
k = Peaks2MapsKernel(resample_to_mask=True)
elif kernel == "alekernel":
print("Running alekernel")
k = ALEKernel(fwhm=15)
if atlas is not None:
if atlas == "harvard-oxford":
print("Parcellating using the Harvard Oxford Atlas")
# atlas_labels = atlas.labels[1:] # unused
atlas_shape = atlas.maps.shape
atlas_affine = atlas.maps.affine
atlas_data = atlas.maps.get_fdata()
elif atlas == "aal":
print("Parcellating using the AAL Atlas")
atlas = datasets.fetch_atlas_aal()
# atlas_labels = atlas.labels # unused
atlas_shape = nib.load(atlas.maps).shape
atlas_affine = nib.load(atlas.maps).affine
atlas_data = nib.load(atlas.maps).get_fdata()
elif atlas == "craddock-2012":
print("Parcellating using the Craddock-2012 Atlas")
atlas = datasets.fetch_atlas_craddock_2012()
elif atlas == "destrieux-2009":
print("Parcellating using the Destrieux-2009 Atlas")
atlas = datasets.fetch_atlas_destrieux_2009(lateralized=True)
# atlas_labels = atlas.labels[3:] # unused
atlas_shape = nib.load(atlas.maps).shape
atlas_affine = nib.load(atlas.maps).affine
atlas_data = nib.load(atlas.maps).get_fdata()
elif atlas == "msdl":
print("Parcellating using the MSDL Atlas")
atlas = datasets.fetch_atlas_msdl()
elif atlas == "surface":
print("Generating surface vertices")
if atlas != "fsaverage5" and atlas != "hcp":
imgs = k.transform(dset, return_type="image")
masker = NiftiLabelsMasker(
labels_img=atlas.maps, standardize=True, memory="nilearn_cache"
)
time_series = masker.fit_transform(imgs)
else:
# change to array for other approach
imgs = k.transform(dset, return_type="image")
print(np.shape(imgs))
if atlas == "fsaverage5":
fsaverage = fetch_surf_fsaverage(mesh="fsaverage5")
pial_left = fsaverage.pial_left
pial_right = fsaverage.pial_right
medial_wall_inds_left = surface.load_surf_data(
"./templates/lh.Medial_wall.label"
)
print(np.shape(medial_wall_inds_left))
medial_wall_inds_right = surface.load_surf_data(
"./templates/rh.Medial_wall.label"
)
print(np.shape(medial_wall_inds_right))
sulc_left = fsaverage.sulc_left
sulc_right = fsaverage.sulc_right
elif atlas == "hcp":
pial_left = "./templates/S1200.L.pial_MSMAll.32k_fs_LR.surf.gii"
pial_right = "./templates/S1200.R.pial_MSMAll.32k_fs_LR.surf.gii"
medial_wall_inds_left = np.where(
nib.load("./templates/hcp.tmp.lh.dscalar.nii").get_fdata()[0] == 0
)[0]
medial_wall_inds_right = np.where(
nib.load("./templates/hcp.tmp.rh.dscalar.nii").get_fdata()[0] == 0
)[0]
left_verts = 32492 - len(medial_wall_inds_left)
sulc_left = nib.load(
"./templates/S1200.sulc_MSMAll.32k_fs_LR.dscalar.nii"
).get_fdata()[0][0:left_verts]
sulc_left = np.insert(
sulc_left,
np.subtract(
medial_wall_inds_left, np.arange(len(medial_wall_inds_left))
),
0,
)
sulc_right = nib.load(
"./templates/S1200.sulc_MSMAll.32k_fs_LR.dscalar.nii"
).get_fdata()[0][left_verts:]
sulc_right = np.insert(
sulc_right,
np.subtract(
medial_wall_inds_right, np.arange(len(medial_wall_inds_right))
),
0,
)
surf_lh = surface.vol_to_surf(
imgs,
pial_left,
radius=6.0,
interpolation="nearest",
kind="ball",
n_samples=None,
mask_img=dset.masker.mask_img,
)
surf_rh = surface.vol_to_surf(
imgs,
pial_right,
radius=6.0,
interpolation="nearest",
kind="ball",
n_samples=None,
mask_img=dset.masker.mask_img,
)
surfs = np.transpose(np.vstack((surf_lh, surf_rh)))
del surf_lh, surf_rh
# handle cortex first
coords_left = surface.load_surf_data(pial_left)[0]
coords_left = np.delete(coords_left, medial_wall_inds_left, axis=0)
coords_right = surface.load_surf_data(pial_right)[0]
coords_right = np.delete(coords_right, medial_wall_inds_right, axis=0)
print("Left Hemipshere Vertices")
surface_macms_lh, inds_discard_lh = build_macms(dset, surfs, coords_left)
print(np.shape(surface_macms_lh))
print(inds_discard_lh)
print("Right Hemipshere Vertices")
surface_macms_rh, inds_discard_rh = build_macms(dset, surfs, coords_right)
print(np.shape(surface_macms_rh))
print(len(inds_discard_rh))
lh_vertices_total = np.shape(surface_macms_lh)[0]
rh_vertices_total = np.shape(surface_macms_rh)[0]
time_series = np.transpose(np.vstack((surface_macms_lh, surface_macms_rh)))
print(np.shape(time_series))
del surface_macms_lh, surface_macms_rh
if subcort:
subcort_img = nib.load("templates/rois-subcortical_mni152_mask.nii.gz")
subcort_vox = np.asarray(np.where(subcort_img.get_fdata()))
subcort_mm = vox2mm(subcort_vox.T, subcort_img.affine)
print("Subcortical Voxels")
subcort_macm, inds_discard_subcort = build_macms(dset, surfs, subcort_mm)
num_subcort_vox = np.shape(subcort_macm)[0]
print(inds_discard_subcort)
time_series = np.hstack((time_series, np.asarray(subcort_macm).T))
print(np.shape(time_series))
time_series = time_series.astype("float32")
print("calculating correlation matrix")
correlation = ConnectivityMeasure(kind="correlation")
time_series = correlation.fit_transform([time_series])[0]
print(np.shape(time_series))
if affinity == "cosine":
time_series = calculate_affinity(time_series, 10 * sparsity)
else:
time_series = np.transpose(k.transform(dset, return_type="array"))
print("Performing gradient analysis")
gradients, statistics = embed.compute_diffusion_map(
time_series, alpha=0.5, return_result=True, overwrite=True
)
pickle.dump(statistics, open(op.join(workdir, "statistics.p"), "wb"))
# if subcortical included in gradient decomposition, remove gradient scores
if subcort:
subcort_grads = gradients[np.shape(gradients)[0] - num_subcort_vox :, :]
subcort_grads = insert(subcort_grads, inds_discard_subcort)
gradients = gradients[0 : np.shape(gradients)[0] - num_subcort_vox, :]
# get left hemisphere gradient scores, and insert 0's where medial wall is
gradients_lh = gradients[0:lh_vertices_total, :]
if len(inds_discard_lh) > 0:
gradients_lh = insert(gradients_lh, inds_discard_lh)
gradients_lh = insert(gradients_lh, medial_wall_inds_left)
# get right hemisphere gradient scores and insert 0's where medial wall is
gradients_rh = gradients[-rh_vertices_total:, :]
if len(inds_discard_rh) > 0:
gradients_rh = insert(gradients_rh, inds_discard_rh)
gradients_rh = insert(gradients_rh, medial_wall_inds_right)
grad_dict = {
"grads_lh": gradients_lh,
"grads_rh": gradients_rh,
"pial_left": pial_left,
"sulc_left": sulc_left,
"pial_right": pial_right,
"sulc_right": sulc_right,
}
if subcort:
grad_dict["subcort_grads"] = subcort_grads
pickle.dump(grad_dict, open(op.join(workdir, "gradients.p"), "wb"))
# map the gradient to the parcels
for i in range(np.shape(gradients)[1]):
if atlas is not None:
if atlas == "fsaverage5" or atlas == "hcp":
plot_surfaces(grad_dict, i, workdir)
if subcort:
tmpimg = masking.unmask(subcort_grads[:, i], subcort_img)
nib.save(tmpimg, op.join(workdir, "gradient-{0}.nii.gz".format(i)))
else:
tmpimg = np.zeros(atlas_shape)
for j, n in enumerate(np.unique(atlas_data)[1:]):
inds = atlas_data == n
tmpimg[inds] = gradients[j, i]
nib.save(
nib.Nifti1Image(tmpimg, atlas_affine),
op.join(workdir, "gradient-{0}.nii.gz".format(i)),
)
else:
tmpimg = np.zeros(np.prod(dset.masker.mask_img.shape))
inds = np.ravel_multi_index(
np.nonzero(dset.masker.mask_img.get_fdata()), dset.masker.mask_img.shape
)
tmpimg[inds] = gradients[:, i]
nib.save(
nib.Nifti1Image(
np.reshape(tmpimg, dset.masker.mask_img.shape), dset.masker.mask_img.affine
),
op.join(workdir, "gradient-{0}.nii.gz".format(i)),
)
os.system(
"python3 /Users/miriedel/Desktop/GitHub/surflay/make_figures.py "
"-f {grad_image} --colormap jet".format(
grad_image=op.join(workdir, "gradient-{0}.nii.gz".format(i))
)
)
output_dir = op.join(
outdir,
(
f"{dataset_name}_{atlas_name}_{kernel_name}_{sparsity_name}_{gradients_name}_"
f"{affinity_name}_{approach_name}"
)
)
shutil.copytree(workdir, output_dir)
shutil.rmtree(workdir)
title=title,
figure=fig,
colorbar=False)
###############################################################################
# Load brain development fMRI dataset and MSDL atlas
# -------------------------------------------------------------------
# We study only 30 subjects from the dataset, to save computation time.
from nilearn import datasets
rest_data = datasets.fetch_development_fmri(n_subjects=30)
###############################################################################
# We use probabilistic regions of interest (ROIs) from the MSDL atlas.
msdl_data = datasets.fetch_atlas_msdl()
msdl_coords = msdl_data.region_coords
n_regions = len(msdl_coords)
print('MSDL has {0} ROIs, part of the following networks :\n{1}.'.format(
n_regions, msdl_data.networks))
###############################################################################
# Region signals extraction
# -------------------------
# To extract regions time series, we instantiate a
# :class:`nilearn.input_data.NiftiMapsMasker` object and pass the atlas the
# file name to it, as well as filtering band-width and detrending option.
from nilearn import input_data
masker = input_data.NiftiMapsMasker(msdl_data.maps,
resampling_target="data",
def reduce(dataset, output_dir=None, direct=False, source='hcp_rs_concat'):
"""Create a reduced version of a given dataset.
Unmask must be called beforehand"""
memory = Memory(cachedir=get_cache_dirs()[0], verbose=2)
print('Fetch data')
this_dataset_dir = join(get_output_dir(output_dir), 'unmasked', dataset)
masker, X = get_raw_contrast_data(this_dataset_dir)
print('Retrieve components')
if source == 'craddock':
components = fetch_craddock_parcellation().parcellate400
niimgs = masker.inverse_transform(X.values)
label_masker = NiftiLabelsMasker(labels_img=components,
smoothing_fwhm=0,
mask_img=masker.mask_img_).fit()
# components = label_masker.inverse_transform(np.eye(400))
print('Transform and fit data')
Xt = label_masker.transform(niimgs)
else:
if source == 'msdl':
components = [fetch_atlas_msdl()['maps']]
else:
data = fetch_atlas_modl()
if source == 'hcp_rs':
components_imgs = [data.nips2017_components256]
elif source == 'hcp_rs_concat':
components_imgs = [
data.nips2017_components16, data.nips2017_components64,
data.nips2017_components256
]
elif source == 'hcp_336':
components_imgs = [data.nips2017_components336]
elif source == 'hcp_new':
components_imgs = [
data.positive_new_components16,
data.positive_new_components64,
data.positive_new_components128
]
elif source == 'hcp_new_big':
components_imgs = [
data.positive_new_components16,
data.positive_new_components64,
data.positive_new_components512
]
elif source == 'hcp_rs_positive_concat':
components_imgs = [
data.positive_components16, data.positive_components64,
data.positive_components512
]
elif source == 'hcp_new_208':
components_imgs = [data.positive_new_components208]
components = masker.transform(components_imgs)
print('Transform and fit data')
proj, proj_inv, _ = memory.cache(make_projection_matrix)(
components, scale_bases=True)
if direct:
proj = proj_inv.T
Xt = X.dot(proj)
Xt = pd.DataFrame(data=Xt, index=X.index)
this_source = source
if direct:
this_source += '_direct'
this_output_dir = join(get_output_dir(output_dir), 'reduced', this_source,
dataset)
if not os.path.exists(this_output_dir):
os.makedirs(this_output_dir)
print(join(this_output_dir, 'Xt.pkl'))
Xt.to_pickle(join(this_output_dir, 'Xt.pkl'))
dump(masker, join(this_output_dir, 'masker.pkl'))
np.save(join(output_dir, 'components'), components)