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 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)
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
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
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
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
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 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')
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
"""
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 _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
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')
####################################################################
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
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_
# 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