def _set_volume_masker(roi_file, as_voxels=False, **kwargs):
"""Check and see if multiple ROIs exist in atlas file"""
if not isinstance(roi_file, str):
raise ValueError('roi_file must be a file name string')
if roi_file.endswith('.csv') or roi_file.endswith('.tsv'):
roi = _read_coords(roi_file)
n_rois = len(roi)
print(' {} region(s) detected from coordinates'.format(n_rois))
if kwargs.get('radius') is None:
warnings.warn('No radius specified for coordinates; setting '
'to nilearn.input_data.NiftiSphereMasker default '
'of extracting from a single voxel')
masker = NiftiSpheresMasker(roi, **kwargs)
elif roi_file.endswith('.nii.gz'):
# remove args for NiftiSpheresMasker
if 'radius' in kwargs:
kwargs.pop('radius')
if 'allow_overlap' in kwargs:
kwargs.pop('allow_overlap')
roi_img = image.load_img(roi_file)
if len(roi_img.shape) == 4:
n_rois = roi_img.shape[-1]
print(' {} region(s) detected from {}'.format(n_rois,
roi_img.get_filename()))
masker = NiftiMapsMasker(roi_img, allow_overlap=True,**kwargs)
else:
n_rois = len(np.unique(roi_img.get_fdata())) - 1
print(' {} region(s) detected from {}'.format(n_rois,
roi_img.get_filename()))
if n_rois > 1:
masker = NiftiLabelsMasker(roi_img, **kwargs)
elif n_rois == 1:
# binary mask for single ROI
if as_voxels:
if 'mask_img' in kwargs:
kwargs.pop('mask_img')
masker = NiftiMasker(roi_img, **kwargs)
else:
# more computationally efficient if only wanting the mean
masker = NiftiLabelsMasker(roi_img, **kwargs)
else:
raise ValueError('No ROI detected; check ROI file')
else:
raise ValueError('Invalid file type for roi_file. Must be one of: '
'.nii.gz, .csv, .tsv')
return masker, n_rois
def make_masker(scheme):
'''
Parameters
----------
scheme : String
The type of parcellation wanted.
Returns
-------
masker: nilearn.input_data.NiftiLabelsMasker
Masker of the chosen scheme.
labels: list
Labels of all the regions in parcellation.
'''
if scheme.lower() == "harvox": # 48 regions
dataset = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm')
atlas_filename = dataset.maps
labels = dataset.labels[1:] # trim off "background" label
masker = NiftiLabelsMasker(labels_img=atlas_filename,
standardize=True,
high_variance_confounds=True,
verbose=1)
elif scheme.lower() == "yeo": # 17 regions
dataset = datasets.fetch_atlas_yeo_2011()
masker = NiftiLabelsMasker(labels_img=dataset['thick_17'],
standardize=True,
high_variance_confounds=True,
verbose=1)
labels = [
"Visual A", "Visual B", "Somatomotor A", "Somatomotor B",
"Dorsal Attention A", "Dorsal Attention B",
"Salience/Ventral Attention A", "Salience/Ventral Attention B",
"Limbic A", "Limbic B", "Control C", "Control A", "Control B",
"Temporal Parietal", "Default C", "Default A", "Default B"
] # list from valerie-jzr
elif scheme.lower() == "aal": # 116 regions
dataset = datasets.fetch_atlas_aal(version='SPM12')
labels = dataset['labels']
masker = NiftiLabelsMasker(labels_img=dataset['maps'],
standardize=True,
high_variance_confounds=True,
verbose=1)
elif scheme.lower() == "schaefer":
dataset = datasets.fetch_atlas_schaefer_2018(n_rois=100,
yeo_networks=17)
labels = dataset['labels']
masker = NiftiLabelsMasker(labels_img=dataset['maps'],
standardize=True,
high_variance_confounds=True,
verbose=1)
return masker, labels
def apply_mask(self, atlas="AAL"):
if atlas == "AAL":
# load atlas
atlas_filename = datasets.fetch_atlas_aal(version="SPM12",
verbose=0).maps
elif atlas == "multiscale":
raise NotImplementedError()
else:
raise ValueError("Altas should be 'AAL' or 'multiscale'")
# set mask
masker = NiftiLabelsMasker(labels_img=atlas_filename,
standardize=True,
detrend=True,
low_pass=0.08,
high_pass=0.01,
t_r=3.7,
memory="nilearn_cache",
verbose=0)
# apply mask to data
confounds = high_variance_confounds(self.fmri_filename,
n_confounds=1,
detrend=True)
ts_hvar = masker.fit_transform(self.fmri_filename, confounds=confounds)
return ts_hvar
def compute_connectivity_subjects(func_list, atlas, mask, conn, n_jobs=-1):
""" Returns connectivities for all subjects
tril matrix n_subjects * n_rois_tril
"""
if len(nib.load(atlas).shape) == 4:
masker = NiftiMapsMasker(maps_img=atlas,
mask_img=mask,
detrend=True,
low_pass=.1,
high_pass=.01,
t_r=3.,
resampling_target='data',
smoothing_fwhm=6,
memory=CACHE_DIR,
memory_level=2)
else:
masker = NiftiLabelsMasker(labels_img=atlas,
mask_img=mask,
t_r=3.,
detrend=True,
low_pass=.1,
high_pass=.01,
resampling_target='data',
smoothing_fwhm=6,
memory=CACHE_DIR,
memory_level=2)
p = Parallel(n_jobs=n_jobs, verbose=5)(delayed(
compute_connectivity_subject)(conn, func, masker)\
for func in func_list)
return np.asarray(p)
def from_fmri_data(
cls,
datafile: str,
atlas: Optional[str] = None,
confounds: Optional[str] = None,
**kwargs,
):
"""Take a 4D dataset and generate signals from the atlas parcels.
"""
if atlas is None:
atlas = MIST_ATLAS_444
kind = "atlas"
else:
kind = "atlas_custom"
# Resampling target should be the image with lowest resolution.
# Assuming that the data resolution is isotropic for now.
atlas_res = nib.load(atlas).header["pixdim"][1]
data_res = nib.load(datafile).header["pixdim"][1]
resampling_target = "data" if data_res > atlas_res else "labels"
masker = NiftiLabelsMasker(labels_img=atlas,
standardize=True,
resampling_target=resampling_target)
signals = masker.fit_transform(datafile)
atlasrois = atlas_roitovol(atlas, nrois=signals.shape[-1])
return cls(timeseries=signals,
maps=atlasrois,
kind=kind,
confounds=confounds,
**kwargs)
def timeSeries(func_files, confound_files, atlas_filename):
# This function receives a list of funcional files and a list of matching confound files
# and outputs an array
from nilearn.input_data import NiftiLabelsMasker
# define masker here
masker = NiftiLabelsMasker(
labels_img=atlas_filename,
standardize=True,
smoothing_fwhm=6,
memory="nilearn_cashe",
t_r=1,
verbose=5,
high_pass=.01,
low_pass=.1
) # As it is task based we dont' bandpassing high_pass=.01 , low_pass = .1)
total_subjects = [
] # creating an empty array that will hold all subjects matrix
# This function needs a masker object that will be defined outside the function
for func_file, confound_file in zip(func_files, confound_files):
print(f"proccessing file {func_file}") # print file name
confoundClean = removeVars(confound_file)
confoundArray = confoundClean #confoundClean.values
time_series = masker.fit_transform(func_file, confounds=confoundArray)
#time_series = extractor.fit_transform(func_file, confounds=confoundArray)
#masker.fit_transform(func_file, confoundArray)
total_subjects.append(time_series)
return total_subjects
def _run_interface(self, runtime):
fname = self.inputs.fmri_denoised
entities = parse_file_entities(fname)
bold_img = nb.load(fname)
parcellation_file = get_parcellation_file_path(entities['space'])
masker = NiftiLabelsMasker(labels_img=parcellation_file,
standardize=True)
time_series = masker.fit_transform(bold_img, confounds=None)
corr_measure = ConnectivityMeasure(kind='correlation')
corr_mat = corr_measure.fit_transform([time_series])[0]
entities['pipeline'] = extract_pipeline_from_path(fname)
conn_file = join(self.inputs.output_dir,
build_path(entities, self.conn_file_pattern, False))
carpet_plot_file = join(
self.inputs.output_dir,
build_path(entities, self.carpet_plot_pattern, False))
matrix_plot_file = join(
self.inputs.output_dir,
build_path(entities, self.matrix_plot_pattern, False))
make_carpetplot(time_series, carpet_plot_file)
mplot = plot_matrix(corr_mat, vmin=-1, vmax=1)
mplot.figure.savefig(matrix_plot_file)
np.save(conn_file, corr_mat)
self._results['corr_mat'] = conn_file
self._results['carpet_plot'] = carpet_plot_file
self._results['matrix_plot'] = matrix_plot_file
return runtime
def __init__(self, data_config, mode="train"):
super(TransoformerDataset, self).__init__(data_config, mode)
self.masker = NiftiLabelsMasker(
labels_img=
f"{data_config.workdir}/input/Schaefer2018_400Parcels_7Networks_order_FSLMNI152_1mm.nii.gz",
standardize=True,
)
def series_times_ROI(Maps, func, typeF):
from nilearn.input_data import NiftiLabelsMasker, NiftiMapsMasker
from nilearn import plotting
import scipy.io as sio
import numpy as np
import os
##################################
Resul = os.getcwd() #+'-Results'
n_map = Maps[Maps.rfind('/') + 1:][:Maps[Maps.rfind('/') + 1:].find('.')]
n_plot = 'empty_plot'
#os.system('mkdir '+Resul)
##################################
if typeF == 'Labels':
masker = NiftiLabelsMasker(labels_img=Maps, standardize=True)
plot_atlas = plotting.plot_roi(Maps)
n_plot = Resul + '/Atlas_' + n_map + '_' + typeF + '.svg'
plot_atlas.savefig(n_plot)
if typeF == 'Maps':
masker = NiftiMapsMasker(maps_img=Maps,
standardize=True,
memory='nilearn_cache',
verbose=5)
time_series = masker.fit_transform(func)
print('Shape of serial times ', np.shape(time_series))
out_mat = Resul + '/Time_series_' + n_map + '_' + typeF + '.mat'
sio.savemat(out_mat, {'time_series': time_series})
return out_mat, n_plot
def connectivity_data():
"""Fixture for connectivity tests."""
base_dir = os.path.abspath(pkg_resources.resource_filename(
"pynets", "../data/examples"))
func_file = f"{base_dir}/BIDS/sub-25659/ses-1/func/" \
f"sub-25659_ses-1_task-rest_space-T1w_desc-preproc_bold.nii.gz"
mask_file = f"{base_dir}/BIDS/sub-25659/ses-1/func/" \
f"sub-25659_ses-1_task-rest_space-T1w_desc-preproc_" \
f"bold_mask.nii.gz"
parcellation = pkg_resources.resource_filename(
"pynets", "templates/atlases/DesikanKlein2012.nii.gz"
)
masker = NiftiLabelsMasker(
labels_img=nib.load(parcellation), background_label=0,
resampling_target="labels", dtype="auto",
mask_img=nib.load(mask_file), standardize=True)
time_series = masker.fit_transform(func_file)
conn_measure = ConnectivityMeasure(
kind="correlation")
conn_matrix = conn_measure.fit_transform([time_series])[0]
[coords, _, _, label_intensities] = \
get_names_and_coords_of_parcels(parcellation)
labels = ['ROI_' + str(idx) for idx, val in enumerate(label_intensities)]
yield {'time_series': time_series, 'conn_matrix': conn_matrix,
'labels': labels, 'coords': coords, 'indices': label_intensities}
def _run_interface(self, runtime):
fname = self.inputs.fmri_denoised
bold_img = nb.load(fname)
masker = NiftiLabelsMasker(labels_img=self.inputs.parcellation,
standardize=True)
time_series = masker.fit_transform(bold_img, confounds=None)
corr_measure = ConnectivityMeasure(kind='correlation')
corr_mat = corr_measure.fit_transform([time_series])[0]
_, base, _ = split_filename(fname)
conn_file = f'{self.inputs.output_dir}/{base}_conn_mat.npy'
carpet_plot_file = join(self.inputs.output_dir,
f'{base}_carpet_plot.png')
matrix_plot_file = join(self.inputs.output_dir,
f'{base}_matrix_plot.png')
create_carpetplot(time_series, carpet_plot_file)
mplot = plot_matrix(corr_mat, vmin=-1, vmax=1)
mplot.figure.savefig(matrix_plot_file)
np.save(conn_file, corr_mat)
self._results['corr_mat'] = conn_file
self._results['carpet_plot'] = carpet_plot_file
self._results['matrix_plot'] = matrix_plot_file
return runtime
def debiasing(data_file, mask, mtx, idx_u, idx_v, tr, out_dir, history_str):
"""
Perform debiasing based on denoised edge-time matrix.
"""
print("Performing debiasing based on denoised edge-time matrix...")
masker = NiftiLabelsMasker(
labels_img=mask,
standardize=False,
memory="nilearn_cache",
strategy="mean",
)
# Read data
data = masker.fit_transform(data_file)
# Generate mask of significant edge-time connections
ets_mask = np.zeros(data.shape)
idxs = np.where(mtx != 0)
time_idxs = idxs[0]
edge_idxs = idxs[1]
print("Generating mask of significant edge-time connections...")
for idx, time_idx in enumerate(time_idxs):
ets_mask[time_idx, idx_u[edge_idxs[idx]]] = 1
ets_mask[time_idx, idx_v[edge_idxs[idx]]] = 1
# Create HRF matrix
hrf = HRFMatrix(
TR=tr,
TE=[0],
nscans=data.shape[0],
r2only=True,
has_integrator=False,
is_afni=True,
)
hrf.generate_hrf()
# Perform debiasing
deb_output = debiasing_spike(hrf, data, ets_mask)
beta = deb_output["beta"]
fitt = deb_output["betafitts"]
# Transform results back to 4D
beta_4D = masker.inverse_transform(beta)
beta_file = join(out_dir, f"{basename(data_file[:-7])}_beta_ETS.nii.gz")
beta_4D.to_filename(beta_file)
atlas_mod.inverse_transform(beta_file, data_file)
subprocess.run(f"3dNotes {join(out_dir, beta_file)} -h {history_str}",
shell=True)
fitt_4D = masker.inverse_transform(fitt)
fitt_file = join(out_dir, f"{basename(data_file[:-7])}_fitt_ETS.nii.gz")
fitt_4D.to_filename(fitt_file)
subprocess.run(f"3dNotes {join(out_dir, fitt_file)} -h {history_str}",
shell=True)
atlas_mod.inverse_transform(fitt_file, data_file)
print("Debiasing finished and files saved.")
return beta, fitt
def _run_interface(self, runtime):
from nilearn import datasets
from nilearn.input_data import NiftiLabelsMasker
import numpy as np
dataset = datasets.fetch_atlas_harvard_oxford(
self.inputs.atlas_identifier)
atlas_filename = dataset.maps
masker = NiftiLabelsMasker(labels_img=atlas_filename,
standardize=True,
detrend=True,
low_pass=0.1,
high_pass=0.01,
t_r=self.inputs.tr,
memory='nilearn_cache',
verbose=0)
#file_labels = open('/home/brainlab/Desktop/Rudas/Data/Parcellation/AAL from Freesourfer/fs_default.txt', 'r')
#labels = []
#for line in file_labels.readlines():
#labels.append(line)
#file_labels.close()
time_series = masker.fit_transform(
self.inputs.in_file, confounds=self.inputs.confounds_file)
np.savetxt(self.inputs.time_series_out_file,
time_series,
fmt='%10.2f',
delimiter=',')
if self.inputs.plot:
from nilearn import plotting
from nilearn.connectome import ConnectivityMeasure
import matplotlib
import matplotlib.pyplot as plt
fig, ax = matplotlib.pyplot.subplots()
font = {'family': 'normal', 'size': 5}
matplotlib.rc('font', **font)
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform(
[time_series])[0]
# Mask the main diagonal for visualization:
np.fill_diagonal(correlation_matrix, 0)
plotting.plot_matrix(correlation_matrix,
figure=fig,
labels=dataset.labels[1:],
vmax=0.8,
vmin=-0.8,
reorder=True)
fig.savefig(self.inputs.correlation_matrix_out_file, dpi=1200)
return runtime
def make_parcellation(data_path, atlas, template='MNI152NLin2009cAsym', atlas_desc=None, resolution=2, parc_params=None, return_meta=False):
"""
Performs a parcellation which reduces voxel space to regions of interest (brain data).
Parameters
----------
data_path : str
Path to .nii image.
atlas : str
Specify which atlas you want to use (see github.com/templateflow/)
template : str
What space you data is in. If fmriprep, leave as MNI152NLin2009cAsym.
atlas_desc : str
Specify which description of atlas.
resolution : int
Resolution of atlas. Can be 1 or 2.
parc_params : dict
**kwargs for nilearn functions.
return_meta : bool
If true, tries to return any meta-information that exists about parcellation.
Returns
-------
data : array
Data after the parcellation.
NOTE
----
These functions make use of nilearn. Please cite templateflow and nilearn if used in a publicaiton.
"""
if not parc_params:
parc_params = {}
tf_get_params = {
'template': template,
'resolution': resolution,
'atlas': atlas
}
if atlas_desc is not None:
tf_get_params['desc'] = atlas_desc
file = tf.get(**tf_get_params, extensions='nii.gz')
if isinstance(file, list):
raise ValueError('More than one template file found. Specify the type of file you need (often atlas_desc). Run: templateflow.api.TF_LAYOUT.get_descs(atlas=' +
atlas + ') to see available desc for atlas')
region = NiftiLabelsMasker(str(file), **parc_params)
data = region.fit_transform(data_path)
if return_meta:
meta_info = tf.get(template=template, atlas=atlas,
desc=atlas_desc, extensions='tsv')
meta_info = load_tabular_file(str(meta_info))
return data, meta_info
else:
return data
def correlation_matrix(ts,atlas, confounds=None, mask=None, loud=False, structure_names=[], save_as='', low_pass=0.25, high_pass=0.004, smoothing_fwhm=.3, ): """Return a CSV file containing correlations between ROIs. Parameters ---------- ts : str Path to the 4D NIfTI timeseries file on which to perform the connectivity analysis. confounds : 2D array OR path to CSV file Array/CSV file containing confounding time-series to be regressed out before FC analysis. atlas : str, optional Path to a 3D NIfTI-like binary label file designating ROIs. structure_names : list, optional Ordered list of all structure names in atlas (length N). save_as : str Path under which to save the Pandas DataFrame conttaining the NxN correlation matrix. """ ts = path.abspath(path.expanduser(ts)) if isinstance(atlas,str): atlas = path.abspath(path.expanduser(atlas)) if mask: mask = path.abspath(path.expanduser(mask)) tr = nib.load(ts).header['pixdim'][0] labels_masker = NiftiLabelsMasker( labels_img=atlas, mask_img=mask, standardize=True, memory='nilearn_cache', verbose=5, low_pass=low_pass, high_pass = high_pass, smoothing_fwhm=smoothing_fwhm, t_r=tr, ) #TODO: test confounds with physiological signals if(confounds): confounds = path.abspath(path.expanduser(confounds)) timeseries = labels_masker.fit_transform(ts, confounds=confounds) else: timeseries = labels_masker.fit_transform(ts) correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform([timeseries])[0] if structure_names: df = pd.DataFrame(columns=structure_names, index=structure_names, data=correlation_matrix) else: df = pd.DataFrame(data=correlation_matrix) if save_as: save_dir = path.dirname(save_as) if not path.exists(save_dir): makedirs(save_dir) df.to_csv(save_as)
def extract_ts(path, atlasPath):
img = image.load_img(path)
template = nilearn.datasets.load_mni152_template()
img_re = image.resample_to_img(img, template, interpolation='linear')
masker = NiftiLabelsMasker(labels_img=atlasPath, standardize=True,
memory='nilearn_cache', verbose=5)
ts = masker.fit_transform(img_re)
return ts
def test_ibma_with_custom_masker(testdata_ibma):
""" Ensure voxel-to-ROI reduction works. """
atlas = op.join(get_test_data_path(), "test_pain_dataset", "atlas.nii.gz")
masker = NiftiLabelsMasker(atlas)
meta = ibma.Fishers(mask=masker)
meta.fit(testdata_ibma)
assert isinstance(meta.results, nimare.results.MetaResult)
assert meta.results.maps["z"].shape == (5, )
def extract_timeseries(filename, atlas_filename, confounds=None):
"""
Wrapper around nilearn masker and fit_transform.
"""
masker = NiftiLabelsMasker(labels_img=atlas_filename, standardize=True)
time_series = masker.fit_transform(filename, confounds=confounds)
return time_series
def _run_interface(self, runtime):
from nilearn.input_data import NiftiLabelsMasker
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import EmpiricalCovariance
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from mne.viz import plot_connectivity_circle
import re
plt.switch_backend('Agg')
# extract timeseries from every label
masker = NiftiLabelsMasker(labels_img=self.inputs.atlas_file,
standardize=True, verbose=1)
timeseries = masker.fit_transform(self.inputs.timeseries_file)
# create correlation matrix
correlation_measure = ConnectivityMeasure(cov_estimator=EmpiricalCovariance(),
kind="correlation")
correlation_matrix = correlation_measure.fit_transform([timeseries])[0]
np.fill_diagonal(correlation_matrix, np.NaN)
# add the atlas labels to the matrix
atlas_lut_df = pd.read_csv(self.inputs.atlas_lut, sep='\t')
regions = atlas_lut_df['regions'].values
correlation_matrix_df = pd.DataFrame(correlation_matrix, index=regions, columns=regions)
# do a fisher's r -> z transform
fisher_z_matrix_df = correlation_matrix_df.apply(lambda x: (np.log(1 + x) - np.log(1 - x)) * 0.5)
# write out the file.
out_file = os.path.join(runtime.cwd, 'fisher_z_correlation.tsv')
fisher_z_matrix_df.to_csv(out_file, sep='\t', na_rep='n/a')
# save the filename in the outputs
self._results['correlation_matrix'] = out_file
# visualizations with mne
connmat = fisher_z_matrix_df.values
labels = list(fisher_z_matrix_df.index)
# define title and outfile names:
trial_regex = re.compile(r'.*trialtype-(?P<trial>[A-Za-z0-9]+)')
title = re.search(trial_regex, self.inputs.timeseries_file).groupdict()['trial']
outfile = os.path.join(runtime.cwd, ".".join([title, "svg"]))
n_lines = int(np.sum(connmat > 0) / 2)
fig = plt.figure(figsize=(5, 5))
plot_connectivity_circle(connmat, labels, n_lines=n_lines, fig=fig, title=title, fontsize_title=10,
facecolor='white', textcolor='black', colormap='jet', colorbar=1,
node_colors=['black'], node_edgecolor=['white'], show=False, interactive=False)
fig.savefig(outfile, dpi=300)
self._results['correlation_fig'] = outfile
return runtime
def prepare_data(data_dir, output_dir, pipeline = "cpac", quality_checked = True):
# get dataset
print("Loading dataset...")
abide = datasets.fetch_abide_pcp(data_dir = data_dir,
pipeline = pipeline,
quality_checked = quality_checked)
# make list of filenames
fmri_filenames = abide.func_preproc
# load atlas
multiscale = datasets.fetch_atlas_basc_multiscale_2015()
atlas_filename = multiscale.scale064
# initialize masker object
masker = NiftiLabelsMasker(labels_img=atlas_filename,
standardize=True,
memory='nilearn_cache',
verbose=0)
# initialize correlation measure
correlation_measure = ConnectivityMeasure(kind='correlation', vectorize=True,
discard_diagonal=True)
try: # check if feature file already exists
# load features
feat_file = os.path.join(output_dir, 'ABIDE_BASC064_features.npz')
X_features = np.load(feat_file)['a']
print("Feature file found.")
except: # if not, extract features
X_features = [] # To contain upper half of matrix as 1d array
print("No feature file found. Extracting features...")
for i,sub in enumerate(fmri_filenames):
# extract the timeseries from the ROIs in the atlas
time_series = masker.fit_transform(sub)
# create a region x region correlation matrix
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# add to our container
X_features.append(correlation_matrix)
# keep track of status
print('finished extracting %s of %s'%(i+1,len(fmri_filenames)))
# Save features
np.savez_compressed(os.path.join(output_dir, 'ABIDE_BASC064_features'),
a = X_features)
# Dimensionality reduction of features with PCA
print("Running PCA...")
pca = PCA(0.99).fit(X_features) # keeping 99% of variance
X_features_pca = pca.transform(X_features)
# Transform phenotypic data into dataframe
abide_pheno = pd.DataFrame(abide.phenotypic)
# Get the target vector
y_target = abide_pheno['DX_GROUP']
return(X_features_pca, y_target)
def _set_masker(roi_file, as_voxels=False, **kwargs):
"""Check and see if multiple ROIs exist in atlas file"""
if isinstance(roi_file, str) and roi_file.endswith('.tsv'):
roi = _read_coords(roi_file)
n_rois = len(roi)
is_coords = True
print(' {} region(s) detected from coordinates'.format(n_rois))
else:
roi = load_img(roi_file)
n_rois = len(np.unique(roi.get_data())) - 1
is_coords = False
print(' {} region(s) detected from {}'.format(n_rois,
roi.get_filename()))
if is_coords:
if kwargs.get('radius') is None:
warnings.warn('No radius specified for coordinates; setting '
'to nilearn.input_data.NiftiSphereMasker default '
'of extracting from a single voxel')
masker = NiftiSpheresMasker(roi, **kwargs)
else:
if 'radius' in kwargs:
kwargs.pop('radius')
if 'allow_overlap' in kwargs:
kwargs.pop('allow_overlap')
if n_rois > 1:
masker = NiftiLabelsMasker(roi, **kwargs)
elif n_rois == 1:
# single binary ROI mask
if as_voxels:
if 'mask_img' in kwargs:
kwargs.pop('mask_img')
masker = NiftiMasker(roi, **kwargs)
else:
# more computationally efficient if only wanting the mean of ROI
masker = NiftiLabelsMasker(roi, **kwargs)
else:
raise ValueError('No ROI detected; check ROI file')
return masker
def test_ibma_with_custom_masker():
""" Ensure voxel-to-ROI reduction works. """
atlas = op.join(get_resource_path(), 'atlases',
'HarvardOxford-cort-maxprob-thr25-2mm.nii.gz')
masker = NiftiLabelsMasker(atlas)
meta = ibma.Fishers(mask=masker)
meta.fit(pytest.dset_z)
assert isinstance(meta.results, nimare.base.MetaResult)
assert meta.results.maps['z'].shape == (48, )
def main(args):
# Set analysis directories
root = '/net/synapse/nt/users/bmacintosh_lab/nluciw/'
# Root directory of data.
data_dir = root + 'data/EnF/sourcedata/'
# Output directory.
output_dir = root + 'outputs/perf_covar/' + args.output_dir
# Create output if does not exist.
if not os.path.exists(os.path.dirname(output_dir)):
os.makedirs(os.path.dirname(output_dir))
# Save command line
with open(output_dir + 'commandline_args.txt', 'w') as f:
f.write('\n'.join(sys.argv[1:]))
# Load 4d nifti objects for both groups
bd_data = fetch_data(data_dir,
args.nifti_name,
metadata=args.metadata,
subject_group=('BD', ))
hc_data = fetch_data(data_dir,
args.nifti_name,
metadata=args.metadata,
subject_group=('HC', ))
hc_vols = concat_imgs(hc_data.imgs)
bd_vols = concat_imgs(bd_data.imgs)
# Construct or load parcellator object using the atlas we specify on
# the command line.
parcellator = NiftiLabelsMasker(labels_img=args.atlas,
mask_img=data_dir +
'masks/cbf_80p_aal_merge_mni.nii.gz',
standardize=False,
strategy='mean')
parcellator.fit()
# Do the parcellation and correlation for both groups.
hc_covar, bd_covar =\
covariance.parcellate_and_correlate([hc_vols,bd_vols],
output_dir,
parcellator,
prefix = args.output_prefix,
detrend=False#,
# pve_gm_imgs=[concat_imgs(hc_data.struc_imgs),
# concat_imgs(bd_data.struc_imgs)]
)
print(len(bd_data.imgs), len(hc_data.imgs))
difference = statistics.compute_difference(bd_covar[0], hc_covar[0],
len(bd_data.imgs),
len(hc_data.imgs))
cors = np.stack((bd_covar[0], hc_covar[0], difference))
np.save(output_dir + args.output_prefix + 'cors', cors)
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(fname, masker_fname, sid, labels, roi_numbers, save_csv=True):
if os.path.isfile(fname) and os.path.isfile(masker_fname):
masker_obj = NiftiLabelsMasker(labels_img=masker_fname,
standardize=True,
memory='nilearn_cache',
verbose=5)
anImg = nib.load(fname)
try:
time_series = masker_obj.fit_transform(anImg)
cormat = connectivity_obj.fit_transform([time_series])[0]
except Exception as e:
print("Problem extracting: ")
print(e)
time_series = None
cormat = None
if time_series is None or cormat is None:
print(
'Could not compute time series for this file, skipping: {}'
.format(fname))
elif save_csv and outpath:
try:
#print(masker_obj.labels_)
masker_labels = np.asarray(masker_obj.labels_)
#print(masker_labels)
#print(roi_numbers)
labels_extracted = np.array(labels)[np.isin(
roi_numbers, masker_labels)]
#print(labels_extracted)
if not (cormat.shape[0] == labels_extracted.shape[0] &
time_series.shape[1] == labels_extracted.shape[0]):
raise Exception(
"Shape of extracted data and implied labels do not match. Labels will be set to 999."
)
except Exception as e:
print("Problem setting labels: ")
print(e)
masker_labels = np.arange(999, 999 + time_series.shape[1],
1)
labels_extracted = masker_labels
if not os.path.isdir(outpath):
raise Exception(
"Cannot find output dir {}".format(outpath))
else:
save_one(fname,
time_series,
cormat,
sid,
labels_extracted,
masker_labels,
outpath,
use_number_labels_only=True)
else:
warnings.warn('Cannot find file(s) {}, {}'.format(
fname, masker_fname))
time_series = []
cormat = []
def staticFC(seedIMG,seedNAME,funcdata,output):
'''
For example:
seedIMG='Thalamus_atlas_regions.nii'
seedNAME="Thalamus_atlas_regions.txt"
'''
masker = NiftiLabelsMasker(labels_img=seedIMG, standardize=True)
my_file = pd.read_table(seedNAME,header=None)
seedname= list(my_file[0])
seed_time_series = masker.fit_transform(funcdata)
# remember to check the TR in this code.
brain_masker = input_data.NiftiMasker(
smoothing_fwhm=6,
detrend=True, standardize=True,
low_pass=0.1, high_pass=0.01, t_r=2,
memory='nilearn_cache', memory_level=1, verbose=2)
brain_time_series = brain_masker.fit_transform(funcdata)
#print("Seed time series shape: (%s, %s)" % seed_time_series.shape)
#print("Brain time series shape: (%s, %s)" % brain_time_series.shape)
seed_to_voxel_correlations = (np.dot(brain_time_series.T, seed_time_series) /
seed_time_series.shape[0]
)
# print("Seed-to-voxel correlation shape: (%s, %s)" %
# seed_to_voxel_correlations.shape)
# print("Seed-to-voxel correlation: min = %.3f; max = %.3f" % (
# seed_to_voxel_correlations.min(), seed_to_voxel_correlations.max()))
seed_to_voxel_correlations_img = brain_masker.inverse_transform(
seed_to_voxel_correlations.T)
seed_to_voxel_correlations_fisher_z = np.arctanh(seed_to_voxel_correlations)
# Finally, we can tranform the correlation array back to a Nifti image
# object, that we can save.
seed_to_voxel_correlations_fisher_z_img = brain_masker.inverse_transform(
seed_to_voxel_correlations_fisher_z.T)
#seed_to_voxel_correlations_fisher_z_img.to_filename('seed_correlation_z.nii.gz')
IM=funcs.four_to_three(seed_to_voxel_correlations_fisher_z_img)
for i,M in enumerate(IM):
outdir=f'{output}/{seedname[i]}/seedFC'
if not os.path.exists(outdir):
os.makedirs(outdir)
subname=os.path.basename(funcdata)[:-4]
if not os.path.exists(f'{outdir}/{subname}_SFC_Z.nii.gz'):
M.to_filename(f'{outdir}/{subname}_SFC_Z.nii.gz')
else:
print('Existed')
def comp_timeseries(item):
print("Computing time-series for:", item)
# Get filepaths
bold_fp = WORKDIR + ("sub-{0:0>3}/ses-{1}/func/" \
"sub-{0:0>3}_ses-{1}_task-{2}_run-{3}_space-MNI152NL"
"in2009cAsym_desc-preproc_bold.nii.gz") \
.format(item[0], item[1].lower(), item[2], item[3])
conf_fp = WORKDIR + ("sub-{0:0>3}/ses-{1}/func/" \
"sub-{0:0>3}_ses-{1}_task-{2}_run-{3}_desc-confounds_"
"regressors.tsv") \
.format(item[0], item[1].lower(), item[2], item[3])
# Load the image and drop first n frames
func_img = image.index_img(image.load_img(bold_fp), slice(CUTOFF, None))
# Load confounds
confounds = pd.read_csv(conf_fp, sep='\t') \
.loc[CUTOFF:, [
"a_comp_cor_00",
"a_comp_cor_01",
"a_comp_cor_02",
"a_comp_cor_03",
"a_comp_cor_04",
"a_comp_cor_05",
"global_signal",
"white_matter",
"csf",
"trans_x",
"trans_y",
"trans_z",
'rot_x',
'rot_y',
'rot_z']]
# Create parcellation object with additional pre-processing parameters
willard_mask = NiftiLabelsMasker(willard_img,
detrend=True,
t_r=0.802,
low_pass=0.1,
high_pass=0.01,
standardize=True,
memory=HOMEDIR + 'cache',
memory_level=1)
# Process and perform parcellation
roi_time_series = willard_mask.fit_transform(func_img,
confounds=confounds.values)
# Write into csv
csv_data = pd.DataFrame(roi_time_series)
csv_data.to_csv(OUTDIR + "sub-{0:0>3}_ses-{1}_task-{2}_run-" \
"{3}.csv".format(item[0], item[1].lower(), item[2], item[3]),
header=False, index=False)
def post_processed_data(atlas_data, regressors):
"""A post-processed version of the atlas_data, which is generated directly
by nilearn rather than niimasker. The results from niimasker should
directly match what is produced by nilearn.
"""
labels_img = _get_atlas()['maps']
masker = NiftiLabelsMasker(labels_img, standardize=True, smoothing_fwhm=5,
detrend=True, low_pass=.1, high_pass=.01, t_r=2)
confounds = regressors.values
return masker.fit_transform(atlas_data, confounds=confounds)
def cal_connectome(fmri_ff,
confound_ff,
atlas_ff,
outputjpg_ff,
metric='correlation',
labelrange=None,
label_or_map=0):
if label_or_map == 0:
# “correlation”, “partial correlation”, “tangent”, “covariance”, “precision”
masker = NiftiLabelsMasker(labels_img=atlas_ff,
standardize=True,
verbose=0)
else:
masker = NiftiMapsMasker(maps_img=atlas_ff,
standardize=True,
verbose=0)
time_series_0 = masker.fit_transform(fmri_ff, confounds=confound_ff)
if labelrange is None:
labelrange = np.arange(time_series_0.shape[1])
time_series = time_series_0[:, labelrange]
if metric == 'sparse inverse covariance':
try:
estimator = GraphLassoCV()
estimator.fit(time_series)
correlation_matrix = -estimator.precision_
except:
correlation_matrix = np.zeros(
(time_series.shape[1], time_series.shape[1]))
else:
correlation_measure = ConnectivityMeasure(kind=metric)
correlation_matrix = correlation_measure.fit_transform([time_series
])[0]
# Plot the correlation matrix
fig = plt.figure(figsize=(6, 5), dpi=100)
plt.clf()
# Mask the main diagonal for visualization:
np.fill_diagonal(correlation_matrix, 0)
plt.imshow(correlation_matrix,
interpolation="nearest",
cmap="RdBu_r",
vmax=0.8,
vmin=-0.8)
plt.gca().yaxis.tick_right()
plt.axis('off')
plt.colorbar()
plt.title(metric.title(), fontsize=12)
plt.tight_layout()
fig.savefig(outputjpg_ff, bbox_inches='tight')
plt.close()
return correlation_matrix
def _vectorize_nii(in_data_file, mask_file, parcellation_path, fwhm):
from nilearn.input_data import NiftiMasker, NiftiLabelsMasker
import nibabel as nib
if parcellation_path is None:
masker = NiftiMasker(mask_img=mask_file, smoothing_fwhm=fwhm)
else:
masker = NiftiLabelsMasker(labels_img=parcellation_path,
smoothing_fwhm=fwhm)
vectorized_data = masker.fit_transform(in_data_file)
return vectorized_data, masker
