def main():
"""Make reports."""
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(run_report,
n_jobs=config.get_n_jobs())
logs = parallel(
run_func(cfg=get_config(subject=subject),
subject=subject,
session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
sessions = config.get_sessions()
if not sessions:
sessions = [None]
if (config.get_task() is not None
and config.get_task().lower() == 'rest'):
msg = ' … skipping "average" report for "rest" task.'
logger.info(**gen_log_kwargs(message=msg))
return
for session in sessions:
run_report_average(cfg=get_config(subject='average'),
subject='average',
session=session)
def run_group_average_source(*, cfg, subject='average'):
"""Run group average in source space"""
mne.datasets.fetch_fsaverage(subjects_dir=config.get_fs_subjects_dir())
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(morph_stc,
n_jobs=config.get_n_jobs())
all_morphed_stcs = parallel(
run_func(cfg=cfg,
subject=subject,
fs_subject=config.get_fs_subject(subject),
session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
mean_morphed_stcs = np.array(all_morphed_stcs).mean(axis=0)
# XXX to fix
sessions = config.get_sessions()
if sessions:
session = sessions[0]
else:
session = None
run_average(cfg=cfg,
session=session,
mean_morphed_stcs=mean_morphed_stcs)
def main():
# Ensure we're also processing fsaverage if present
subjects = config.get_subjects()
if (Path(config.get_fs_subjects_dir()) / 'fsaverage').exists():
subjects.append('fsaverage')
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(make_coreg_surfaces,
n_jobs=config.get_n_jobs())
parallel(run_func(get_config(), subject) for subject in subjects)
def main():
"""Run epochs."""
# Here we use fewer n_jobs to prevent potential memory problems
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(run_epochs,
n_jobs=max(
config.get_n_jobs() // 4, 1))
logs = parallel(
run_func(cfg=get_config(subject, session),
subject=subject,
session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
def main():
"""Run epochs."""
parallel, run_func, _ = parallel_func(drop_ptp, n_jobs=config.get_n_jobs())
with config.get_parallel_backend():
logs = parallel(
run_func(cfg=get_config(), subject=subject, session=session)
for subject, session in
itertools.product(
config.get_subjects(),
config.get_sessions()
)
)
config.save_logs(logs)
def main():
"""Apply ICA."""
if not config.spatial_filter == 'ica':
msg = 'Skipping …'
logger.info(**gen_log_kwargs(message=msg))
return
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(apply_ica,
n_jobs=config.get_n_jobs())
logs = parallel(
run_func(cfg=get_config(), subject=subject, session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
def main():
"""Initialize the output directories."""
msg = 'Running: Initializing output directories.'
logger.info(**gen_log_kwargs(message=msg))
with config.get_parallel_backend():
init_dataset(cfg=get_config())
parallel, run_func, _ = parallel_func(init_subject_dirs,
n_jobs=config.get_n_jobs())
parallel(
run_func(cfg=get_config(), subject=subject, session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
msg = 'Completed: Initializing output directories.'
logger.info(**gen_log_kwargs(message=msg))
def main() -> None:
"""Run freesurfer recon-all command on BIDS dataset.
The script allows to run the freesurfer recon-all
command on all subjects of your BIDS dataset. It can
run in parallel with the --n_jobs parameter.
It is built on top of the FreeSurfer BIDS app:
https://github.com/BIDS-Apps/freesurfer
and the MNE BIDS Pipeline
https://mne.tools/mne-bids-pipeline
You must have freesurfer available on your system.
Run via the MNE BIDS Pipeline's `run.py`:
python run.py --steps=freesurfer --config=your_pipeline_config.py
""" # noqa
logger.info('Running FreeSurfer')
subjects = config.get_subjects()
root_dir = config.get_bids_root()
subjects_dir = Path(config.get_fs_subjects_dir())
subjects_dir.mkdir(parents=True, exist_ok=True)
with config.get_parallel_backend():
n_jobs = config.get_n_jobs()
parallel, run_func, _ = parallel_func(run_recon, n_jobs=n_jobs)
parallel(run_func(root_dir, subject, fs_bids_app)
for subject in subjects)
# Handle fsaverage
fsaverage_dir = subjects_dir / 'fsaverage'
if fsaverage_dir.exists():
if fsaverage_dir.is_symlink():
fsaverage_dir.unlink()
else:
shutil.rmtree(fsaverage_dir)
env = os.environ
shutil.copytree(f"{env['FREESURFER_HOME']}/subjects/fsaverage",
subjects_dir / 'fsaverage')
def main():
"""Run forward."""
if not config.run_source_estimation:
msg = ' … skipping: run_source_estimation is set to False.'
logger.info(**gen_log_kwargs(message=msg))
return
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(run_forward,
n_jobs=config.get_n_jobs())
logs = parallel(
run_func(cfg=get_config(subject=subject),
subject=subject,
session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
def main():
"""Run maxwell_filter."""
if not config.use_maxwell_filter:
msg = 'Skipping …'
logger.info(**gen_log_kwargs(message=msg))
return
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(run_maxwell_filter,
n_jobs=config.get_n_jobs())
logs = parallel(
run_func(cfg=get_config(subject, session),
subject=subject,
session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
def main():
"""Run cov."""
if not config.run_source_estimation:
msg = ' … skipping: run_source_estimation is set to False.'
logger.info(**gen_log_kwargs(message=msg))
return
if config.noise_cov == "ad-hoc":
msg = ' … skipping: using ad-hoc diagonal covariance.'
logger.info(**gen_log_kwargs(message=msg))
return
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(run_covariance,
n_jobs=config.get_n_jobs())
logs = parallel(
run_func(cfg=get_config(), subject=subject, session=session)
for subject, session in itertools.product(config.get_subjects(),
config.get_sessions()))
config.save_logs(logs)
def main():
"""Run filter."""
with config.get_parallel_backend():
parallel, run_func, _ = parallel_func(filter_data,
n_jobs=config.get_n_jobs())
# Enabling different runs for different subjects
sub_run_ses = []
for subject in config.get_subjects():
sub_run_ses += list(
itertools.product([subject], config.get_runs(subject=subject),
config.get_sessions()))
logs = parallel(
run_func(cfg=get_config(subject),
subject=subject,
run=run,
session=session) for subject, run, session in sub_run_ses)
config.save_logs(logs)
def run_time_decoding(*, cfg, subject, condition1, condition2, session=None):
msg = f'Contrasting conditions: {condition1} – {condition2}'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
fname_epochs = BIDSPath(subject=subject,
session=session,
task=cfg.task,
acquisition=cfg.acq,
run=None,
recording=cfg.rec,
space=cfg.space,
suffix='epo',
extension='.fif',
datatype=cfg.datatype,
root=cfg.deriv_root,
check=False)
epochs = mne.read_epochs(fname_epochs)
if cfg.analyze_channels:
# We special-case the average reference here to work around a situation
# where e.g. `analyze_channels` might contain only a single channel:
# `concatenate_epochs` below will then fail when trying to create /
# apply the projection. We can avoid this by removing an existing
# average reference projection here, and applying the average reference
# directly – without going through a projector.
if 'eeg' in cfg.ch_types and cfg.eeg_reference == 'average':
epochs.set_eeg_reference('average')
else:
epochs.apply_proj()
epochs.pick(cfg.analyze_channels)
# We define the epochs and the labels
if isinstance(cfg.conditions, dict):
epochs_conds = [cfg.conditions[condition1], cfg.conditions[condition2]]
cond_names = [condition1, condition2]
else:
epochs_conds = cond_names = [condition1, condition2]
epochs_conds = [condition1, condition2]
epochs = mne.concatenate_epochs(
[epochs[epochs_conds[0]], epochs[epochs_conds[1]]])
n_cond1 = len(epochs[epochs_conds[0]])
n_cond2 = len(epochs[epochs_conds[1]])
X = epochs.get_data()
y = np.r_[np.ones(n_cond1), np.zeros(n_cond2)]
with config.get_parallel_backend():
clf = make_pipeline(
StandardScaler(),
LogReg(solver='liblinear', random_state=cfg.random_state,
n_jobs=1))
se = SlidingEstimator(clf,
scoring=cfg.decoding_metric,
n_jobs=cfg.n_jobs)
from sklearn.model_selection import StratifiedKFold
cv = StratifiedKFold(shuffle=True)
scores = cross_val_multiscore(se, X=X, y=y, cv=cv, n_jobs=1)
# let's save the scores now
a_vs_b = f'{cond_names[0]}+{cond_names[1]}'.replace(op.sep, '')
processing = f'{a_vs_b}+{cfg.decoding_metric}'
processing = processing.replace('_', '-').replace('-', '')
fname_mat = fname_epochs.copy().update(suffix='decoding',
processing=processing,
extension='.mat')
savemat(fname_mat, {'scores': scores, 'times': epochs.times})
fname_tsv = fname_mat.copy().update(extension='.tsv')
tabular_data = pd.DataFrame(
dict(cond_1=[cond_names[0]] * len(epochs.times),
cond_2=[cond_names[1]] * len(epochs.times),
time=epochs.times,
mean_crossval_score=scores.mean(axis=0),
metric=[cfg.decoding_metric] * len(epochs.times)))
tabular_data.to_csv(fname_tsv, sep='\t', index=False)
