def get_masker_coord(filename): if 'BASC' in filename: basc = datasets.fetch_atlas_basc_multiscale_2015(version='sym')['scale444'] filename=basc nib_basc444 = nib.load(basc) labels_data = nib_basc444.get_data() else: nib_parcel = nib.load(filename) labels_data = nib_parcel.get_data() #fetch all possible label values all_labels = np.unique(labels_data) # remove the 0. value which correspond to voxels out of ROIs all_labels = all_labels[1:] # bari_labels = np.zeros((all_labels.shape[0],3)) # ## go through all labels # for i,curlabel in enumerate(all_labels): # vox_in_label = np.stack(np.argwhere(labels_data == curlabel)) # bari_labels[i] = vox_in_label.mean(axis=0) # allcoords=[] for i,curlabel in enumerate(all_labels): img_curlab = math_img(formula="img==%d"%curlabel,img=filename) allcoords.append(find_xyz_cut_coords(img_curlab)) allcoords=np.array(allcoords) return allcoords
def participant_level(args, subjects_to_analyze): # The subject level analysis: extract time-series per subject # Retrieve the atlas atlas_data = datasets.fetch_atlas_basc_multiscale_2015() atlas_filename = atlas_data.scale122 # find all RS scans and extract time-series on them for subject_label in subjects_to_analyze: for fmri_file in glob( os.path.join(args.bids_dir, "derivatives", "sub-%s" % subject_label, "func", "*_hmc_mni.nii.gz")): masker = input_data.NiftiLabelsMasker(labels_img=atlas_filename, standardize=True, detrend=True, verbose=3) time_series = masker.fit_transform(fmri_file) out_file = os.path.split(fmri_file)[-1].replace( "_hmc_mni.nii.gz", "_time_series.tsv") out_file = os.path.join(args.output_dir, out_file) np.savetxt(out_file, time_series, delimiter='\t') estimator = covariance.LedoitWolf(store_precision=True) estimator.fit(time_series) out_file = os.path.split(fmri_file)[-1].replace( "_hmc_mni.nii.gz", "_connectome.tsv") out_file = os.path.join(args.output_dir, out_file) np.savetxt(out_file, estimator.precision_, delimiter='\t')
def plot_atlas(): ############################################################################### # Retrieving multiscale group brain parcellations # ----------------------------------------------- from nilearn.datasets import MNI152_FILE_PATH print('Path to MNI152 template: %r' % MNI152_FILE_PATH) parcellations = datasets.fetch_atlas_basc_multiscale_2015(version='sym') # We show here networks of 64, 197, 444 networks_64 = parcellations['scale064'] networks_197 = parcellations['scale197'] networks_444 = parcellations['scale444'] ############################################################################### # Visualizing brain parcellations # ------------------------------- # The coordinates of all plots are selected automatically by itself # We manually change the colormap of our choice plotting.plot_roi(networks_64, cmap=plotting.cm.bwr, title='64 regions of brain clusters') plotting.plot_roi(networks_197, cmap=plotting.cm.bwr, title='197 regions of brain clusters') plotting.plot_roi(networks_444, cmap=plotting.cm.bwr_r, title='444 regions of brain clusters') plotting.show()
def fetch_basc_vascular_atlas(n_scales='scale007', target_affine=np.diag((5, 5, 5))): """ Fetch the BASC brain atlas given its resolution. Parameters ---------- hrf_atlas: str, BASC dataset name possible values are: 'scale007', 'scale012', 'scale036', 'scale064', 'scale122', 'scale197', 'scale325', 'scale444' target_affine : np.array, (default=np.diag((5, 5, 5))), affine matrix for the produced Nifti images Return ------ mask_full_brain : Nifti Image, full mask brain atlas_rois : Nifti Image, ROIs atlas """ if n_scales not in valid_scales: raise ValueError(f"n_scales should be in {valid_scales}, " f"got '{n_scales}'") basc_dataset = datasets.fetch_atlas_basc_multiscale_2015(version='sym') atlas_rois_fname = basc_dataset[n_scales] atlas_to_return = image.load_img(atlas_rois_fname) atlas_to_return = image.resample_img(atlas_to_return, target_affine, interpolation='nearest') brain_mask = image_nilearn.binarize_img(atlas_to_return, threshold=0) return brain_mask, atlas_to_return
def make_masker(atlas, dim, mask): mem = Memory(location=expanduser('cache')) masker_params = dict( mask_img=mask, smoothing_fwhm=5, memory=mem, memory_level=1, standardize=True, detrend=True, t_r=2, low_pass=0.01, high_pass=None, verbose=0, ) if atlas in ['difumo']: if atlas == 'difumo': maps_img = fetch_difumo(dimension=dim).maps masker = OurNiftiMasker(maps_img=maps_img, reduction='maps', **masker_params) elif atlas in ['basc']: if atlas == 'basc': basc = fetch_atlas_basc_multiscale_2015() this_labels_img = basc[f'scale{dim:03.0f}'] masker = OurNiftiMasker(label_img=this_labels_img, reduction='labels', **masker_params) elif atlas == 'none': masker = OurNiftiMasker(reduction=None, **masker_params) else: raise ValueError('Wrong atlas argument') masker.fit() masker_geom = NiftiMasker(mask_img=mask).fit() return masker, masker_geom
def fetch_atlas_basc_2015(n_scales='scale007'): """ Fetch the BASC brain atlas given its resolution. Parameters ---------- hrf_atlas: str, BASC dataset name possible values are: 'scale007', 'scale012', 'scale036', 'scale064', 'scale122' Return ------ mask_full_brain : Nifti Image, full mask brain atlas_rois : Nifti Image, ROIs atlas """ if n_scales not in ['scale007', 'scale012', 'scale036', 'scale064', 'scale122']: raise ValueError("n_scales should be in ['scale007', 'scale012', " "'scale036', 'scale064', 'scale122'], " "got '{}'".format(n_scales)) basc_dataset = datasets.fetch_atlas_basc_multiscale_2015(version='sym') atlas_rois_fname = basc_dataset[n_scales] atlas_to_return = image.load_img(atlas_rois_fname) # compute the full brain mask (0/1 Nifti object) brain_mask = np.ones_like(atlas_to_return.get_fdata()) brain_mask[atlas_to_return.get_fdata() == 0] = 0 return image.new_img_like(atlas_to_return, brain_mask), atlas_to_return
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 fetch_atlas_basc_multiscale_2015(args): ds = datasets.fetch_atlas_basc_multiscale_2015(**args) scales = [7, 12, 20, 36, 64, 122, 197, 325, 444] files = [] for scale in scales: files.append(ds['scale{:03d}'.format(scale)]) df = pd.DataFrame({'scale': scales, 'path':files}) return df
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 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 extract_timeseries(func, atlas=fetch_atlas_basc_multiscale_2015().scale064, confounds=None, memory=None, memory_level=1, duration=None): """Extract time series for a list of functional volume. Parameters ---------- func : str, Path of Nifti volumes. atlas : str or 3D/4D Niimg-like object, (default=BASC64) The atlas to use to create the masker. If string, it should corresponds to the path of a Nifti image. confounds : str, Path containing the confounds. memory : instance of joblib.Memory or string, (default=None) Used to cache the masking process. By default, no caching is done. If a string is given, it is the path to the caching directory. memory_level : integer, optional (default=1) Rough estimator of the amount of memory used by caching. Higher value means more memory for caching. duration : float The duration of timeseries to be extracted, measured in seconds. """ TR = 1.992 # s masker = make_masker_from_atlas(atlas, memory=memory, memory_level=memory_level) masker.fit() if confounds is not None: confounds_ = np.loadtxt(confounds) else: confounds_ = None func_img = nib.load(func) if duration is not None: # how many slices to keep n_slices = int(duration / TR) func_img = func_img.slicer[:, :, :, :n_slices] if confounds_ is not None: confounds_ = confounds_[:n_slices, :] return masker.transform(func_img, confounds=confounds_)
def extract_timeseries(func, atlas=fetch_atlas_basc_multiscale_2015().scale064, confounds=None, memory=None, memory_level=1): """Extract time series for a list of functional volume. Parameters ---------- func : str, Path of Nifti volumes. atlas : str or 3D/4D Niimg-like object, (default=BASC64) The atlas to use to create the masker. If string, it should corresponds to the path of a Nifti image. confounds : str, Path containing the confounds. memory : instance of joblib.Memory or string, (default=None) Used to cache the masking process. By default, no caching is done. If a string is given, it is the path to the caching directory. memory_level : integer, optional (default=1) Rough estimator of the amount of memory used by caching. Higher value means more memory for caching. n_jobs : integer, optional (default=1) Used to process several patients in parallel. If -1, then the number of jobs is set to the number of cores. """ masker = make_masker_from_atlas(atlas, memory=memory, memory_level=memory_level) masker.fit() if confounds is not None: confounds_ = np.loadtxt(confounds) else: confounds_ = None return masker.transform(func, confounds=confounds_)
def parcelation(filename): from nilearn import plotting from nilearn import datasets parcellations = datasets.fetch_atlas_basc_multiscale_2015(version='sym') networks_64 = parcellations['scale064'] networks_197 = parcellations['scale197'] networks_444 = parcellations['scale444'] x0, y0 = 580, 300 img = nib.load(filename) data_orig = img.get_fdata()[..., 1] #misc.face() print(data_orig.shape) fig, axes = plt.subplots(1, 2) axes[0].imshow(data_orig) axes[0].scatter(x0, y0, c="r") axes[0].set_title("original") data_rot, (x1, y1) = rot(data_orig, np.array([x0, y0]), 66) axes.flatten()[1].imshow(data_rot) axes.flatten()[1].scatter(x1, y1, c="r") axes.flatten()[1].set_title("Rotation: {}deg".format(66)) plt.show() plotting.plot_roi(img, cmap=plotting.cm.bwr_r, title='yale imaging') plotting.show()
def get_masker_coord(atlasname): """ Get coordinates of parcellation (3D) from a brain atlas image defined by labels (integers) Parameters: --------- atlasname : string - pathway of the atlas OR is atlas is BASC tuple or list as filename[0]='BASC' filename[1]='sym' or 'asym' filename[2]= str of nb of parcel (version): '444' """ if 'BASC' in atlasname: basc = datasets.fetch_atlas_basc_multiscale_2015( version=atlasname[1])['scale' + atlasname[2]] atlasname = basc nib_parcel = nib.load(atlasname) labels_data = nib_parcel.get_data() #fetch all possible label values all_labels = np.unique(labels_data) # remove the 0. value which correspond to voxels out of ROIs all_labels = all_labels[1:] # bari_labels = np.zeros((all_labels.shape[0],3)) # ## go through all labels # for i,curlabel in enumerate(all_labels): # vox_in_label = np.stack(np.argwhere(labels_data == curlabel)) # bari_labels[i] = vox_in_label.mean(axis=0) # allcoords = [] for i, curlabel in enumerate(all_labels): img_curlab = math_img(formula="img==%d" % curlabel, img=atlasname) allcoords.append(find_xyz_cut_coords(img_curlab)) allcoords = np.array(allcoords) return allcoords
def fetch_resample_basc(mask, scale="444"): from nilearn.datasets import fetch_atlas_basc_multiscale_2015 from nilearn.image import resample_to_img basc = fetch_atlas_basc_multiscale_2015()['scale{}'.format(scale)] resampled_basc = resample_to_img(basc, mask, interpolation='nearest') return resampled_basc
from nilearn.datasets import fetch_atlas_basc_multiscale_2015 import joblib from joblib import Parallel, delayed, Memory # path to the Cam-CAN data set STORAGE_HOME = '/storage/tompouce/okozynet/camcan' CAMCAN_PREPROCESSED = '/storage/data/camcan/camcan_preproc' CAMCAN_PATIENTS_EXCLUDED = join(STORAGE_HOME, 'excluded_patients.csv') CAMCAN_TIMESERIES = join(STORAGE_HOME, 'timeseries') # path to the atlases # modl atlas from task-fMRI was used ATLASES = [ '/storage/store/derivatives/OpenNeuro/modl/256/0.0001/maps.nii.gz', fetch_atlas_basc_multiscale_2015().scale197 ] ATLASES_DESCR = ['modl256', 'basc197'] # path for the caching CACHE_TIMESERIES = join(STORAGE_HOME, 'cache/timeseries') if not os.path.exists(CACHE_TIMESERIES): os.makedirs(CACHE_TIMESERIES) MEMORY = Memory(CACHE_TIMESERIES) N_JOBS = 10 dataset = load_camcan_rest(data_dir=CAMCAN_PREPROCESSED, patients_excluded=CAMCAN_PATIENTS_EXCLUDED) for atlas, atlas_descr in zip(ATLASES, ATLASES_DESCR): time_series = Parallel(n_jobs=N_JOBS, verbose=1)(
from nilearn import datasets from nilearn import image import nibabel as nib import nympy as np import pickle as pkl basc = datasets.fetch_atlas_basc_multiscale_2015() basc444 = nib.load(basc.scale444) yeo = datasets.fetch_atlas_yeo_2011() yeo7 = nib.load(yeo.thick_7) template = datasets.load_mni152_template() basc_re = image.resample_to_img(basc444, template, interpolation='nearest') yeo_re = image.resample_to_img(yeo7, template, interpolation='nearest') yeo_data = yeo_re.get_fdata()[:,:,:,0] basc_data = basc_re.get_fdata() inde = [] for i in range(1,445): li = list(np.unique(yeo_data[basc_data == i])) nu = [len(np.argwhere(yeo_data[basc_data == i] == j)) for j in li] inde.append(li[nu.index(max(nu))]) inde = np.array(inde)
import os.path import scipy.io as sio suj=89 meas=20 # Load Conditions file eventname='F:/sim/event_sim.csv' label=np.array(np.recfromcsv(eventname,names='s'))['s'] # Create session file rest_mask = label == b'Rest' # Prepare masker & Correct affine template = load_mni152_template() basc = datasets.fetch_atlas_basc_multiscale_2015(version='sym')['scale444'] orig_filename='F:/sim/template/restbaseline.nii.gz' orig_img= image.load_img(orig_filename) brainmask = load_mni152_brain_mask() mem = Memory('nilearn_cache') masker = NiftiLabelsMasker(labels_img = basc, mask_img = brainmask, memory=mem, memory_level=1, verbose=0, detrend=False, standardize=False, high_pass=0.01,t_r=2, resampling_target='labels') masker.fit() # Prep Classification for s in np.arange(84,89):#range(suj):# for n in range(meas):
def copy_atlas(): if not os.path.exists(ATLAS_DIR): os.makedirs(ATLAS_DIR) atlas_filename = datasets.fetch_atlas_basc_multiscale_2015().scale122 shutil.copy(atlas_filename, os.path.join(ATLAS_DIR, ATLAS_FILENAME))
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_labelled_atlas(query, data_dir=None, return_labels=True): """Parses input query to determine which atlas to fetch and what version of the atlas to use (if applicable). Parameters ---------- query : str Input string in the following format: nilearn:{atlas_name}:{atlas_parameters}. The following can be for `atlas_name`: 'destrieux', 'yeo', 'aal', 'talairach', and 'schaefer'. `atlas_parameters` is not available for the `destrieux` atlas. data_dir : str, optional Directory in which to save atlas data. By default None, which creates a ~/nilearn_data/ directory as per nilearn. return_labels : bool, optional Whether to return atlas labels. Default is True. Not available for the 'basc' atlas. Returns ------- str, list or None The atlas image and the accompanying labels (if provided) Raises ------ ValueError Raised when the query does is not formatted correctly or if the no match found. """ # extract parameters params = query.split(':') if len(params) == 3: _, atlas_name, sub_param = params elif len(params) == 2: _, atlas_name = params sub_param = None else: raise ValueError('Incorrect atlas query string provided') # get atlas if atlas_name == 'destrieux': atlas = fetch_atlas_destrieux_2009(lateralized=True, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'yeo': atlas = fetch_atlas_yeo_2011(data_dir=data_dir) img = atlas[sub_param] if '17' in sub_param: labels = pd.read_csv(atlas['colors_17'], sep=r'\s+')['NONE'].tolist() elif atlas_name == 'aal': version = 'SPM12' if sub_param is None else sub_param atlas = fetch_atlas_aal(version=version, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'basc': version, scale = sub_param.split('-') atlas = fetch_atlas_basc_multiscale_2015(version=version, data_dir=data_dir) img = atlas['scale{}'.format(scale.zfill(3))] labels = None elif atlas_name == 'talairach': atlas = fetch_atlas_talairach(level_name=sub_param, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'schaefer': n_rois, networks, resolution = sub_param.split('-') # corrected version of schaefer labels until fixed in nilearn correct_url = ('https://raw.githubusercontent.com/ThomasYeoLab/CBIG/' 'v0.14.3-Update_Yeo2011_Schaefer2018_labelname/' 'stable_projects/brain_parcellation/' 'Schaefer2018_LocalGlobal/Parcellations/MNI/') atlas = fetch_atlas_schaefer_2018(n_rois=int(n_rois), yeo_networks=int(networks), resolution_mm=int(resolution), data_dir=data_dir, base_url=correct_url) img = atlas['maps'] labels = atlas['labels'] else: raise ValueError('No atlas detected. Check query string') if not return_labels: labels = None else: labels = labels.astype(str).tolist() return img, labels
func_imgs = data_store[name].func phenotypic = data_store[name].phenotypic motion_confounds = data_store[name].motion_param connectome_regress_confounds = None from utils import data_info shape, affine, _ = data_info(func_imgs[0]) ########################################################################### # Predefined Atlases # ------------------ # Fetch the atlas from nilearn import datasets as nidatasets basc = nidatasets.fetch_atlas_basc_multiscale_2015() # Define atlases for LearnBrainRegions object as dict() atlases = dict() from region_extractor import connected_label_regions relabelled_basc_36 = connected_label_regions(basc['scale036'], min_size=1500) atlases['basc'] = relabelled_basc_36 ########################################################################### # Masker # ------ # Masking the data from nilearn import datasets
This example shows how to download and fetch brain parcellations of multiple networks using :func:`nilearn.datasets.fetch_atlas_basc_multiscale_2015` and visualize them using plotting function :func:`nilearn.plotting.plot_roi`. We show here only three different networks of 'symmetric' version. For more details about different versions and different networks, please refer to its documentation. """ ############################################################################### # Fetching multiscale group brain parcellations # import datasets module and use `fetch_atlas_basc_multiscale_2015` function from nilearn import datasets parcellations = datasets.fetch_atlas_basc_multiscale_2015(version='sym') # We show here networks of 64, 197, 444 networks_64 = parcellations['scale064'] networks_197 = parcellations['scale197'] networks_444 = parcellations['scale444'] ############################################################################### # Visualizing brain parcellations # import plotting module and use `plot_roi` function, since the maps are in 3D from nilearn import plotting # The coordinates of all plots are selected automatically by itself # We manually change the colormap of our choice plotting.plot_roi(networks_64, cmap=plotting.cm.bwr,
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) for atlas, atlas_descr in zip(ATLASES, ATLASES_DESCR):
# documentation. # # # Retrieving multiscale group brain parcellations # ----------------------------------------------- # # # In[2]: # import datasets module and use `fetch_atlas_basc_multiscale_2015` function from nilearn import datasets parcellations = datasets.fetch_atlas_basc_multiscale_2015(version='sym') # We show here networks of 64, 122, 197 networks_64 = parcellations['scale064'] networks_122 = parcellations['scale122'] networks_197 = parcellations['scale197'] # Visualizing brain parcellations # ------------------------------- # # # In[3]:
groups=np.append(groups,np.ones(len(y_foot))*i) # CROSS MODAL CLASSIFICATION (cross-validated) #n_p=0 #result_cv_tr_foot,permutation_scores_tr_foot, p_foot=permutation_score(pipeline,roi_foot_all,roi_hand_all,y_foot_all,groups,logo,n_p) #print('Train FOOT - IMAG VS STIM',np.array(result_cv_tr_foot).mean(),p_foot) #result_cv_tr_hand,permutation_scores_tr_hand, p_hand=permutation_score(pipeline,roi_hand_all,roi_foot_all,y_hand_all,groups,logo,n_p) #print('Train HAND - IMAG VS STIM',np.array(result_cv_tr_hand).mean(),p_hand) #result_cv_tr_imag,permutation_scores_tr_imag, p_imag=permutation_score(pipeline,roi_imag_all,roi_stim_all,y_imag_all,groups,logo,n_p) #print('Train IMAG - HAND VS FOOT',np.array(result_cv_tr_imag).mean(),p_imag) #result_cv_tr_stim,permutation_scores_tr_stim, p_stim=permutation_score(pipeline,roi_stim_all,roi_imag_all,y_stim_all,groups,logo,n_p) #print('Train STIM - HAND VS FOOT',np.array(result_cv_tr_stim).mean(),p_stim) # Prepare ploting basc = datasets.fetch_atlas_basc_multiscale_2015(version='asym')['scale444'] brainmask = load_mni152_brain_mask() masker = NiftiLabelsMasker(labels_img = basc, mask_img = brainmask, memory_level=1, verbose=0, detrend=True, standardize=False, high_pass=0.01,t_r=2.28, resampling_target='labels' ) masker.fit() pipeline.fit(roi_foot_all,y_foot_all) coef_foot = pipeline.named_steps['svm'].coef_ weight_f = masker.inverse_transform(coef_foot) plot_stat_map(weight_f, title='Train Imp',display_mode='z',cmap='bwr',threshold=0.4)