def _mne_to_dict_evoked(eeg): # Try loading mne try: import mne except ImportError: raise ImportError( "NeuroKit error: eeg_add_channel(): the 'mne' module is required for this function to run. ", "Please install it first (`pip install mne`).", ) if not isinstance(eeg, list): eeg = [eeg] data = {} old_verbosity_level = mne.set_log_level(verbose="WARNING", return_old_level=True) for i, evoked in enumerate(eeg): df = evoked.to_data_frame() df.index = evoked.times # Add info info = pd.DataFrame({"Label": [i] * len(df)}) info["Condition"] = evoked.comment info["Time"] = evoked.times info.index = evoked.times data[i] = pd.concat([info, df], axis=1) mne.set_log_level(old_verbosity_level) return data
def _mne_to_dict_epochs(eeg): # Try loading mne try: import mne except ImportError: raise ImportError( "NeuroKit error: eeg_add_channel(): the 'mne' module is required for this function to run. ", "Please install it first (`pip install mne`).", ) data = {} old_verbosity_level = mne.set_log_level(verbose="WARNING", return_old_level=True) for i, dat in enumerate(eeg.get_data()): df = pd.DataFrame(dat.T) df.columns = eeg[i].ch_names df.index = eeg[i].times # Add info info = pd.DataFrame({"Label": [i] * len(df)}) info["Condition"] = list(eeg[i].event_id.keys())[0] info["Time"] = eeg[i].times info.index = eeg[i].times data[i] = pd.concat([info, df], axis=1) mne.set_log_level(old_verbosity_level) return data
def setUp(self) -> None: mne.set_log_level(False) self.dataset = create_dummy_dataset() self.dataset.return_person_id = True self.dataset.return_session_id = True self.transform = ZScore() self.dataset.add_transform(self.transform)
def source_distributed(evo_crop, fwd, cov, methods, dir_base): param_loose = np.arange(0.1, 1.1, 0.1) param_depth = np.arange(0.1, 1.1, 0.1) param_snr = np.arange(1, 5, 1) mne.set_log_level('ERROR') # Only for final run print('Computing source estimates - ', methods) for method in tqdm(methods, position=0, desc='methods'): for loose in tqdm(param_loose, position=1, desc='loose'): for depth in tqdm(param_depth, position=2, desc='depth'): # anatomical source space inv = m_inv_op(evo_crop.info, fwd, cov, loose=loose, depth=depth) for snr in param_snr: lambda2 = 1. / snr**2 stc = a_inv_op(evo_crop, inv, lambda2, method=method, pick_ori=None) fname_stc = op.join( dir_base, 'results', 'source_loc', method, '%s__%s_l%0.1f_d%0.1f_s%0.1f-stc' % (evo_crop.info['description'], method, loose, depth, snr)) stc.save(fname_stc)
def eeg_rereference_mne(eeg, reference="average", robust=False, **kwargs): eeg = eeg.copy() if reference == "average" and robust is True: eeg._data = eeg_rereference_array(eeg._data, reference=reference, robust=robust) eeg.info["custom_ref_applied"] = True elif reference in ["lap", "csd"]: try: import mne if mne.__version__ < '0.20': raise ImportError except ImportError: raise ImportError( "NeuroKit error: eeg_rereference(): the 'mne' module (version > 0.20) is required " "for this function to run. Please install it first (`pip install mne`).", ) old_verbosity_level = mne.set_log_level(verbose="WARNING", return_old_level=True) eeg = mne.preprocessing.compute_current_source_density(eeg) mne.set_log_level(old_verbosity_level) else: eeg = eeg.set_eeg_reference(reference, verbose=False, **kwargs) return eeg
def interpolate_bads(inst, picks, dots=None, reset_bads=True, mode='accurate'): """Interpolate bad MEG and EEG channels.""" import mne # to prevent cobyla printf error # XXX putting to critical for now unless better solution # emerges verbose = mne.set_log_level('CRITICAL', return_old_level=True) eeg_picks = set(pick_types(inst.info, meg=False, eeg=True, exclude=[])) eeg_picks_interp = [p for p in picks if p in eeg_picks] if len(eeg_picks_interp) > 0: _interpolate_bads_eeg(inst, picks=eeg_picks_interp) meg_picks = set(pick_types(inst.info, meg=True, eeg=False, exclude=[])) meg_picks_interp = [p for p in picks if p in meg_picks] if len(meg_picks_interp) > 0: _interpolate_bads_meg_fast(inst, picks=meg_picks_interp, dots=dots, mode=mode) if reset_bads is True: inst.info['bads'] = [] mne.set_log_level(verbose) return inst
def raw_clean(montage): """Return an `mne.io.Raw` object with no bad channels for use with tests. This fixture downloads and reads in subject 30, run 2 from the Physionet BCI2000 (eegbci) open dataset, which contains no bad channels on an initial pass of :class:`pyprep.NoisyChannels`. Intended for use with tests where channels are made artificially bad. File attributes: - Channels: 64 EEG - Sample rate: 160 Hz - Duration: 61 seconds This is only run once per session to save time downloading. """ mne.set_log_level("WARNING") # Download and read S030R02.edf from the BCI2000 dataset edf_fpath = eegbci.load_data(30, 2, update_path=True)[0] raw = mne.io.read_raw_edf(edf_fpath, preload=True) eegbci.standardize(raw) # Fix non-standard channel names # Set a montage for use with RANSAC raw.set_montage(montage) return raw
def write_mnefiff(data, filename): """Export data to MNE using FIFF format. Parameters ---------- data : instance of ChanTime data with only one trial filename : path to file file to export to (include '.mat') Notes ----- It cannot store data larger than 2 GB. The data is assumed to have only EEG electrodes. It overwrites a file if it exists. """ from mne import create_info, set_log_level from mne.io import RawArray set_log_level(WARNING) TRIAL = 0 info = create_info(list(data.axis['chan'][TRIAL]), data.s_freq, ['eeg', ] * data.number_of('chan')[TRIAL]) UNITS = 1e-6 # mne wants data in uV fiff = RawArray(data.data[0] * UNITS, info) if data.attr['chan']: fiff.set_channel_positions(data.attr['chan'].return_xyz(), data.attr['chan'].return_label()) fiff.save(filename, overwrite=True)
def transform(self, X): from mne.beamformer import apply_lcmv_epochs mne.set_log_level('WARNING') epochs = mne.EpochsArray(X, self.info, verbose=False) epochs.filter(self.filter_specs['lp'], self.filter_specs['hp'], fir_design='firwin', n_jobs=self.n_jobs) stcs = apply_lcmv_epochs(epochs, self.filters, return_generator=True, max_ori_out='signed', verbose=False) stcs_mat = np.ones((X.shape[0], self.fwd['nsource'], X.shape[2])) for trial in range(X.shape[0]): stcs_mat[trial, :, :] = next(stcs).data # make an epoch # epochs_stcs = source2epoch(stcs_mat, self.fwd['nsource'], # self.info['sfreq']) # epochs_stcs.filter(self.filter_specs['lp'], self.filter_specs['hp'], # n_jobs=self.n_jobs) if self.power_win is None: self.power_win = self.t_win time_idx = epochs.time_as_index(self.power_win) # stcs_mat is [trials, grid points, time points] return np.sum(stcs_mat[:, :, time_idx[0]:time_idx[1]]**2, axis=2)
def get_signals(path): """ 1) Reading edf file using MNE 2) Band pass filtering 3) Downsampling :param path: str, filepath to the EDF files (ending in '/') :return: dataframe of EEG, EEG2, and EMG signals """ mne.set_log_level('WARNING') raw_edf = mne.io.read_raw_edf(path, preload=True) channels = raw_edf.ch_names if 'EEG 2' in channels: raw_edf.rename_channels({'EEG 2': 'EEG2'}) elif 'EEG(sec)' in channels: raw_edf.rename_channels({'EEG(sec)': 'EEG2'}) elif 'EEG(SEC)' in channels: raw_edf.rename_channels({'EEG(SEC)': 'EEG2'}) raw_edf.pick_channels(['EEG', 'EEG2', 'EMG']) # Select channels raw_edf.filter(2, 30., fir_design='firwin') # Band filter raw_edf.resample(C.FINAL_SAMPLING_FREQ, npad='auto') # Downsampling to 62 Hz return raw_edf.to_data_frame()
def from_raw_2_times(night=None, r_events=None, dir_path=None): if r_events is None: if dir_path is None: dir_path = "../data/raw/EEG" pattern = r'Nathalie.+\.mff' files = [f for f in os.listdir(dir_path) if re.match(pattern, f)] mne.set_log_level(verbose='CRITICAL') for nf, f in enumerate(files): fields = re.findall(pattern='\d+', string=f) nonight = int(fields[0]) if nonight == night: break path_to_file = os.path.join(dir_path, files[nf]) raw = mne.io.read_raw_egi(path_to_file, montage='GSN-HydroCel-256', preload=False) events = mne.find_events(raw) else: raw = r_events['raw'] events = r_events['events'] print(datetime.datetime.fromtimestamp(raw.info['meas_date'][0])) s = [t for t, n, e in events if e == raw.event_id['DIN1']] word_events = [] fs = raw.info['sfreq'] for i, inception in enumerate(s): if inception / fs + 55 <= raw.times.max(): timing = datetime.datetime.fromtimestamp(raw.info['meas_date'][0] + inception / fs) word_events.append({"time": timing, "index": i}) return word_events
def test_morphing(): mne.set_log_level('warning') data_dir = mne.datasets.sample.data_path() subjects_dir = os.path.join(data_dir, 'subjects') sss = datasets._mne_source_space('fsaverage', 'ico-4', subjects_dir) vertices_to = [sss[0]['vertno'], sss[1]['vertno']] ds = datasets.get_mne_sample(-0.1, 0.1, src='ico', sub='index==0', stc=True) stc = ds['stc', 0] morph_mat = mne.compute_morph_matrix('sample', 'fsaverage', stc.vertices, vertices_to, None, subjects_dir) ndvar = ds['src'] morphed_ndvar = morph_source_space(ndvar, 'fsaverage') morphed_stc = mne.morph_data_precomputed('sample', 'fsaverage', stc, vertices_to, morph_mat) assert_array_equal(morphed_ndvar.x[0], morphed_stc.data) morphed_stc_ndvar = load.fiff.stc_ndvar([morphed_stc], 'fsaverage', 'ico-4', subjects_dir, 'dSPM', False, 'src', parc=None) assert_dataobj_equal(morphed_ndvar, morphed_stc_ndvar)
def ica_all(): """Filter all of the EEG data in a directory and save. Parameters ---------- l_freq : float Low-pass frequency (Hz). h_freq : float High-pass frequency (Hz). read_dir : str Directory from which to read the data. save_dir : str Directory in which to save the filtered data. """ parser = argparse.ArgumentParser(prog='1_filter_all.py', description=__doc__) parser.add_argument('-i', '--input', type=str, required=True, help="Directory of files to be filtered.") parser.add_argument('-o', '--output', type=str, required=True, help="Directory in which to save filtered files.") parser.add_argument('-m', '--method', type=str, default='extended-infomax', help='ICA method to use.') parser.add_argument('-v', '--verbose', type=str, default='error') args = parser.parse_args() input_dir = op.abspath(args.input) output_dir = op.abspath(args.output) ica_method = args.method if not op.exists(input_dir): sys.exit("Input directory not found.") if not op.exists(output_dir): sys.exit("Output directory not found.") set_log_level(verbose=args.verbose) input_fnames = op.join(input_dir, '*.fif') input_fnames = glob(input_fnames) n_files = len(input_fnames) print("Preparing to ICA {n} files".format(n=n_files)) # Initialize a progress bar. progress = ProgressBar(n_files, mesg='Performing ICA') progress.update_with_increment_value(0) for fname in input_fnames: # Open file. raw = io.read_raw_fif(fname, preload=True, add_eeg_ref=False) # Perform ICA. ica = ICA(method=ica_method).fit(raw) # Save file. save_fname = op.splitext(op.split(fname)[-1])[0] save_fname += '-ica' save_fname = op.join(output_dir, save_fname) ica.save(save_fname + '.fif') # Update progress bar. progress.update_with_increment_value(1) print("") # Get onto new line once progressbar completes.
def run(): """Run command.""" from mne.commands.utils import get_optparser parser = get_optparser(__file__) parser.add_option('--input', dest='input_fname', help='Input data file name', metavar='filename') parser.add_option('--mrk', dest='mrk_fname', help='MEG Marker file name', metavar='filename') parser.add_option('--elp', dest='elp_fname', help='Headshape points file name', metavar='filename') parser.add_option('--hsp', dest='hsp_fname', help='Headshape file name', metavar='filename') parser.add_option('--stim', dest='stim', help='Colon Separated Stimulus Trigger Channels', metavar='chs') parser.add_option('--slope', dest='slope', help='Slope direction', metavar='slope') parser.add_option('--stimthresh', dest='stimthresh', default=1, help='Threshold value for trigger channels', metavar='value') parser.add_option('--output', dest='out_fname', help='Name of the resulting fiff file', metavar='filename') parser.add_option('--debug', dest='debug', action='store_true', default=False, help='Set logging level for terminal output to debug') options, args = parser.parse_args() if options.debug: mne.set_log_level('debug') input_fname = options.input_fname if input_fname is None: with ETSContext(): mne.gui.kit2fiff() sys.exit(0) hsp_fname = options.hsp_fname elp_fname = options.elp_fname mrk_fname = options.mrk_fname stim = options.stim slope = options.slope stimthresh = options.stimthresh out_fname = options.out_fname if isinstance(stim, str): stim = map(int, stim.split(':')) raw = read_raw_kit(input_fname=input_fname, mrk=mrk_fname, elp=elp_fname, hsp=hsp_fname, stim=stim, slope=slope, stimthresh=stimthresh) raw.save(out_fname) raw.close() sys.exit(0)
def container_process(conf): print('\trun tfr container...') path_home = conf.path_home kind = conf.kind train = conf.train frequency = conf.frequency spec = conf.spec data_path = conf.data_path verbose = conf.verbose donor = mne.Evoked(f'{path_home}donor-ave.fif', verbose = 'ERROR') fpath_events = conf.path_mio + '/mio_out_{}/{}_run{}_mio_corrected_{}{}.txt' plot_spectrogram = conf.plot_spectrogram single_trial = conf.single_trial #get rid of runs, leave frequency data for pos and neg feedback for time course plotting for i in range(len(kind)): for subject in conf.subjects: data = [] processing_done = False if not plot_spectrogram: out_file = conf.path_container + "{}_{}{}_{}{}-ave.fif".format(subject, spec, kind[i], frequency, train) else: out_file = conf.path_container + "{0}_{1}{2}_{3}{4}-50ms-tfr.h5".format(subject, spec, kind[i], frequency, train) for run in conf.runs: print('\t\t', kind[i], run, subject) path_events = fpath_events.format(kind[i], subject, run, kind[i], train) if pathlib.Path(path_events).exists(): if verbose: print('This file is being processed: ', path_events) freq_file = conf.path_tfr + data_path.format(subject, run, spec, frequency, kind[i], train) old_level = mne.set_log_level(verbose='ERROR', return_old_level=True) freq_data = mne.time_frequency.read_tfrs(freq_file)[0] mne.set_log_level(verbose=old_level) data.append(freq_data.data) processing_done = True if run == conf.runs[-1] and processing_done: container_results(plot_spectrogram, single_trial, freq_data, data, donor, out_file, verbose) if plot_spectrogram: sdata = [] for subject in conf.subjects: out_file = conf.path_container + "{0}_{1}{2}_{3}{4}-50ms-tfr.h5".format(subject, spec, kind[0], frequency, train) if pathlib.Path(out_file).exists(): freq_subject_data = mne.time_frequency.read_tfrs(out_file)[0] sdata.append(freq_subject_data) freq_spec_data = mne.grand_average(sdata) title = f'Spectrogram ~{conf.L_freq}-{conf.H_freq} Hz TFR in {kind[0]}' PM = freq_spec_data.plot(picks='meg', fmin=conf.L_freq, fmax=conf.H_freq, vmin=-0.15, vmax=0.15, title=title) os.chdir('/home/asmyasnikova83/') PM.savefig('output.png') print('\tSpectrogramm completed') print('\ttfr container completed')
def run_lcmv_epochs(epochs, fwd, data_cov, reg, noise_cov=None, pick_ori='max-power', weight_norm='nai', verbose=False): """Run LCMV on epochs. Run weight-normalized LCMV beamformer on epoch data, will return matrix of trials or stc object. Parameters: ----------- epochs : MNE epochs epochs to source reconstruct. fwd : MNE forward model forward model. data_cov : MNE covariance estimate data covariance matrix reg : float regularization parameter noise_cov : MNE covariance estimate noise covariance matrix, optional verbose : bool overrides default verbose level, defaults to False, i.e., no logger info. Returns ------- stcs_mat : numpy array matrix with all source trials stc : MNE stc single trial stc object (last trial) filters : dict spatial filter used in computation """ filters = make_lcmv(epochs.info, fwd, data_cov=data_cov, noise_cov=noise_cov, pick_ori=pick_ori, reg=reg, weight_norm=weight_norm, verbose=verbose) # apply that filter to epochs stcs = apply_lcmv_epochs(epochs, filters, return_generator=True, max_ori_out='signed', verbose=verbose) # preallocate matrix stcs_mat = np.ones((epochs._data.shape[0], fwd['nsource'], len(epochs.times))) if verbose is False: mne.set_log_level('WARNING') # resolve generator for trial in range(epochs._data.shape[0]): # last time: also save stc if trial == 0: stc = next(stcs) stcs_mat[trial, :, :] = stc.data else: stcs_mat[trial, :, :] = next(stcs).data return stcs_mat, stc, filters
def run(): """Run command.""" from mne.commands.utils import get_optparser parser = get_optparser(__file__) parser.add_option('--input', dest='input_fname', help='Input data file name', metavar='filename') parser.add_option('--mrk', dest='mrk_fname', help='MEG Marker file name', metavar='filename') parser.add_option('--elp', dest='elp_fname', help='Headshape points file name', metavar='filename') parser.add_option('--hsp', dest='hsp_fname', help='Headshape file name', metavar='filename') parser.add_option('--stim', dest='stim', help='Colon Separated Stimulus Trigger Channels', metavar='chs') parser.add_option('--slope', dest='slope', help='Slope direction', metavar='slope') parser.add_option('--stimthresh', dest='stimthresh', default=1, help='Threshold value for trigger channels', metavar='value') parser.add_option('--output', dest='out_fname', help='Name of the resulting fiff file', metavar='filename') parser.add_option('--debug', dest='debug', action='store_true', default=False, help='Set logging level for terminal output to debug') options, args = parser.parse_args() if options.debug: mne.set_log_level('debug') input_fname = options.input_fname if input_fname is None: with ETSContext(): mne.gui.kit2fiff() sys.exit(0) hsp_fname = options.hsp_fname elp_fname = options.elp_fname mrk_fname = options.mrk_fname stim = options.stim slope = options.slope stimthresh = options.stimthresh out_fname = options.out_fname if isinstance(stim, str): stim = map(int, stim.split(':')) raw = read_raw_kit(input_fname=input_fname, mrk=mrk_fname, elp=elp_fname, hsp=hsp_fname, stim=stim, slope=slope, stimthresh=stimthresh) raw.save(out_fname) raw.close()
def _fast_map_meg_channels(info, pick_from, pick_to, mode='fast'): from mne.io.pick import pick_info from mne.forward._field_interpolation import _setup_dots from mne.forward._field_interpolation import _compute_mapping_matrix from mne.forward._make_forward import _create_meg_coils, _read_coil_defs from mne.forward._lead_dots import _do_self_dots, _do_cross_dots from mne.bem import _check_origin miss = 1e-4 # Smoothing criterion for MEG # XXX: hack to silence _compute_mapping_matrix verbose = mne.get_config('MNE_LOGGING_LEVEL', 'INFO') mne.set_log_level('WARNING') def _compute_dots(info, mode='fast'): """Compute all-to-all dots.""" templates = _read_coil_defs() coils = _create_meg_coils(info['chs'], 'normal', info['dev_head_t'], templates) my_origin = _check_origin((0., 0., 0.04), info_from) int_rad, noise, lut_fun, n_fact = _setup_dots(mode, coils, 'meg') self_dots = _do_self_dots(int_rad, False, coils, my_origin, 'meg', lut_fun, n_fact, n_jobs=1) cross_dots = _do_cross_dots(int_rad, False, coils, coils, my_origin, 'meg', lut_fun, n_fact).T return self_dots, cross_dots _compute_fast_dots = mem.cache(_compute_dots, verbose=0) info['bads'] = [] # if bads is different, hash will be different info_from = pick_info(info, pick_from, copy=True) templates = _read_coil_defs() coils_from = _create_meg_coils(info_from['chs'], 'normal', info_from['dev_head_t'], templates) my_origin = _check_origin((0., 0., 0.04), info_from) int_rad, noise, lut_fun, n_fact = _setup_dots(mode, coils_from, 'meg') # This function needs a clean input. It hates the presence of other # channels than MEG channels. Make sure all is picked. self_dots, cross_dots = _compute_fast_dots( info, mode=mode) cross_dots = cross_dots[pick_to, :][:, pick_from] self_dots = self_dots[pick_from, :][:, pick_from] ch_names = [c['ch_name'] for c in info_from['chs']] fmd = dict(kind='meg', ch_names=ch_names, origin=my_origin, noise=noise, self_dots=self_dots, surface_dots=cross_dots, int_rad=int_rad, miss=miss) fmd['data'] = _compute_mapping_matrix(fmd, info_from) mne.set_log_level(verbose) return fmd['data']
def raw(): """Fixture for physionet EEG subject 4, dataset 1.""" mne.set_log_level("WARNING") # load in subject 1, run 1 dataset edf_fpath = eegbci.load_data(4, 1, update_path=True)[0] # using sample EEG data (https://physionet.org/content/eegmmidb/1.0.0/) raw = mne.io.read_raw_edf(edf_fpath, preload=True) # The eegbci data has non-standard channel names. We need to rename them: eegbci.standardize(raw) return raw
def raw(): """Fixture for physionet EEG subject 4, dataset 1.""" mne.set_log_level("WARNING") # load in subject 1, run 1 dataset edf_fpath = eegbci.load_data(4, 1, update_path=True)[0] # using sample EEG data (https://physionet.org/content/eegmmidb/1.0.0/) raw = mne.io.read_raw_edf(edf_fpath, preload=True) raw.rename_channels(lambda s: s.strip(".")) raw.rename_channels( lambda s: s.replace("c", "C").replace("o", "O").replace("f", "F"). replace("t", "T").replace("Tp", "TP").replace("Cp", "CP")) return raw
def main(in_pkl, kind): logging.basicConfig(level=logging.DEBUG) mne.set_log_level(logging.ERROR) in_df = pd.read_pickle(in_pkl) output_path = os.path.join( LABELED_ROOT, os.path.splitext(os.path.split(in_pkl)[1])[0]) + \ '_sigmas.pkl' logging.info(f'Creating sigmas for file {in_pkl} in file {output_path}') create_sigma_pkl(in_df, kind, output_path) logging.info('Finished procedure.')
def set_log_level(verbose='info'): """Set lot level. Set the general log level. level can be 'info', 'debug' or 'warning' """ mne.set_log_level(False) level = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING } coloredlogs.install(level=level.get(verbose, logging.INFO))
def load_brainvision(path): # Import the BrainVision data into an MNE Raw object mne.set_log_level("WARNING") print('reading raw file...') raw= mne.io.read_raw_brainvision(path, preload=True, eog=('EOG1_1','EOG2_1'), misc=('EMG1_1','EMG2_1'), verbose=True) raw.rename_channels(lambda s: s.strip(".")) # Specify this as the emg channel (channel type) raw.set_channel_types({'EMG1_1': 'emg','EMG2_1': 'emg'}) print('Done!') return raw
def interpolate_bads(inst, picks, reset_bads=True, mode='accurate'): """Interpolate bad MEG and EEG channels.""" import mne from mne.channels.interpolation import _interpolate_bads_eeg mne.set_log_level('WARNING') # to prevent cobyla printf error # this needs picks, assume our instance is complete and intact _interpolate_bads_eeg(inst) _interpolate_bads_meg_fast(inst, picks=picks, mode=mode) if reset_bads is True: inst.info['bads'] = [] return inst
def main(kind, file): logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) mne.set_log_level(logging.ERROR) if file is not '': _, ext = os.path.splitext(file) file = files_builder(ext=ext).single_file(file) interactive_plot(file) return logger.info(f'Plotting EEG singals of kind {kind}.') for file in files_builder(kind): interactive_plot(file)
def ReadEdf(edffilename): mne.set_log_level("WARNING") raw = mne.io.read_raw_edf(edffilename, preload=False) #raw.plot() start, stop = raw.time_as_index([100, 115]) # 100 s to 115 s data segment picks = mne.pick_types(raw.info, include=(raw.ch_names)) n_channels = len(raw.ch_names) data, times = raw[picks[:n_channels], start:stop] ch_names = [raw.info['ch_names'][p] for p in picks[:n_channels]] edfPanda1 = pd.DataFrame(data[0], times) edfPanda2 = pd.DataFrame(data[1], times) edfPanda3 = pd.DataFrame(data[2], times) edfPanda4 = pd.DataFrame(data[3], times) edfPanda5 = pd.DataFrame(data[14], times) return (edfPanda1, edfPanda2, edfPanda3, edfPanda4, edfPanda5, ch_names)
def main(fname, kind, ww, ws, minl, maxl): logging.basicConfig(level=logging.DEBUG) mne.set_log_level(logging.ERROR) window = Window(ww, ws) if ww > 0 else None existing_df = None output_path = os.path.join(LABELED_ROOT, kind) assert os.path.exists(output_path), output_path fpath = os.path.join(output_path, fname) if os.path.isfile(fpath): logging.warning(f'File {fpath} exists. We will try to extend it.') existing_df = pd.read_pickle(fpath) create_training_data(fpath, DataKind(kind), window, minl, maxl, existing_df) logging.info('Finished procedure.')
def silent_mne(full_silence=False): ''' Context manager that silences warnings from mne-python. ''' import mne log_level = mne.set_log_level('error', return_old_level=True) if full_silence: with warnings.catch_warnings(): warnings.simplefilter("ignore") yield else: yield mne.set_log_level(log_level)
def set_log_level(level="INFO"): """Set lot level. Set the general log level. Use one of the levels supported by python logging, i.e.: DEBUG, INFO, WARNING, ERROR, CRITICAL """ VALID_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] level = level.upper() if level not in VALID_LEVELS: raise ValueError( f"Invalid level {level}. Choose one of {VALID_LEVELS}.") mne.set_log_level(False) logging.basicConfig( level=level, format="%(asctime)s %(levelname)s %(threadName)s %(name)s %(message)s", )
def test_morphing(): mne.set_log_level('warning') sss = datasets._mne_source_space('fsaverage', 'ico-4', subjects_dir) vertices_to = [sss[0]['vertno'], sss[1]['vertno']] ds = datasets.get_mne_sample(-0.1, 0.1, src='ico', sub='index==0', stc=True) stc = ds['stc', 0] morph_mat = mne.compute_morph_matrix('sample', 'fsaverage', stc.vertno, vertices_to, None, subjects_dir) ndvar = ds['src'] morphed_ndvar = morph_source_space(ndvar, 'fsaverage') morphed_stc = mne.morph_data_precomputed('sample', 'fsaverage', stc, vertices_to, morph_mat) assert_array_equal(morphed_ndvar.x[0], morphed_stc.data) morphed_stc_ndvar = load.fiff.stc_ndvar([morphed_stc], 'fsaverage', 'ico-4', subjects_dir, 'src', parc=None) assert_dataobj_equal(morphed_ndvar, morphed_stc_ndvar)
def interpolate_bads(inst, reset_bads=True, mode='accurate'): """Interpolate bad MEG and EEG channels. """ import mne from mne.channels.interpolation import _interpolate_bads_eeg mne.set_log_level('WARNING') # to prevent cobyla printf error if getattr(inst, 'preload', None) is False: raise ValueError('Data must be preloaded.') _interpolate_bads_eeg(inst) _interpolate_bads_meg_fast(inst, mode=mode) if reset_bads is True: inst.info['bads'] = [] return inst
def generate_mmi(seconds, targets): mne.set_log_level(False) for target in targets: perf = _mmi_performance(target, 'saved_models/MMI/{}s/fine_tuned-{}/'.format(seconds, target), alignment=True, tlen=seconds) perf.to_csv('analysis/mmi_{}s_{}_ft.csv'.format(seconds, target)) perf = _mmi_performance(target, 'saved_models/MMI/{}s/fine_tuned-{}/'.format(seconds, target), alignment=False, tlen=seconds) perf.to_csv('analysis/mmi_{}s_{}_ft_no_ea.csv'.format(seconds, target)) perf = _mmi_performance(target, 'saved_models/MMI/{}s/targetted_mdl_{}/'.format(seconds, target), tlen=seconds, alignment=True, subjects=64) perf.to_csv('analysis/mmi_{}s_{}_mdl.csv'.format(seconds, target)) perf = _mmi_performance(target, 'saved_models/MMI/{}s/targetted_mdl_{}/'.format(seconds, target), tlen=seconds, alignment=False, subjects=64) perf.to_csv('analysis/mmi_{}s_{}_mdl_no_ea.csv'.format(seconds, target))
def newdatalabels(filename): raw_data = mne.io.read_raw_eeglab(filename, preload=True) mne.set_log_level("WARNING") raw_data.resample(128, npad='auto') #resampling #band-pass filtering in the range 4 Hz - 38 Hz raw_data.filter(4, 38, method="iir") # data=raw_data.get_data() # chs = raw_data.pick_channels(['FC6','FCZ','FC5','FC3','FC4','CP3','CP4','C5','C3','C1','CZ','C2','C4','C6']) chs = raw_data.pick_channels([ 'FCZ', 'FC5', 'FC1', 'FC2', 'FC6', 'FC3', 'FC4', 'C5', 'C3', 'C1', 'CZ', 'C2', 'C4', 'C6', 'CP3', 'CP1', 'CP2', 'CP4' ]) data = chs.get_data() # data = data[122:130,:] #electrode-wise exponential moving standarlization m = np.mean(data[:, 0:1000], axis=1) #m is the first 1000 datapoints mean values v = np.var(data[:, 0:1000], axis=1) #v is the first 1000 datapoints variance values sd = np.zeros((data.shape[0], data.shape[1])) #standarlized data for i in range(1000, data.shape[1]): m = 0.001 * data[:, i] + 0.999 * m v = 0.001 * ((data[:, i] - m)**2) + 0.999 * v sd[:, i] = (data[:, i] - m) / np.sqrt(v) events_from_annot, event_dict = mne.events_from_annotations(raw_data) #new standarlized data with labels newsd = [] labels = [] print(filename) for i in range(len(events_from_annot)): if events_from_annot[i, 2] == 1 or events_from_annot[i, 2] == 2: st = events_from_annot[i, 0] - 256 #start time et = events_from_annot[i, 0] + 768 #end time labels.append(events_from_annot[i, 2]) #newsd.append(sd[:,st:et]) tmp = sd[:, st:et] if tmp.shape[1] != 0: newsd.append(tmp) newsd = np.stack([arr for arr in newsd], axis=0) labels = np.array(labels) return (newsd, labels)
def create_3Dmatrix(epochs_dim, ch_type, input_filename, input_filename_trial, output_filename=None): mne.set_log_level('WARNING') raw = mne.fiff.Raw(input_filename) datatrial = pickle.load(open(input_filename_trial)) trigger_times = datatrial['trigger_times'] trigger_decimal = datatrial['trigger_decimal'] coi = datatrial['coi'] print print "Get the indexes of just the MEG channels" picks = mne.fiff.pick_types(raw.info, meg=ch_type['meg'], eeg=ch_type['eeg'], stim=ch_type['stim'], exclude=ch_type['exclude']) #only meg channels events = np.vstack([trigger_times, np.zeros(len(trigger_times), dtype=np.int), trigger_decimal]).T print "Extracting Epochs for each condition for the contrast." baseline = (None, 0) # means from the first instant to t = 0 reject = {} tmin = epochs_dim[0] tmax = epochs_dim[1] epochs = mne.Epochs(raw, events, event_id=None, tmin=tmin, tmax=tmax, proj=True, picks=picks, baseline=baseline, preload=False, reject=reject) X = epochs.get_data() y = epochs.events[:,2] label = np.zeros(len(y)) for i, yi in enumerate(y): if np.sum(yi == coi[0]): label[i] = 1 if output_filename == None: filename_save = input_filename_trial.split('.')[0]+'_3D.pickle' else: filename_save = os.path.abspath(output_filename) print "Saving to:", filename_save pickle.dump({'X': X, 'y': label, 'tmin': tmin, 'sfreq': raw.info['sfreq'] }, open(filename_save, 'w'), protocol = pickle.HIGHEST_PROTOCOL) return filename_save
def _fast_map_meg_channels(info, pick_from, pick_to, dots=None, mode='fast'): from mne.io.pick import pick_info from mne.forward._field_interpolation import _setup_dots from mne.forward._field_interpolation import _compute_mapping_matrix from mne.forward._make_forward import _create_meg_coils, _read_coil_defs from mne.bem import _check_origin miss = 1e-4 # Smoothing criterion for MEG # XXX: hack to silence _compute_mapping_matrix verbose = mne.get_config('MNE_LOGGING_LEVEL', 'INFO') mne.set_log_level('WARNING') info_from = pick_info(info, pick_from, copy=True) templates = _read_coil_defs() coils_from = _create_meg_coils(info_from['chs'], 'normal', info_from['dev_head_t'], templates) my_origin = _check_origin((0., 0., 0.04), info_from) int_rad, noise, lut_fun, n_fact = _setup_dots(mode, coils_from, 'meg') # This function needs a clean input. It hates the presence of other # channels than MEG channels. Make sure all is picked. if dots is None: dots = self_dots, cross_dots = _compute_dots(info, mode=mode) else: self_dots, cross_dots = dots self_dots, cross_dots = _pick_dots(dots, pick_from, pick_to) ch_names = [c['ch_name'] for c in info_from['chs']] fmd = dict(kind='meg', ch_names=ch_names, origin=my_origin, noise=noise, self_dots=self_dots, surface_dots=cross_dots, int_rad=int_rad, miss=miss) fmd['data'] = _compute_mapping_matrix(fmd, info_from) mne.set_log_level(verbose) return fmd['data']
def __init__(self, subject, settings=dict()): self.subject = subject self.settings = settings if 'debug' in settings: configure_custom(settings['debug']) else: configure_custom(debug=True) if 'mne_log_level' in settings: mne.set_log_level(settings['mne_log_level']) else: mne.set_log_level('INFO') if 'sfreq' in settings: self.downsample_sfreq = settings['sfreq'] else: self.downsample_sfreq = 64 if 'layout' in settings: self.layout = settings['layout'] else: self.layout = mne.channels.read_layout('biosemi.lay') if 'data_root' in settings: self.data_root = settings['data_root'] else: self.data_root = os.path.join(deepthought.DATA_PATH, 'OpenMIIR') # load stimuli metadata version self.stimuli_version = get_stimuli_version(subject) # initial state self.raw = None self.ica = None self.filtered = False self.downsampled = False
def plot_group_fourierICA(fn_groupICA_obj, stim_id=1, stim_delay=0, resp_id=None, corr_event_picking=None, global_scaling=True, subjects_dir=None, bar_plot=False): """ Interface to plot the results from group FourierICA Parameters ---------- fn_groupICA_obj: filename of the group ICA object stim_id: Id of the event of interest to be considered in the stimulus channel. Only of interest if 'stim_name' is set default: event_id=1 stim_delay: stimulus delay in milliseconds default: stim_delay=0 resp_id: Response IDs for correct event estimation. Note: Must be in the order corresponding to the 'event_id' default: resp_id=None corr_event_picking: string if set should contain the complete python path and name of the function used to identify only the correct events default: corr_event_picking=None subjects_dir: string If the subjects directory is not confirm with the system variable 'SUBJECTS_DIR' parameter should be set default: subjects_dir=None bar_plot: boolean If set the results of the time-frequency analysis are shown as bar plot. This option is recommended when FourierICA was applied to resting-state data default: bar_plot=False """ # ------------------------------------------ # import necessary modules # ------------------------------------------ from jumeg.decompose.fourier_ica_plot import plot_results_src_space from mne import set_log_level from os.path import exists from pickle import dump, load # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # read in group FourierICA object # ------------------------------------------ with open(fn_groupICA_obj, "rb") as filehandler: groupICA_obj = load(filehandler) icasso_obj = groupICA_obj['icasso_obj'] win_length_sec = icasso_obj.tmax_win - icasso_obj.tmin_win temp_profile_names = ["Event-ID %i" % i for i in groupICA_obj['icasso_obj'].event_id] # ------------------------------------------ # check if time-courses already exist # ------------------------------------------ fn_temporal_envelope = fn_groupICA_obj[:-4] + '_temporal_envelope.obj' # generate time courses if they do not exist if not exists(fn_temporal_envelope): # import necessary modules from jumeg.decompose.group_ica import get_group_fourierICA_time_courses # generate time courses temporal_envelope, src_loc, vert, sfreq = \ get_group_fourierICA_time_courses(groupICA_obj, event_id=stim_id, stim_delay=stim_delay, resp_id=resp_id, corr_event_picking=corr_event_picking, unfiltered=False, baseline=(None, 0)) # save data temp_env_obj = {'temporal_envelope': temporal_envelope, 'src_loc': src_loc, 'vert': vert, 'sfreq': sfreq} with open(fn_temporal_envelope, "wb") as filehandler: dump(temp_env_obj, filehandler) # when data are stored read them in else: # read data in with open(fn_temporal_envelope, "rb") as filehandler: temp_env_obj = load(filehandler) # get data temporal_envelope = temp_env_obj['temporal_envelope'] src_loc = temp_env_obj['src_loc'] vert = temp_env_obj['vert'] # ------------------------------------------ # check if classification already exists # ------------------------------------------ if groupICA_obj.has_key('classification') and\ groupICA_obj.has_key('mni_coords') and\ groupICA_obj.has_key('labels'): classification = groupICA_obj['classification'] mni_coords = groupICA_obj['mni_coords'] labels = groupICA_obj['labels'] else: classification = {} mni_coords = [] labels = None # ------------------------------------------ # plot "group" results # ------------------------------------------ fnout_src_fourier_ica = fn_groupICA_obj[:fn_groupICA_obj.rfind('.obj')] + \ img_src_group_ica mni_coords, classification, labels =\ plot_results_src_space(groupICA_obj['fourier_ica_obj'], groupICA_obj['W_orig'], groupICA_obj['A_orig'], src_loc_data=src_loc, vertno=vert, subjects_dir=subjects_dir, tpre=icasso_obj.tmin_win, win_length_sec=win_length_sec, flow=icasso_obj.flow, fhigh=icasso_obj.fhigh, fnout=fnout_src_fourier_ica, tICA=icasso_obj.tICA, global_scaling=global_scaling, temporal_envelope=temporal_envelope, temp_profile_names=temp_profile_names, classification=classification, mni_coords=mni_coords, labels=labels, bar_plot=bar_plot) # ------------------------------------------ # adjust groupICA_obj with the new # parameters if they didn't exist before # ------------------------------------------ if not groupICA_obj.has_key('classification') and\ not groupICA_obj.has_key('mni_coords') and\ not groupICA_obj.has_key('labels'): groupICA_obj['classification'] = classification groupICA_obj['mni_coords'] = mni_coords groupICA_obj['labels'] = labels # write new groupICA_obj back to disk with open(fn_groupICA_obj, "wb") as filehandler: dump(groupICA_obj, filehandler)
def group_fourierICA_src_space(fname_raw, ica_method='fourierica', # parameter for ICA method nrep=50, # parameter for ICASSO src_loc_method='dSPM', snr=1.0, # parameter for inverse estimation inv_pattern='-src-meg-fspace-inv.fif', stim_name='STI 014', stim_id=1, # parameter for epoch generation corr_event_picking=None, stim_delay=0.0, tmin=-0.2, tmax=0.8, average=False, flow=4., fhigh=34., # parameter for Fourier transformation remove_outliers=False, hamming_data=False, dim_reduction='MDL', pca_dim=None, cost_function='g2', # parameter for complex ICA estimation lrate=0.2, complex_mixing=True, conv_eps=1e-9, max_iter=5000, envelopeICA=False, interpolate_bads=True, decim_epochs=None, fnout=None, # parameter for saving the results verbose=True): """ Module to perform group FourierICA (if wished in combination with ICASSO --> if 'nrep'=1 only FourierICA is performed, if 'nrep'>1 FourierICA is performed in combination with ICASSO). Parameters ---------- fname_raw: list of strings filename(s) of the pre-processed raw file(s) ica_method: string which ICA method should be used for the group ICA? You can chose between 'extended-infomax', 'fastica', 'fourierica' and 'infomax' default: ica_method='fourierica' nrep: integer number of repetitions ICA, i.e. ICASSO, should be performed default: nrep=50 src_loc_method: string method used for source localization. default: src_loc_method='dSPM' snr: float signal-to-noise ratio for performing source localization --> for single epochs an snr of 1.0 is recommended, if keyword 'average' is set one should use snr=3.0 default: snr=1.0 inv_pattern: string String containing the ending pattern of the inverse solution. Note, here fspace is used if the inverse solution is estimated in the Fourier space for later applying Fourier (i.e., complex) ICA default: inv_pattern='-src-meg-fspace-inv.fif' stim_name: string name of the stimulus channel. Note, for applying FourierCIA data are chopped around stimulus onset. If not set data are chopped in overlapping windows default: stim_names='STI 014' stim_id: integer or list of integers list containing the event IDs default: stim_id=1 corr_event_picking: string if set should contain the complete python path and name of the function used to identify only the correct events default: corr_event_picking=None stim_delay: float Stimulus delay in seconds default: stim_delay=0.0 tmin: float time of interest prior to stimulus onset for epoch generation (in seconds) default: tmin=-0.2 tmax: float time of interest after the stimulus onset for epoch generation (in seconds) default: tmax=0.8 average: bool should data be averaged across subjects before FourierICA application? Note, averaged data require less memory! default: average=False flow: float lower frequency border for estimating the optimal de-mixing matrix using FourierICA default: flow=4.0 fhigh: float upper frequency border for estimating the optimal de-mixing matrix using FourierICA default: fhigh=34.0 Note: here default flow and fhigh are choosen to contain: - theta (4-7Hz) - low (7.5-9.5Hz) and high alpha (10-12Hz), - low (13-23Hz) and high beta (24-34Hz) remove_outliers: If set outliers are removed from the Fourier transformed data. Outliers are defined as windows with large log-average power (LAP) LAP_{c,t}=log \sum_{f}{|X_{c,tf}|^2 where c, t and f are channels, window time-onsets and frequencies, respectively. The threshold is defined as |mean(LAP)+3 std(LAP)|. This process can be bypassed or replaced by specifying a function handle as an optional parameter. remove_outliers=False hamming_data: boolean if set a hamming window is applied to each epoch prior to Fourier transformation default: hamming_data=False dim_reduction: string {'', 'AIC', 'BIC', 'GAP', 'MDL', 'MIBS', 'explVar'} Method for dimension selection. For further information about the methods please check the script 'dimension_selection.py'. default: dim_reduction='MDL' pca_dim: Integer The number of components used for PCA decomposition. default: pca_dim=None cost_function: string which cost-function should be used in the complex ICA algorithm 'g1': g_1(y) = 1 / (2 * np.sqrt(lrate + y)) 'g2': g_2(y) = 1 / (lrate + y) 'g3': g_3(y) = y default: cost_function='g2' lrate: float learning rate which should be used in the applied ICA algorithm default: lrate=0.3 complex_mixing: bool if mixing matrix should be real or complex default: complex_mixing=True conv_eps: float iteration stop when weight changes are smaller then this number default: conv_eps = 1e-9 max_iter: integer maximum number of iterations used in FourierICA default: max_iter=5000 envelopeICA: if set ICA is estimated on the envelope of the Fourier transformed input data, i.e., the mixing model is |x|=As default: envelopeICA=False interpolate_bads: bool if set bad channels are interpolated (using the mne routine raw.interpolate_bads()). default: interpolate_bads=True decim_epochs: integer if set the number of epochs will be reduced (per subject) to that number for the estimation of the demixing matrix. Note: the epochs were chosen randomly from the complete set of epochs. default: decim_epochs=None fnout: string output filename of the result structure. If not set the filename is generated automatically. default: fnout=None verbose: bool, str, int, or None If not None, override default verbose level (see mne.verbose). default: verbose=True Return ------ groupICA_obj: dictionary Group ICA information stored in a dictionary. The dictionary has following keys: 'fn_list': List of filenames which where used to estimate the group ICA 'W_orig': estimated de-mixing matrix 'A_orig': estimated mixing matrix 'quality': quality index of the clustering between components belonging to one cluster (between 0 and 1; 1 refers to small clusters, i.e., components in one cluster have a highly similar) 'icasso_obj': ICASSO object. For further information please have a look into the ICASSO routine 'fourier_ica_obj': FourierICA object. For further information please have a look into the FourierICA routine fnout: string filename where the 'groupICA_obj' is stored """ # ------------------------------------------ # import necessary modules # ------------------------------------------ from jumeg.decompose.icasso import JuMEG_icasso from mne import set_log_level import numpy as np from os.path import dirname, join from pickle import dump # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # check input parameter # ------------------------------------------ # filenames if isinstance(fname_raw, list): fn_list = fname_raw else: fn_list = [fname_raw] # ------------------------------------------- # set some path parameter # ------------------------------------------- fn_inv = [] for fn_raw in fn_list: fn_inv.append(fn_raw[:fn_raw.rfind('-raw.fif')] + inv_pattern) # ------------------------------------------ # apply FourierICA combined with ICASSO # ------------------------------------------ icasso_obj = JuMEG_icasso(nrep=nrep, fn_inv=fn_inv, src_loc_method=src_loc_method, morph2fsaverage=True, ica_method=ica_method, cost_function=cost_function, dim_reduction=dim_reduction, decim_epochs=decim_epochs, tICA=False, snr=snr, lrate=lrate) W_orig, A_orig, quality, fourier_ica_obj \ = icasso_obj.fit(fn_list, average=average, stim_name=stim_name, event_id=stim_id, pca_dim=pca_dim, stim_delay=stim_delay, tmin_win=tmin, tmax_win=tmax, flow=flow, fhigh=fhigh, max_iter=max_iter, conv_eps=conv_eps, complex_mixing=complex_mixing, envelopeICA=envelopeICA, hamming_data=hamming_data, remove_outliers=remove_outliers, cost_function=cost_function, interpolate_bads=interpolate_bads, corr_event_picking=corr_event_picking, verbose=verbose) # ------------------------------------------ # save results to disk # ------------------------------------------ # generate dictionary to save results groupICA_obj = {'fn_list': fn_list, 'W_orig': W_orig, 'A_orig': A_orig, 'quality': quality, 'icasso_obj': icasso_obj, 'fourier_ica_obj': fourier_ica_obj} # check if the output filename is already set if not fnout: # generate filename for output structure if isinstance(stim_id, (list, tuple)): fn_base = "group_FourierICA_combined" for id in np.sort(stim_id)[::-1]: fn_base += "_%ddB" % id elif isinstance(stim_id, (int, long)): fn_base = "group_FourierICA_%ddB" % stim_id else: fn_base = "group_ICA_resting_state.obj" # write file to disk fnout = join(dirname(dirname(fname_raw[0])), fn_base + ".obj") with open(fnout, "wb") as filehandler: dump(groupICA_obj, filehandler) # return dictionary return groupICA_obj, fnout
def test_source_estimate(): "Test SourceSpace dimension" mne.set_log_level('warning') ds = datasets.get_mne_sample(src='ico') dsa = ds.aggregate('side') # test auto-conversion asndvar('epochs', ds=ds) asndvar('epochs', ds=dsa) asndvar(dsa['epochs'][0]) # source space clustering res = testnd.ttest_ind('src', 'side', ds=ds, samples=0, pmin=0.05, tstart=0.05, mintime=0.02, minsource=10) assert_equal(res.clusters.n_cases, 52) # test disconnecting parc src = ds['src'] source = src.source parc = source.parc orig_conn = set(map(tuple, source.connectivity())) disc_conn = set(map(tuple, source.connectivity(True))) assert_true(len(disc_conn) < len(orig_conn)) for pair in orig_conn: s, d = pair if pair in disc_conn: assert_equal(parc[s], parc[d]) else: assert_not_equal(parc[s], parc[d]) # threshold-based test with parc srcl = src.sub(source='lh') res = testnd.ttest_ind(srcl, 'side', ds=ds, samples=10, pmin=0.05, tstart=0.05, mintime=0.02, minsource=10, parc='source') assert_equal(res._cdist.dist.shape[1], len(srcl.source.parc.cells)) label = 'superiortemporal-lh' c_all = res._clusters(maps=True) c_label = res._clusters(maps=True, source=label) assert_array_equal(c_label['location'], label) for case in c_label.itercases(): id_ = case['id'] idx = c_all['id'].index(id_)[0] assert_equal(case['v'], c_all[idx, 'v']) assert_equal(case['tstart'], c_all[idx, 'tstart']) assert_equal(case['tstop'], c_all[idx, 'tstop']) assert_less_equal(case['p'], c_all[idx, 'p']) assert_dataobj_equal(case['cluster'], c_all[idx, 'cluster'].sub(source=label)) # threshold-free test with parc res = testnd.ttest_ind(srcl, 'side', ds=ds, samples=10, tstart=0.05, parc='source') cl = res._clusters(0.05) assert_equal(cl.eval("p.min()"), res.p.min()) mp = res.masked_parameter_map() assert_in(mp.min(), (0, res.t.min())) assert_in(mp.max(), (0, res.t.max())) # indexing source space s_sub = src.sub(source='fusiform-lh') idx = source.index_for_label('fusiform-lh') s_idx = src[idx] assert_dataobj_equal(s_sub, s_idx)
import cProfile from optparse import OptionParser import pstats import mne from eelbrain import * import eelbrain mne.set_log_level("warning") eelbrain._stats.testnd.multiprocessing = False # option parser parser = OptionParser() parser.add_option("-m", "--make", dest="make", metavar="KIND", help="Make a new profile of kind mne or uts") parser.add_option("-f", "--file", dest="file_ext", metavar="NAME", help="Use a different file for this profile") parser.add_option( "-s", "--sort", dest="sort", metavar="CRITERION", help="Sort the profile entries according to CRITERION" ) parser.add_option("-n", dest="number", metavar="NUMBER", help="Display NUMBER entries from the profile.") (options, args) = parser.parse_args() # process options if options.file_ext is None: fname = "profile_of_anova.profile" else: fname = "profile_of_anova_%s.profile" % options.file_ext sort = options.sort if options.number is None:
for case in range(rt.n_cases): w = rt[case]['Word'] i = word_map[w] index.append(i) rt['index'] = Var(index) rt.sort('index') # align rows of log with rt log.update(rt, replace=False, info=False) # combine log = log[log['RealWord'] == 1] # event file currently does not contain nonwords log.sort('AbsTime') # make sure log file is sorted by time return log # don't print a bunch of info set_log_level('warning') # create instance upon importing module if socket.gethostname() == 'silversurfer.linguistics.fas.nyu.edu': e = SufAmb('/Volumes/BackUp/sufAmb') # data is stored on silversurfer else: print "Trying to connect to data drive." e = SufAmb('/Volumes/BackUp/sufAmb') # Number of good trials per condition # total: table.frequencies(Y='accept',ds=e.load_selected_events(reject='keep')) # by condition: # print table.frequencies(Y='Condition',ds=e.load_selected_events(reject='keep').sub("accept==True")) #e.set_inv(ori, depth, reg, snr, method, pick_normal) #e.load_inv(fiff)
============================== Generate simulated evoked data ============================== compare the regression results between my method and MNE, using the wrapped version """ import numpy as np import matplotlib.pyplot as plt import numpy.linalg as la import mne from mne.viz import plot_evoked, plot_sparse_source_estimates from mne.simulation import generate_stc import matplotlib.pyplot as plt from mne.inverse_sparse.mxne_optim import _Phi, _PhiT mne.set_log_level('warning') import os,sys,inspect # laptop #os.chdir('/home/yingyang/Dropbox/MEG_source_loc_proj/stft_tree_group_lasso/') # desktop os.chdir('/home/ying/Dropbox/MEG_source_loc_proj/STFT_R_git_repo/') currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) parentdir = os.path.dirname(currentdir) sys.path.insert(0,parentdir+"/Simulation") sys.path.insert(0,parentdir + "/Spline_Regression") sys.path.insert(0,parentdir + "/MNE_stft") sys.path.insert(0,currentdir) from mne.inverse_sparse.mxne_optim import * from Simulation_real_scale import *
''' import scipy.io import numpy as np import os import sys import fftw3 from itertools import islice from collections import deque from PyQt4 import QtGui, QtCore import pyqtgraph as pg import file_handler import objgraph import mne mne.set_log_level('DEBUG') class Cine(object): def __init__(self): self.filehandler = file_handler.FileHandler() self.app = QtGui.QApplication(sys.argv) self.widget = QtGui.QWidget() self.start_btn = QtGui.QPushButton('Start') self.stop_btn = QtGui.QPushButton('Stop') self.file_in = QtGui.QInputDialog() self.layout = QtGui.QGridLayout() self.layout.addWidget(self.start_btn, 0, 0) self.layout.addWidget(self.stop_btn, 0, 1) self.widget.setLayout(self.layout) self.start_btn.clicked.connect(self.start) self.stop_btn.clicked.connect(self.stop)
parser.add_argument('--reject', help=help_reject, action='store_true') parser.add_argument('--nharm', type=int, default=default_nharm, choices=[0, 1, 2, 3, 4], help=help_nharm) parser.add_argument('--epoch_start', type=float, default=None, help=help_epoch_start) parser.add_argument('--epoch_end', type=float, default=None, help=help_epoch_end) parser.add_argument('--plot_snr', help=help_plot_snr, action='store_true') parser.add_argument('--stim_channel', help=help_stim_channel, type=str, default=None) parser.add_argument('--stim_mask', type=int, default=None, help=help_sti_mask) args = parser.parse_args() mne.set_log_level('ERROR') # reduce mne output if args.epochs_file: fnbase = os.path.basename(os.path.splitext(args.epochs_file)[0]) else: fnbase = os.path.basename(os.path.splitext(args.snr_file)[0]) verbose = False """ Load cHPI SNR file. It is typically not maxfiltered, so ignore MaxShield warnings. """ raw_chpi = mne.io.Raw(args.snr_file, allow_maxshield='yes', verbose=verbose) picks = mne.pick_types(raw_chpi.info, meg=True) """ If using a separate file for the actual data epochs, load it. """ if args.epochs_file:
def test_logging(): """Test logging (to file) """ old_log_file = open(fname_log, 'r') old_lines = clean_lines(old_log_file.readlines()) old_log_file.close() old_log_file_2 = open(fname_log_2, 'r') old_lines_2 = clean_lines(old_log_file_2.readlines()) old_log_file_2.close() if op.isfile(test_name): os.remove(test_name) # test it one way (printing default off) set_log_file(test_name) set_log_level('WARNING') # should NOT print evoked = Evoked(fname_evoked, setno=1) assert_true(open(test_name).readlines() == []) # should NOT print evoked = Evoked(fname_evoked, setno=1, verbose=False) assert_true(open(test_name).readlines() == []) # should NOT print evoked = Evoked(fname_evoked, setno=1, verbose='WARNING') assert_true(open(test_name).readlines() == []) # SHOULD print evoked = Evoked(fname_evoked, setno=1, verbose=True) new_log_file = open(test_name, 'r') new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines) # now go the other way (printing default on) os.remove(test_name) set_log_file(test_name) set_log_level('INFO') # should NOT print evoked = Evoked(fname_evoked, setno=1, verbose='WARNING') assert_true(open(test_name).readlines() == []) # should NOT print evoked = Evoked(fname_evoked, setno=1, verbose=False) assert_true(open(test_name).readlines() == []) # SHOULD print evoked = Evoked(fname_evoked, setno=1) new_log_file = open(test_name, 'r') old_log_file = open(fname_log, 'r') new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines) # check to make sure appending works (and as default, raises a warning) with warnings.catch_warnings(True) as w: set_log_file(test_name, overwrite=False) assert len(w) == 0 set_log_file(test_name) assert len(w) == 1 evoked = Evoked(fname_evoked, setno=1) new_log_file = open(test_name, 'r') new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines_2) # make sure overwriting works set_log_file(test_name, overwrite=True) # this line needs to be called to actually do some logging evoked = Evoked(fname_evoked, setno=1) new_log_file = open(test_name, 'r') new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines)
def select_trial_label(event_id, trigger_channels, coi, input_filename, output_filename=None): mne.set_log_level('WARNING') print "loading dataset " + input_filename raw = mne.fiff.Raw(input_filename) print print "Extract events from channels", print trigger_channels channels_num = len(trigger_channels) triggers = [] for trigger_channel in trigger_channels: print trigger_channel, tmp = mne.find_events(raw, stim_channel=trigger_channel)[:,0] triggers.append(tmp) trigger_times = np.unique(np.concatenate(triggers)) #concatenate trigger event and order them without repetitions threshold_faulty_hw = 5 print "Fix triggers times occurring <"+str(threshold_faulty_hw)+" timesteps from the previous trigger (due to faulty hardware)" idx_triggers_to_fix = np.where(np.diff(trigger_times) < threshold_faulty_hw)[0] fix = dict(zip(trigger_times[idx_triggers_to_fix+1], trigger_times[idx_triggers_to_fix])) print "Actual triggers times to fix due to faulty HW:", fix trigger_times = np.concatenate([[trigger_times[0]], trigger_times[1:][np.diff(trigger_times) >= threshold_faulty_hw]]) for ttf in fix.keys(): for trigger in triggers: trigger[trigger==ttf] = fix[ttf] # this is the actual fix # some checks: tmp = np.unique(np.concatenate(triggers)) assert((tmp == trigger_times).all()) print "Binary to decimal conversion of triggers." trigger_decimal = np.zeros(trigger_times.size, dtype=np.int) for i, t in enumerate(trigger_times): for bit, trigger in enumerate(triggers): if (trigger == t).any(): trigger_decimal[i] += 2**(channels_num - bit - 1) # right lsb trigger_decimal_unique = np.unique(trigger_decimal) summary = [(trigger_decimal==v).sum() for v in trigger_decimal_unique] print "Summary:" print trigger_decimal_unique print summary triggers_of_interest = np.concatenate(coi) print "triggers_of_interest:", triggers_of_interest print "corresponding to:" for toi in triggers_of_interest: print '\t', event_id[toi] triggers_mask = np.logical_or.reduce([trigger_decimal==v for v in triggers_of_interest]) if output_filename == None: filename_save = input_filename.split('.')[0]+'_trial_time.pickle' else: filename_save = os.path.abspath(output_filename) print "Saving to:", filename_save pickle.dump({'trigger_times': trigger_times[triggers_mask], 'trigger_decimal': trigger_decimal[triggers_mask], 'coi': coi, }, open(filename_save, 'w'), protocol = pickle.HIGHEST_PROTOCOL) return filename_save
# of filenames for various things we'll be using. import os.path as op import numpy as np from scipy.signal import welch, coherence from mayavi import mlab from matplotlib import pyplot as plt import mne from mne.simulation import simulate_raw from mne.datasets import sample from mne.minimum_norm import make_inverse_operator, apply_inverse from mne.time_frequency import csd_morlet from mne.beamformer import make_dics, apply_dics_csd # Suppress irrelevant output mne.set_log_level('ERROR') # We use the MEG and MRI setup from the MNE-sample dataset data_path = sample.data_path(download=False) subjects_dir = op.join(data_path, 'subjects') mri_path = op.join(subjects_dir, 'sample') # Filenames for various files we'll be using meg_path = op.join(data_path, 'MEG', 'sample') raw_fname = op.join(meg_path, 'sample_audvis_raw.fif') trans_fname = op.join(meg_path, 'sample_audvis_raw-trans.fif') src_fname = op.join(mri_path, 'bem/sample-oct-6-src.fif') bem_fname = op.join(mri_path, 'bem/sample-5120-5120-5120-bem-sol.fif') fwd_fname = op.join(meg_path, 'sample_audvis-meg-eeg-oct-6-fwd.fif') cov_fname = op.join(meg_path, 'sample_audvis-cov.fif')
from utils import get_data from config import ( data_path, pyoutput_path, subjects, paths('report'), contrasts, open_browser, chan_types, ) report, run_id, _, logger = setup_provenance(script=__file__, results_dir=paths('report')) mne.set_log_level('INFO') # force separation of magnetometers and gradiometers if 'meg' in [i['name'] for i in chan_types]: chan_types = [dict(name='mag'), dict(name='grad')] + \ [dict(name=i['name']) for i in chan_types if i['name'] != 'meg'] for subject in subjects: # Extract events from mat file meg_fname = op.join(data_path, subject, 'preprocessed', subject + '_preprocessed') bhv_fname = op.join(data_path, subject, 'behavior', subject + '_fixed.mat') epochs, events = get_data(meg_fname, bhv_fname) # Apply each contrast all_epochs = [[]] * len(contrasts)
def group_fourierICA_src_space(fname_raw, average=False, stim_name=None, stim_id=1, stim_delay=None, pca_dim=None, ica_method='fourierica', src_loc_method="dSPM", snr=3., nrep=1, tmin=0, tmax=1.0, flow=4., fhigh=34., hamming_data=True, remove_outliers=True, complex_mixing=True, max_iter=2000, conv_eps=1e-9, lrate=0.2, cost_function='g2', envelopeICA=False, verbose=True): """ Module to perform group FourierICA. Parameters ---------- fname_raw: filename(s) of the pre-processed raw file(s) average: Should data be averaged across subjects before FourierICA application? Note, averaged data require less memory! default: average=False stim_name: name of the stimulus channel. Note, for applying FourierCIA data are chopped around stimulus onset. If not set data are chopped in overlapping windows default: stim_names=None stim_id: Id of the event of interest to be considered in the stimulus channel. Only of interest if 'stim_name' is set default: event_id=1 stim_delay: stimulus delay in milliseconds default: stim_delay=0 pca_dim: the number of PCA components used to apply FourierICA. If pca_dim > 1 this refers to the exact number of components. If between 0 and 1 pca_dim refers to the variance which should be explained by the chosen components If pca_dim == None the minimum description length (MDL) (Wax and Kailath, 1985) criterion is used to estimation the number of components default: pca_dim=None ica_method: which ICA method should be used for the group ICA? You can chose between 'extended-infomax', 'fastica', 'fourierica' and 'infomax' default: ica_method='fourierica' src_loc_method: method used for source localization. default: src_loc_method='dSPM' snr: signal-to-noise ratio for performing source localization default: snr=3.0 nrep: number of repetitions ICA, i.e. ICASSO, should be performed default: nrep=1 tmin: time of interest prior to stimulus onset. Important for generating epochs to apply FourierICA default = 0.0 tmax: time of interest after stimulus onset. Important for generating epochs to apply FourierICA default = 1.0 flow: ower frequency border for estimating the optimal de-mixing matrix using FourierICA default: flow=4.0 fhigh: upper frequency border for estimating the optimal de-mixing matrix using FourierICA default: fhigh=34.0 Note: here default flow and fhigh are choosen to contain: - theta (4-7Hz) - low (7.5-9.5Hz) and high alpha (10-12Hz), - low (13-23Hz) and high beta (24-34Hz) hamming_data: if set a hamming window is applied to each epoch prior to Fourier transformation default: hamming_data=True remove_outliers: If set outliers are removed from the Fourier transformed data. Outliers are defined as windows with large log-average power (LAP) LAP_{c,t}=log \sum_{f}{|X_{c,tf}|^2 where c, t and f are channels, window time-onsets and frequencies, respectively. The threshold is defined as |mean(LAP)+3 std(LAP)|. This process can be bypassed or replaced by specifying a function handle as an optional parameter. remove_outliers=True complex_mixing: max_iter: maximum number od iterations used in FourierICA default: max_iter=2000 conv_eps: teration stops when weight changes are smaller then this number default: conv_eps = 1e-9 lrate: initial learning rate default: lrate=0.2 cost_function: which cost-function should be used in the complex ICA algorithm 'g1': g_1(y) = 1 / (2 * np.sqrt(lrate + y)) 'g2': g_2(y) = 1 / (lrate + y) 'g3': g_3(y) = y default: cost_function = 'g2' envelopeICA: if set ICA is estimated on the envelope of the Fourier transformed input data, i.e., the mixing model is |x|=As default: envelopeICA=False verbose: bool, str, int, or None If not None, override default verbose level (see mne.verbose). default: verbose=True """ # ------------------------------------------ # import necessary modules # ------------------------------------------ from jumeg.decompose.icasso import JuMEG_icasso from mne import set_log_level from os.path import dirname, join from pickle import dump # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # check input parameter # ------------------------------------------ # filenames if isinstance(fname_raw, list): fn_list = fname_raw else: fn_list = [fname_raw] # ------------------------------------------- # set some path parameter # ------------------------------------------- fn_inv = [] for fn_raw in fn_list: fn_inv.append(fn_raw[:fn_raw.rfind('-raw.fif')] + inv_pattern) # ------------------------------------------ # apply FourierICA combined with ICASSO # ------------------------------------------ icasso_obj = JuMEG_icasso(nrep=nrep, fn_inv=fn_inv, src_loc_method=src_loc_method, morph2fsaverage=True, envelopeICA=envelopeICA, ica_method=ica_method, tICA=False, snr=snr, lrate=lrate) W_orig, A_orig, quality, fourier_ica_obj \ = icasso_obj.fit(fn_list, average=average, stim_name=stim_name, event_id=stim_id, pca_dim=pca_dim, stim_delay=stim_delay, tmin_win=tmin, tmax_win=tmax, flow=flow, fhigh=fhigh, max_iter=max_iter, conv_eps=conv_eps, complex_mixing=complex_mixing, hamming_data=hamming_data, remove_outliers=remove_outliers, cost_function=cost_function, verbose=verbose) # ------------------------------------------ # save results to disk # ------------------------------------------ groupICA_obj = {'fn_list': fn_list, 'W_orig': W_orig, 'A_orig': A_orig, 'quality': quality, 'icasso_obj': icasso_obj, 'fourier_ica_obj': fourier_ica_obj} if stim_id: fn_base = "group_ICA_%02ddB.obj" % (stim_id) else: fn_base = "group_ICA_resting_state.obj" fnout = join(dirname(dirname(fn_list[0])), fn_base) with open(fnout, "wb") as filehandler: dump(groupICA_obj, filehandler) # return dictionary return groupICA_obj, fnout
############################################################################### # # .. _tut_logging: # # Logging # ======= # Configurations also include the default logging level for the functions. This # field is called "MNE_LOGGING_LEVEL". mne.set_config('MNE_LOGGING_LEVEL', 'INFO') print(mne.get_config(key='MNE_LOGGING_LEVEL')) ############################################################################### # The default value is now set to INFO. This level will now be used by default # every time we call a function in MNE. We can set the global logging level for # only this session by calling :func:`mne.set_log_level` function. mne.set_log_level('WARNING') print(mne.get_config(key='MNE_LOGGING_LEVEL')) ############################################################################### # Notice how the value in the config file was not changed. Logging level of # WARNING only applies for this session. Let's see what logging level of # WARNING prints for :func:`mne.compute_raw_covariance`. cov_raw = mne.compute_raw_covariance(raw) ############################################################################### # Nothing. This means that no warnings were emitted during the computation. If # you look at the documentation of :func:`mne.compute_raw_covariance`, you # notice the ``verbose`` keyword. Setting this parameter does not touch the # configurations, but sets the logging level for just this one function call. # Let's see what happens with logging level of INFO. cov = mne.compute_raw_covariance(raw, verbose=True)
def fit(self, fn_raw, stim_name=None, event_id=1, tmin_stim=0.0, tmax_stim=1.0, flow=4.0, fhigh=34.0, pca_dim=0.90, max_iter=10000, conv_eps=1e-16, verbose=True): """ Perform ICASSO estimation. ICASSO is based on running ICA multiple times with slightly different conditions and clustering the obtained components. Note, here FourierICA is applied Parameters ---------- fn_raw: filename of the input data (expect fif-file). stim_name: name of the stimulus channel. Note, for applying FourierCIA data are chopped around stimulus onset. If not set data are chopped in overlapping windows default: stim_names=None event_id: Id of the event of interest to be considered in the stimulus channel. Only of interest if 'stim_name' is set default: event_id=1 tmin_stim: time of interest prior to stimulus onset. Important for generating epochs to apply FourierICA default = 0.0 tmax_stim: time of interest after stimulus onset. Important for generating epochs to apply FourierICA default = 1.0 flow: lower frequency border for estimating the optimal de-mixing matrix using FourierICA default: flow=4.0 fhigh: upper frequency border for estimating the optimal de-mixing matrix using FourierICA default: fhigh=34.0 Note: here default flow and fhigh are choosen to contain: - theta (4-7Hz) - low (7.5-9.5Hz) and high alpha (10-12Hz), - low (13-23Hz) and high beta (24-34Hz) pca_dim: The number of PCA components used to apply FourierICA. If pca_dim > 1 this refers to the exact number of components. If between 0 and 1 pca_dim refers to the variance which should be explained by the chosen components default: pca_dim=0.9 max_iter: maximum number od iterations used in FourierICA default: max_iter=10000 conv_eps: iteration stops when weight changes are smaller then this number default: conv_eps = 1e-16 verbose: bool, str, int, or None If not None, override default verbose level (see mne.verbose). default: verbose=True Returns ------- W: estimated optimal de-mixing matrix A: estimated mixing matrix Iq: quality index of the clustering between components belonging to one cluster (between 0 and 1; 1 refers to small clusters, i.e., components in one cluster a highly similar) fourier_ica_obj: FourierICA object. For further information please have a look into the FourierICA routine """ # ------------------------------------------ # import necessary module # ------------------------------------------ from fourier_ica import JuMEG_fourier_ica from mne import find_events, pick_types, set_log_level from mne.io import Raw # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # prepare data to apply FourierICA # ------------------------------------------ meg_raw = Raw(fn_raw, preload=True) meg_channels = pick_types(meg_raw.info, meg=True, eeg=False, eog=False, stim=False, exclude='bads') meg_data = meg_raw._data[meg_channels, :] if stim_name: events = find_events(meg_raw, stim_channel=stim_name, consecutive=True) events = events[events[:, 2] == event_id, 0] else: events = [] # ------------------------------------------ # generate FourierICA object # ------------------------------------------ if verbose: print ">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<" print ">>> Performing FourierICA estimation <<<" print ">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<" win_length_sec = tmax_stim - tmin_stim fourier_ica_obj = JuMEG_fourier_ica(events=events, tpre=tmin_stim, flow=flow, fhigh=fhigh, win_length_sec=win_length_sec, remove_outliers=True, hamming_data=True, complex_mixing=True, pca_dim=pca_dim, max_iter=max_iter, conv_eps=conv_eps) # ------------------------------------------ # perform ICASSO ICA # ------------------------------------------ for irep in range(self.nrep): # apply FourierICA W_orig, A_orig, _, _, _, whitenMat, dewhitenMat = fourier_ica_obj.fit(meg_data.copy(), verbose=False) if irep == 0: self.whitenMat = whitenMat self.dewhitenMat = dewhitenMat # save results in structure self.W_est.append(W_orig) self.A_est.append(A_orig) # print out some information if verbose: print ">>> Running FourierICA number %d of %d done" % (irep+1, self.nrep) if irep == 0: str_hamming_window = "True" if fourier_ica_obj.hamming_data else "False" str_complex_mixing = "True" if fourier_ica_obj.complex_mixing else "False" print "..... Fourier ICA parameter:" print "....." print "..... Sampling frequency set to: %d" % fourier_ica_obj.sfreq print "..... Start of frequency band set to: %d" % fourier_ica_obj.flow print "..... End of frequency band set to: %d" % fourier_ica_obj.fhigh print "..... Using hamming window: %s" % str_hamming_window print "..... Assume complex mixing: %s" % str_complex_mixing print "..... Number of independent components: %d" % fourier_ica_obj.ica_dim print "....." # ------------------------------------------ # perform cluster analysis # ------------------------------------------ if verbose: print ">>>""" print ">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<" print ">>> Performing cluster analysis <<<" print ">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<" Z, order, partitions, indexR, dis, sim = self.cluster() proj = self.projection(dis) A, W, Iq = self.get_results(partitions, sim) # ------------------------------------------ # return results # ------------------------------------------ return W, A, Iq, fourier_ica_obj
import mne import numpy as np mne.set_log_level(False) pids = range(1001, 1022) blocks = ["PV0", "PV1", "WM0", "WM1"] conditions = ["NEU", "NEG"] n_trials = 24 n_channels = 72 n_participants = len(pids) n_blocks = len(blocks) n_conditions = len(conditions) n_times = 4097 # construct output file of ranges fout = open("ranges.txt", "w") fout.write("pid block valence trial channel range\n") # spacing between channnels (DC offset) scale = 1e-5 # loop through the participants for p, pid in enumerate(pids): # loop through the blocks for b, block in enumerate(blocks): # loop through the conditions for c, condition in enumerate(conditions): # construct the filename
from __future__ import absolute_import import mne from ..datasets import segment as sg from . import feature_extractor mne.set_log_level(verbose='WARNING') from mne.time_frequency.tfr import cwt_morlet import random import sys import numpy as np from itertools import chain class EpochShim(object): """A wrapper for our segments which mimics the interface of mne.Epoch, for the band_wavelet_synchrony function.""" def __init__(self, segment, window_size): self.segment = segment self.window_size = window_size # The epoch needs a dictionary attribute with the key 'freq' self.info = dict(sfreq=segment.get_sampling_frequency()) def __iter__(self): for window in self.segment.get_windowed(self.window_size): yield window.transpose() def epochs_from_segment(segment, window_size=5.0): """ Creates an MNE Epochs object from a Segment object
def plot_group_fourierICA(fn_groupICA_obj, stim_name=None, stim_id=1, stim_delay=0, subjects_dir=None): """ Interface to plot the results from group FourierICA Parameters ---------- fn_groupICA_obj: filename of the group ICA object stim_name: name of the stimulus channel. Note, for applying FourierCIA data are chopped around stimulus onset. If not set data are chopped in overlapping windows default: stim_names=None stim_id: Id of the event of interest to be considered in the stimulus channel. Only of interest if 'stim_name' is set default: event_id=1 stim_delay: stimulus delay in milliseconds default: stim_delay=0 subjects_dir: If the subjects directory is not confirm with the system variable 'SUBJECTS_DIR' parameter should be set default: subjects_dir=None """ # ------------------------------------------ # import necessary modules # ------------------------------------------ from jumeg.decompose.fourier_ica_plot import plot_results_src_space from mne import set_log_level from pickle import load # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # read in group FourierICA object # ------------------------------------------ with open(fn_groupICA_obj, "rb") as filehandler: groupICA_obj = load(filehandler) icasso_obj = groupICA_obj['icasso_obj'] win_length_sec = icasso_obj.tmax_win - icasso_obj.tmin_win # ------------------------------------------ # get temporal envelope # ------------------------------------------ temporal_envelope, src_loc, vert, sfreq = \ get_group_fourierICA_time_courses(groupICA_obj) # ------------------------------------------ # plot "group" results # ------------------------------------------ if groupICA_obj.has_key('classification'): classification = groupICA_obj['classification'] else: classification = [] fnout_src_fourier_ica = fn_groupICA_obj[:fn_groupICA_obj.rfind('.obj')] + \ img_src_group_ica plot_results_src_space(groupICA_obj['fourier_ica_obj'], groupICA_obj['W_orig'], groupICA_obj['A_orig'], src_loc, vert, subjects_dir=subjects_dir, tpre=icasso_obj.tmin_win, win_length_sec=win_length_sec, sfreq=sfreq, flow=icasso_obj.flow, fhigh=icasso_obj.fhigh, fnout=fnout_src_fourier_ica, tICA=icasso_obj.tICA, morph2fsaverage=icasso_obj.morph2fsaverage, temporal_envelope=temporal_envelope, classification=classification, show=False)
def apply_ICASSO_fourierICA(fn_raw, nrep=50, stim_name='STI 014', event_id=1, tmin=-0.2, tmax=0.8, flow=4.0, fhigh=34.0, pca_dim=None, max_iter=10000, conv_eps=1e-10, lrate=None, complex_mixing=True, hamming_data=False, envelopeICA=False, remove_outliers=False, cost_function=None, verbose=True, plot_dir=None, plot_res=True): # ------------------------------------------ # import FourierICA module # ------------------------------------------ from jumeg.decompose.icasso import JuMEG_icasso from mne import set_log_level # set log level to 'WARNING' set_log_level('WARNING') # ------------------------------------------ # apply FourierICA combined with ICASSO # ------------------------------------------ icasso_obj = JuMEG_icasso(nrep=nrep, envelopeICA=envelopeICA, lrate=lrate) W_orig, A_orig, quality, fourier_ica_obj, _, _ = icasso_obj.fit(fn_raw, stim_name=stim_name, event_id=event_id, tmin_stim=tmin, tmax_stim=tmax, flow=flow, fhigh=fhigh, pca_dim=pca_dim, max_iter=max_iter, conv_eps=conv_eps, complex_mixing=complex_mixing, hamming_data=hamming_data, remove_outliers=remove_outliers, cost_function=cost_function, verbose=verbose) # ------------------------------------------ # plot results # ------------------------------------------ if plot_res: # ------------------------------------------ # import FourierICA module # ------------------------------------------ from fourier_ica_plot import plot_results from mne import pick_types from mne.io import Raw from os import makedirs from os.path import basename, dirname, exists, join if plot_dir == None: # check if directory for result plots exist fn_dir = dirname(fn_raw) plot_dir = join(fn_dir, 'plots') if not exists(plot_dir): makedirs(plot_dir) # prepare data for plotting meg_raw = Raw(fn_raw, preload=True) meg_channels = pick_types(meg_raw.info, meg=True, eeg=False, eog=False, stim=False, exclude='bads') meg_data = meg_raw._data[meg_channels, :] # plot data fn_fourier_ica = join(plot_dir, basename(fn_raw[:fn_raw.rfind('-raw.fif')] + ',fourierICA')) pk_values = plot_results(fourier_ica_obj, meg_data, W_orig, A_orig, meg_raw.info, meg_channels, cluster_quality=quality, fnout=fn_fourier_ica, show=False) else: pk_values = [] return W_orig, A_orig, quality, fourier_ica_obj, pk_values