def get_ICA_parcellation(map_files, mask_loc, working_dir, second_level_dir, n_comps=20, smoothing=4.4, filename=None): try: map_files = flatten(map_files.values()) except AttributeError: pass group_mask = nibabel.load(mask_loc) ## get components canica = CanICA( mask=group_mask, n_components=n_comps, smoothing_fwhm=smoothing, memory=path.join(working_dir, "nilearn_cache"), memory_level=2, threshold=3., verbose=10, random_state=0) # multi-level components modeling across subjects canica.fit(map_files) masker = canica.masker_ components_img = masker.inverse_transform(canica.components_) if filename is not None: prefix = filename + '_' components_img.to_filename( path.join(second_level_dir, 'parcellation', '%scanica%s.nii.gz' % (prefix, n_comps))) return components_img
def run(args=None, config=None): parser = AnalysisParser('config') args = parser.parse_analysis_args(args) config = args.config subs = ['CoRe_011', 'CoRe_023', 'CoRe_054', 'CoRe_079', 'CoRe_082', 'CoRe_087', 'CoRe_094', 'CoRe_100', 'CoRe_107', 'CoRe_155', 'CoRe_192', 'CoRe_195', 'CoRe_220', 'CoRe_235', 'CoRe_267', 'CoRe_268'] base_path = '/media/sf_hcp/sleepdata/' for sb_i in np.arange(0,len(subs)): sb_i=1 sb = subs[sb_i] day1_fmri = glob.glob(base_path + sb + '/proc/*nii') day1_vmrk = glob.glob(base_path + sb + '/proc/*Day*1*_N*vmrk') print(day1_fmri) fmri = nib.load(day1_fmri[0]) canica = CanICA(n_components=40, smoothing_fwhm=6., threshold=None, verbose=10, random_state=0) fmri_info = helpers.fmri_info(day1_fmri[0]) canica.fit(fmri) cimg = canica.components_img_.get_data() TR = fmri_info[0] tr_times = np.arange(0, 30, TR) hrf = helpers.get_hrf(tr_times) # %matplotlib auto for i in np.arange(0,40): plt.subplot(4,10,i+1) plt.imshow(np.max(cimg[:,:,:,i],axis=2)) plt.title(str(i)) # in order: DMN, auditory, visual, lingual, parietal, striatal, thalamic comps = [35,28,30,39,8,9,32] allcomp_ts = canica.transform([fmri])[0].transpose() comps_ts = allcomp_ts[comps,:] network_labs = ['DMN','auditory','visual','lingual', 'parietal','striatal','thalamic'] for i in np.arange(0,len(comps)): plt.subplot(2,5,i+1) plt.imshow(np.max(cimg[:,:,:,comps[i]],axis=2)) plt.title(network_labs[i]) np.save(str.replace(day1_fmri[0],'.nii','_comps'), comps_ts)
def _estimate_atlas_weights(self, images, params): nii_images, nii_mask = convert_images_nifti(images) bg_offset = 1 if params.get('force_bg', False) else 1 canica = CanICA(mask=nii_mask, n_components=params.get('nb_labels') - bg_offset, # - 1 mask_strategy='background', threshold='auto', n_init=5, n_jobs=1, verbose=0) canica.fit(nii_images) components = np.argmax(canica.components_, axis=0) + bg_offset # + 1 atlas = components.reshape(images[0].shape) atlas = segmentation.relabel_sequential(atlas)[0] weights = [weights_image_atlas_overlap_major(img, atlas) for img in self._images] weights = np.array(weights) return atlas, weights, None
class roi_time_series: def __init__(self, canica=None): self.canica = None def _set_ICA(self, imgs, n_components=20, verbose=0): self.canica = CanICA(n_components=n_components, smoothing_fwhm=6., memory="nilearn_cache", memory_level=2, threshold=3., verbose=verbose, random_state=0) self._fit_ICA(imgs) def _fit_ICA(self, imgs): self.canica.fit(imgs) def get_mask(self, component=0): return np.argwhere(image.index_img(self.canica.components_img_, component)._dataobj.astype('bool') == True) def get_ROI_time_series(self, imgs, component=0, n_components=20, verbose=False): #smooth image fmri_original = image.load_img(imgs) fmri_img = image.smooth_img(fmri_original, fwhm=6) #perform ICA and get components if(self.canica == None): if(verbose): print("New ICA computation") self._set_ICA(fmri_img, n_components=n_components) components_img = self.canica.components_img_ #build masker roi_masker = NiftiMasker(mask_img=image.index_img(components_img, component), standardize=True, memory="nilearn_cache", smoothing_fwhm=8) return _apply_mask(imgs, roi_masker.mask_img)
def fit_CanICA(imgs, params): """Interface of CanICA.""" defaults = { 'n_components': 10, 'memory': "nilearn_cache", 'memory_level': 2, 'threshold': 3., 'n_init': 1, 'verbose': 1, 'mask_strategy': 'template', 'n_jobs': -2 } context = dict(defaults, **params) return CanICA(**context).fit(imgs)
return subject_niimg subject_niimg = load_subject(func_img, mask_niimg) func_filenames = subject_filename # list of 4D nifti files for each subject # print basic information on the dataset print('First functional nifti image (4D) is at: %s' % func_filenames) # 4D data from nilearn.decomposition import CanICA canica = CanICA(n_components=20, memory="nilearn_cache", memory_level=2, verbose=10, mask_strategy='template', random_state=0) canica.fit(func_filenames) # Retrieve the independent components in brain space. Directly # accesible through attribute `components_img_`. canica_components_img = canica.components_img_ # components_img is a Nifti Image object, and can be saved to a file with # the following line: canica_components_img.to_filename( '/home/bk/Desktop/bkrest/canica_resting_state.nii.gz') from nilearn.plotting import plot_prob_atlas # Plot all ICA components together
mean_C_matrix_yeo_S2R1 = C_matrices_yeo_S2R1.mean print('Mean correlation has shape {0}.'.format(mean_C_matrix_yeo_S2R1)) mean_C_matrix_sch_S2R1 = C_matrices_sch_S2R1.mean print('Mean correlation has shape {0}.'.format(mean_C_matrix_sch_S2R1)) mean_PC_matrix_yeo_S2R1 = PC_matrices_yeo_S2R1.mean print('Mean correlation has shape {0}.'.format(mean_PC_matrix_yeo_S2R1)) mean_PC_matrix_sch_S2R1 = PC_matrices_sch_S2R1.mean print('Mean correlation has shape {0}.'.format(mean_PC_matrix_sch_S2R1)) ##### Deriving our own ICA components ##### from nilearn.decomposition import CanICA canica = CanICA(n_components=7, smoothing_fwhm=5., memory="nilearn_cache", memory_level=2, threshold=5., verbose=10, random_state=0) canica.fit(path_img_S2R1) #Saving the components as Nifti components_img = canica.components_img_ components_img.to_filename('/Volumes/Harddrive_CTS/MRI/Placebo_1_Analysis/canica_resting_state.nii.gz') #Visualize all components on a plot %matplotlib gtk from nilearn.plotting import plot_prob_atlas import matplotlib.pyplot as plt from nilearn import plotting plot_prob_atlas(components_img, title='All 7 ICA components') # Mapping components each ICA seperately from nilearn.image import iter_img from nilearn.plotting import plot_stat_map, show for i, cur_img in enumerate(iter_img(components_img)):
n_components = 40 ############################################################################### # Dictionary learning dict_learning = DictLearning(n_components=n_components, memory="nilearn_cache", memory_level=2, verbose=1, random_state=0, n_epochs=1) ############################################################################### # CanICA canica = CanICA(n_components=n_components, memory="nilearn_cache", memory_level=2, threshold=3., n_init=1, verbose=1) ############################################################################### # Fit both estimators estimators = [dict_learning, canica] names = {dict_learning: 'DictionaryLearning', canica: 'CanICA'} components_imgs = [] for estimator in estimators: print('[Example] Learning maps using %s model' % names[estimator]) estimator.fit(func_filenames) print('[Example] Saving results') # Decomposition estimator embeds their own masker masker = estimator.masker_
f = open(subject_file, 'r') nifti_list = [] for line in f: nifti_list.append(line.rstrip()) f.close() # movement regressors ## TBD! # Initialize ICA object canica = CanICA(n_components=n_components, memory="nilearn_cache", memory_level=2, threshold=None, n_init=10, verbose=1, mask_strategy='epi', smoothing_fwhm=6, detrend=True, high_pass=0.008, t_r=0.72) ## Run ICA start = time.time() print("RUNNING ICA") canica.fit(nifti_list) end = time.time() print('Elapsed time %f' % (end - start))
animal_id = os.path.basename(os.path.dirname(anat)) registrator.output_dir = os.path.join('ica', animal_id) registrator.fit_anat(anat) registrator.fit_modality(func, 'func', t_r=1., voxel_size=(.3, .3, .3), prior_rigid_body_registration=True) registered_funcs.append(registrator.registered_func_) ############################################################################## # Run ICA # ------- from nilearn.decomposition import CanICA canica = CanICA(n_components=30, smoothing_fwhm=.3, n_jobs=-1) canica.fit(registered_funcs) ############################################################################## # Retrieve the independent components in brain space. components_img = canica.masker_.inverse_transform(canica.components_) ############################################################################## # Visualize the components # ------------------------ # We can plot the outline of all components on one figure. from nilearn import plotting plotting.plot_prob_atlas(components_img, bg_img=registrator.template_brain_, display_mode='z',
from nilearn import datasets adhd_dataset = datasets.fetch_adhd(n_subjects=30) func_filenames = adhd_dataset.func # list of 4D nifti files for each subject # print basic information on the dataset print('First functional nifti image (4D) is at: %s' % func_filenames[0]) # 4D data #################################################################### # Here we apply CanICA on the data from nilearn.decomposition import CanICA canica = CanICA(n_components=20, smoothing_fwhm=6., memory="nilearn_cache", memory_level=5, threshold=3., verbose=10, random_state=0) canica.fit(func_filenames) # Retrieve the independent components in brain space components_img = canica.masker_.inverse_transform(canica.components_) # components_img is a Nifti Image object, and can be saved to a file with # the following line: components_img.to_filename('canica_resting_state.nii.gz') #################################################################### # To visualize we plot the outline of all components on one figure from nilearn.plotting import plot_prob_atlas # Plot all ICA components together
def _run_interface(self, runtime): algorithm = get_trait_value(self.inputs, 'algorithm', default='canica') mask = get_trait_value(self.inputs, 'mask') n_components = get_trait_value(self.inputs, 'n_components') do_cca = get_trait_value(self.inputs, 'do_cca') smoothing_fwhm = get_trait_value(self.inputs, 'smoothing_fwhm', default=None) standardize = get_trait_value(self.inputs, 'standardize', default=None) threshold = get_trait_value(self.inputs, 'threshold', default=None) random_state = get_trait_value(self.inputs, 'random_state', default=None) n_init = get_trait_value(self.inputs, 'n_init') n_jobs = get_trait_value(self.inputs, 'n_jobs') n_epochs = get_trait_value(self.inputs, 'n_epochs') alpha = get_trait_value(self.inputs, 'alpha') memory = get_trait_value(self.inputs, 'memory') memory_level = get_trait_value(self.inputs, 'memory_level') confounds = get_trait_value(self.inputs, 'confounds') # init the estimator if algorithm == 'canica': self._estimator = CanICA( mask=mask, n_components=n_components, threshold=threshold, random_state=random_state, standardize=standardize, smoothing_fwhm=smoothing_fwhm, do_cca=do_cca, verbose=1, n_init=n_init, memory=memory, memory_level=memory_level, n_jobs=n_jobs, ) elif algorithm == 'dictlearning': self._estimator = DictLearning( mask=mask, n_components=n_components, random_state=random_state, standardize=standardize, smoothing_fwhm=smoothing_fwhm, verbose=1, n_epochs=n_epochs, alpha=alpha, memory=memory, memory_level=memory_level, n_jobs=n_jobs, ) # set output file names self._estimator_name = algorithm self._confounds = confounds self._reconstructed_img_file = '{}_resting_state.nii.gz'.format( self._estimator_name) self._score_file = '{}_score.txt'.format(self._estimator_name) self._loading_file = '{}_{}_loading.txt' # fit and transform self._estimator.fit(self.inputs.in_files, confounds=self._confounds) self._score = self._estimator.score(self.inputs.in_files, confounds=self._confounds) self._loadings = self._estimator.transform(self.inputs.in_files, confounds=self._confounds) return runtime
def _set_ICA(self, imgs, n_components=20, verbose=0): self.canica = CanICA(n_components=n_components, smoothing_fwhm=6., memory="nilearn_cache", memory_level=2, threshold=3., verbose=verbose, random_state=0) self._fit_ICA(imgs)
import os from loader import load_dynacomp, set_data_base_dir, set_figure_base_dir from nilearn.decomposition import CanICA from nilearn.plotting import plot_stat_map from nilearn.image import iter_img dataset = load_dynacomp() func = dataset.func1 n_components = 20 canica = CanICA(n_components=n_components, mask=dataset.mask, smoothing_fwhm=None, do_cca=True, threshold=3., n_init=10, standardize=True, random_state=42, n_jobs=2, verbose=2) CANICA_PATH = set_data_base_dir('Dynacomp/canica') output_file = os.path.join(CANICA_PATH, 'canica_' + str(n_components) + '.nii.gz') if not os.path.isfile(output_file): canica.fit(func) components_img = canica.masker_.inverse_transform(canica.components_) components_img.to_filename(output_file) else: components_img = output_file
from sklearn.metrics import accuracy_score # perform an ICA given the subset of the data. ica = CanICA(n_components=20, random_state=0) ica.fit(img) components_img=ica.components_img_ plot_prob_atlas(components_img, title='All ICA components') plt.show() components_img_1st=image.index_img(components_img, 0) ica_time_series=create_mask(components_img_1st, img) ica_cor_matrix=calc_correlation_matrix(ica_time_series) plot_cor_matrix(ica_cor_matrix, 'ICA correlation matrix') '''Now let's take a look at the Schizophrenic subject to compare'''
# utilities from nilearn import datasets adhd_dataset = datasets.fetch_adhd(n_subjects=20) func_filenames = adhd_dataset.func confounds = adhd_dataset.confounds ################################################################################ # Canonical ICA decomposition of functional datasets by importing CanICA from # decomposition module from nilearn.decomposition import CanICA # Initialize canica parameters canica = CanICA(n_components=5, smoothing_fwhm=6., memory="nilearn_cache", memory_level=2, random_state=0) # Fit to the data canica.fit(func_filenames) # ICA maps components_img = canica.masker_.inverse_transform(canica.components_) # Visualization # Show ICA maps by using plotting utilities from nilearn import plotting plotting.plot_prob_atlas(components_img, view_type='filled_contours', title='ICA components')
######################################################################### # Preprocessing #func_data_filename = os.path.join(data_dir, func_data_filename) #sub_img = index_img(load_img(func_data_filename), slice(idx_start, None)) #sub_img.to_filename(os.path.join(data_dir,"func.nii")) subject_data = do_subjects_preproc(jobfile, dataset_dir=data_dir)[0] fmri_img = load_img(subject_data.func[0]) ######################################################################### # ICA analysis ica_output_dir = os.path.join(output_dir, "ica") if not os.path.exists(ica_output_dir): os.makedirs(ica_output_dir) canica = CanICA(n_components=20, smoothing_fwhm=6., memory="nilearn_cache", memory_level=2, threshold=0.6, verbose=10, random_state=random_state) canica.fit(fmri_img) components_img = canica.masker_.inverse_transform(canica.components_) for i, cur_img in enumerate(iter_img(components_img)): display = niplt.plot_stat_map(cur_img, cut_coords=pcc_coords, title="IC {0}".format(i)) display.savefig(os.path.join(ica_output_dir, "ica_n_{0}.png".format(i))) cur_img.to_filename( os.path.join(ica_output_dir, "ica_n_{0}.nii.gz".format(i)))
def run(args=None, config=None): parser = AnalysisParser('config') args = parser.parse_analysis_args(args) config = args.config eeg_path = '/media/sf_shared/graddata/ica_denoised_raw.fif' fmri_path = '/media/sf_shared/CoRe_011/rfMRI/d2/11-BOLD_Sleep_BOLD_Sleep_20150824220820_11.nii' vmrk_path = '/media/sf_shared/CoRe_011/eeg/CoRe_011_Day2_Night_01.vmrk' event_ids, event_lats = helpers.read_vmrk(vmrk_path) event_lats = np.array(event_lats) grad_inds = [ index for index, value in enumerate(event_ids) if value == 'R1' ] grad_inds = np.array(grad_inds) grad_lats = event_lats[grad_inds] grad_lats = grad_lats / 20 # resample from 5000Hz to 250Hz start_ind = int(grad_lats[0]) end_ind = int(grad_lats[-1]) canica = CanICA(n_components=40, smoothing_fwhm=6., threshold=None, verbose=10, random_state=0) fmri = nib.load(fmri_path) # get TR, n_slices, and n_TRs fmri_info = helpers.fmri_info(fmri_path) canica.fit(fmri) cimg = canica.components_img_.get_data() TR = fmri_info[0] tr_times = np.arange(0, 30, TR) hrf = get_hrf(tr_times) # plot components for i in np.arange(0, 40): plt.subplot(4, 10, i + 1) plt.imshow(np.max(cimg[:, :, :, i], axis=2)) # get the EEG raw = mne.io.read_raw_fif(eeg_path, preload=True) raw_data = raw.get_data() # get power spectrum for different sleep stages (BOLD) comps = canica.transform([fmri])[0].transpose() bold_srate = 1 / fmri_info[0] bold_epochl = int(7500 / (250 / bold_srate)) #bold_pxx,bold_f = pxx_bold_component_epoch(comps, bold_srate, 250, bold_epochl, sleep_stages) #eeg_pxx,eeg_f = pxx_eeg_epochs(raw_data, sleep_stages, 7500) # concatenate the epochs, then compute the psd # 1) get triggers, 2) concatenate data, 3) compute psd def get_trigger_inds(trigger_name, event_ids): trig_inds = [ index for index, value in enumerate(event_ids) if value == trigger_names[trig] ] return trig_inds def epoch_triggers(raw_data, lats, pre_samples, post_samples): epochs = np.zeros( (raw_data.shape[0], lats.shape[0], pre_samples + post_samples)) for lat in np.arange(0, lats.shape[0]): epochs[:, lat, :] = raw_data[:, lats[lat] - pre_samples:lats[lat] + post_samples] return epochs trigger_names = ['wake', 'NREM1', 'NREM2', 'NREM3'] """ epoch BOLD and get power for different trigger types what you actually want is single trial EEG and BOLD psd first get all the indices that are contained within the BOLD timeseries then, get the EEG power spectrum values within those same indices """ eeg_srate = 250 bold_pre_samples = 15 bold_post_samples = 25 eeg_pre_samples = int(bold_pre_samples * fmri_info[0] * eeg_srate) eeg_post_samples = int(bold_post_samples * fmri_info[0] * eeg_srate) bold_conversion = eeg_srate / (1 / fmri_info[0]) all_bold_epochs = [] all_eeg_epochs = [] for trig in np.arange(0, len(trigger_names)): trig_inds = get_trigger_inds(trigger_names[trig], event_ids) trig_lats = event_lats[trig_inds] bold_lats = ((trig_lats - start_ind) / bold_conversion).astype(int) bads = np.where((bold_lats - bold_pre_samples < 0) | (bold_lats + bold_post_samples >= comps.shape[1])) bold_lats = np.delete(bold_lats, bads, axis=0) eeg_lats = np.delete(trig_lats, bads, axis=0) bold_epochs = epoch_triggers(comps, bold_lats, bold_pre_samples, bold_post_samples) eeg_epochs = epoch_triggers(raw_data, eeg_lats, eeg_pre_samples, eeg_post_samples) all_bold_epochs.append(bold_epochs) all_eeg_epochs.append(eeg_epochs) # comput power for i in np.arange(0, len(all_eeg_epochs)): eeg_epochs = all_eeg_epochs[i] bold_epochs = all_bold_epochs[i] bold_f, bold_pxx = signal.welch(bold_epochs) eeg_f, eeg_pxx = signal.welch(eeg_epochs) gauss = signal.gaussian(eeg_srate, 20) gauss = gauss / np.sum(gauss) freqs = np.zeros((5, 2)) freqs[0, 0] = 1 freqs[0, 1] = 3 freqs[1, 0] = 4 freqs[1, 1] = 7 freqs[2, 0] = 8 freqs[2, 1] = 15 freqs[3, 0] = 17 freqs[3, 1] = 30 freqs[4, 0] = 30 freqs[4, 1] = 80 chan_freqs = filter_and_downsample(raw_data, comps, freqs, start_ind, end_ind) conved = convolve_chanfreqs(np.log(chan_freqs), hrf) # epoch all the hrf-convolved filtered EEG power all_conved_epochs = [] for trig in np.arange(0, len(trigger_names)): trig_inds = get_trigger_inds(trigger_names[trig], event_ids) trig_lats = event_lats[trig_inds] bold_lats = ((trig_lats - start_ind) / bold_conversion).astype(int) bads = np.where((bold_lats - bold_pre_samples < 0) | (bold_lats + bold_post_samples >= comps.shape[1])) bold_lats = np.delete(bold_lats, bads, axis=0) conved_epochs = np.zeros( (conved.shape[0], conved.shape[1], bold_lats.shape[0], bold_pre_samples + bold_post_samples)) for i in np.arange(0, conved.shape[1]): conved_epochs[:, i, :] = epoch_triggers(conved[:, i, :], bold_lats, bold_pre_samples, bold_post_samples) all_conved_epochs.append(conved_epochs) sig1 = chan_freqs[3, 2, :] sig2 = comps[0, :] sig2 = butter_bandpass_filter(sig2, 0.005, 0.1, 1 / fmri_info[0]) nlags = 50 def xcorr(sig1, sig2, nlags): vec_l = sig1.shape[0] - nlags xcorrs = np.zeros(nlags) vec1 = sig1[int(sig1.shape[0] / 2 - vec_l / 2):int(sig1.shape[0] / 2 + vec_l / 2)] start_p = 0 for i in np.arange(0, nlags): vec2 = sig2[(start_p + i):(start_p + vec_l + i)] xcorrs[i] = np.corrcoef(vec1, vec2)[0, 1] return xcorrs all_xcorrs = [] for i in np.arange(0, len(all_conved_epochs)): xc_i = np.zeros( (1, all_conved_epochs[i].shape[1], all_conved_epochs[i].shape[2], all_bold_epochs[i].shape[0], 20)) for j in np.arange(0, 1): print(j) for k in np.arange(0, all_conved_epochs[i].shape[1]): for el in np.arange(0, all_conved_epochs[i].shape[2]): for m in np.arange(0, all_bold_epochs[i].shape[0]): xc_i[j, k, el, m, :] = xcorr(all_conved_epochs[i][5, k, el, :], all_bold_epochs[i][m, el, :], 20) all_xcorrs.append(xc_i) plt.plot(np.mean(all_xcorrs[1][0, 1, :, 0, :], axis=0)) plt.plot(np.mean(all_xcorrs[2][0, 1, :, 0, :], axis=0)) plt.plot(np.mean(all_xcorrs[3][0, 1, :, 0, :], axis=0)) # correlate power across different epochs """
update_experiment(local_config, args.config) split = experiment["split"] # Extract resting-state networks with CanICA # --------------------------------- if (args.canica): from nilearn.decomposition import CanICA logger.info("Canica algorithm starting...") canica = CanICA(n_components=args.n_components, smoothing_fwhm=args.fwhm, memory_level=2, threshold=3., verbose=args.verbose, random_state=0, n_jobs=args.n_jobs, t_r=TR, standardize=args.standarize, high_pass=args.highpass, low_pass=args.lowpass) canica.fit(func_filenames, confounds=confounds_components) # Retrieve the independent components in brain space components_img = canica.masker_.inverse_transform(canica.components_) # components_img is a Nifti Image object, and can be saved to a file with # the following line: canica_dir = data_dir + '/' + split + '/' + 'canica' create_dir(canica_dir) filename = canica_dir + '/' + fwhm + '_resting_state_all.nii.gz' # save components image
@author: mr243268 """ import os from loader import load_dynacomp, set_data_base_dir, set_figure_base_dir from nilearn.decomposition import CanICA from nilearn.plotting import plot_stat_map from nilearn.image import iter_img dataset = load_dynacomp() func = dataset.func1 n_components = 20 canica = CanICA(n_components=n_components, mask=dataset.mask, smoothing_fwhm=None, do_cca=True, threshold=3., n_init=10, standardize=True, random_state=42, n_jobs=2, verbose=2) CANICA_PATH = set_data_base_dir('Dynacomp/canica') output_file = os.path.join(CANICA_PATH, 'canica_' + str(n_components) + '.nii.gz') if not os.path.isfile(output_file): canica.fit(func) components_img = canica.masker_.inverse_transform(canica.components_) components_img.to_filename(output_file) else: components_img = output_file FIG_PATH = set_figure_base_dir('canica')
def run_canica_subject( sub_id, cond_id='D1_D5', ds_dir='/data/BnB_USER/oliver/somato', out_basedir='/home/homeGlobal/oli/somato/scratch/ica/CanICA', ncomps=50, smoothing=3, caa=True, standard=True, detr=True, highpass=.01953125, tr=2., masktype='epi', ninit=10, seed=42, verb=10): """ Run Nilearn's CanICA on a single condition of a single subject. """ # load example image bold_file = pjoin(ds_dir, sub_id, cond_id, 'data.nii.gz') bold_img = load_img(bold_file) # paths to output out_dir = pjoin(out_basedir, sub_id, cond_id) if not os.path.exists(out_dir): os.makedirs(out_dir) out_comp_nii = pjoin(out_dir, 'components.nii.gz') out_components_arr = pjoin(out_dir, 'components.npy') out_png = pjoin(out_dir, 'components_probatlas.png') # set up ica ica = CanICA(n_components=ncomps, smoothing_fwhm=smoothing, do_cca=caa, standardize=standard, detrend=detr, mask_strategy=masktype, high_pass=highpass, t_r=tr, n_init=ninit, random_state=seed, verbose=verb) # more interesting arguments # mask_strategy='mni_something, mask_args=see nilearn.masking.compute_epi_mask, threshold=3. # fit ica ica.fit(bold_img) # save components as 4d nifti components_img = ica.components_img_ components_img.to_filename(out_comp_nii) # plot components as prob atlas and save plot g = plot_prob_atlas(components_img, bg_img=mean_img(bold_img)) g.savefig(out_png, dpi=300) # save components as 2d np array components_arr = ica.components_ np.save(out_components_arr, components_arr) # save automatically generated epi mask if masktype == 'epi': mask_img = ica.mask_img_ out_mask_img = pjoin(out_dir, 'mask_img.nii.gz') mask_img.to_filename(out_mask_img) return ica # return ica object for later use
adhd_dataset = datasets.fetch_adhd(n_subjects=30) func_filenames = adhd_dataset.func # list of 4D nifti files for each subject # print basic information on the dataset print('First functional nifti image (4D) is at: %s' % func_filenames[0]) # 4D data #################################################################### # Here we apply CanICA on the data # --------------------------------- from nilearn.decomposition import CanICA canica = CanICA(n_components=20, smoothing_fwhm=6., memory="nilearn_cache", memory_level=2, threshold=3., verbose=10, random_state=0) canica.fit(func_filenames) # Retrieve the independent components in brain space. Directly # accesible through attribute `components_img_`. Note that this # attribute is implemented from version 0.4.1. For older versions, # see note section above for details. components_img = canica.components_img_ # components_img is a Nifti Image object, and can be saved to a file with # the following line: components_img.to_filename('canica_resting_state.nii.gz') ####################################################################
# to slightly faster and more reproducible results. However, the images # need to be in MNI template space dict_learning = DictLearning(n_components=n_components, memory="nilearn_cache", memory_level=2, verbose=1, random_state=0, n_epochs=1, mask_strategy='template') ############################################################################### # CanICA # ------ canica = CanICA(n_components=n_components, memory="nilearn_cache", memory_level=2, threshold=3., n_init=1, verbose=1, mask_strategy='template') ############################################################################### # Fit both estimators # -------------------- estimators = [dict_learning, canica] names = {dict_learning: 'DictionaryLearning', canica: 'CanICA'} components_imgs = [] for estimator in estimators: print('[Example] Learning maps using %s model' % names[estimator]) estimator.fit(func_filenames) print('[Example] Saving results')
def _run_interface(self, runtime): from nilearn.decomposition import CanICA, DictLearning from nilearn.plotting import plot_stat_map, plot_prob_atlas from nilearn.image import iter_img from nilearn.input_data import NiftiMapsMasker import numpy as np canica = CanICA(n_components=self.inputs.n_components, smoothing_fwhm=None, low_pass=self.inputs.low_pass, high_pass=self.inputs.high_pass, t_r=self.inputs.tr, do_cca=True, detrend=True, standardize=True, threshold='auto', random_state=0, n_jobs=2, memory_level=2, memory="nilearn_cache") canica.fit(self.inputs.in_file, confounds=self.inputs.confounds_file) # canica.fit(self.inputs.in_file) components_img = canica.components_img_ components_img.to_filename('descomposition_canica.nii.gz') # plot_prob_atlas(components_img, title='All ICA components') masker = NiftiMapsMasker(maps_img=components_img, standardize=True, memory='nilearn_cache', verbose=5) time_series_ica = masker.fit_transform(self.inputs.in_file) np.savetxt('time_series_ica.csv', np.asarray(time_series_ica), delimiter=',') for i, cur_img in enumerate(iter_img(components_img)): display = plot_stat_map(cur_img, display_mode="ortho", colorbar=True) display.savefig('ica_ic_' + str(i + 1) + '.png') display.close() dict_learning = DictLearning(n_components=self.inputs.n_components, smoothing_fwhm=None, low_pass=self.inputs.low_pass, high_pass=self.inputs.high_pass, t_r=self.inputs.tr, detrend=True, standardize=True, random_state=0, n_jobs=-2, memory_level=2, memory="nilearn_cache", mask_strategy = 'template') dict_learning.fit(self.inputs.in_file, confounds=self.inputs.confounds_file) components_img = dict_learning.components_img_ components_img.to_filename('descomposition_dict.nii.gz') for i, cur_img in enumerate(iter_img(components_img)): display = plot_stat_map(cur_img, display_mode="ortho", colorbar=True) display.savefig('dic_ic_' + str(i + 1) + '.png') display.close() return runtime