def get_roi_filter(label_name, fs, channels, show=False, method='sLORETA', lambda2=1): info = mne.create_info( ch_names=channels, sfreq=fs, montage=mne.channels.read_montage(kind='standard_1005'), ch_types=['eeg' for ch in channels]) mne.utils.set_config("SUBJECTS_DIR", 'av_brain', set_env=True) noise_cov = mne.make_ad_hoc_cov(info, verbose=None) fwd = mne.read_forward_solution( r'C:\Users\nsmetanin\PycharmProjects\nfb\tests\sloreta\fsaverage-fwd-1005-1.fif', surf_ori=True) inv = mne.minimum_norm.make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8, fixed=True) inv = mne.minimum_norm.prepare_inverse_operator(inv, nave=1, lambda2=lambda2, method=method) roi_label = get_roi_by_name(label_name) K, noise_norm, vertno = _assemble_kernel(inv, label=roi_label, method=method, pick_ori=None) w = get_filter(K, vertno, inv, roi_label, noise_norm) if show: mne.viz.plot_topomap(w, info) return w
def getInversionKernel(fname_inv, nave=1, lambda2=1. / 9., method='MNE', label=None, pick_ori=None): inverse_operator = read_inverse_operator(fname_inv) inv = prepare_inverse_operator(inverse_operator, nave, lambda2, method) K, noise_norm, vertno = _assemble_kernel(inv, label, 'MNE', pick_ori) is_free_ori = inverse_operator['source_ori'] == FIFF.FIFFV_MNE_FREE_ORI return K, noise_norm, vertno, is_free_ori
def calc_inv_kernel(fn_inv, method="dSPM", nave=1, snr=6., pick_ori="normal", verbose=None): """ Interface for preparing the kernel of the inverse estimation. Parameters ---------- fn_inv : String containing the filename of the inverse operator (must be a fif-file) method : string which source localization method should be used? MNE-based: "MNE" | "dSPM" | "sLORETA" default: method="dSPM" nave : number of averages used to regularize the solution default: nave=1 snr : signal-to-noise ratio default: snr = 3. verbose : bool, str, int, or None If not None, override default verbose level (see mne.verbose). default: verbose=None """ # ------------------------------------------- # import necessary modules # ------------------------------------------- import mne.minimum_norm as min_norm from mne.minimum_norm.inverse import _assemble_kernel import numpy as np # ------------------------------------------- # estimate inverse kernel # ------------------------------------------- # load inverse solution inv_operator = min_norm.read_inverse_operator(fn_inv, verbose=verbose) # set up the inverse according to the parameters lambda2 = 1. / snr ** 2. # the regularization parameter. inv_operator = min_norm.prepare_inverse_operator(inv_operator, nave, lambda2, method) # estimate inverse kernel and noise normalization coefficient kernel, noise_norm, vertno = _assemble_kernel(inv_operator, None, method, pick_ori) if method == "MNE": noise_norm = np.ones((kernel.shape[0]/3)) noise_norm = noise_norm[:, np.newaxis] # ------------------------------------------- # return results # ------------------------------------------- return kernel, noise_norm, vertno
def _apply_inverse_evoked_list(evoked_list, inverse_operator, lambda2, method="MNE", labels=None, nave=1, pick_ori=None, verbose=None, pick_normal=None): """ Utility function for applying the inverse solution to a list of evoked object Assume that the info for each evoked object in the list is the same Input: evoked_list, inverse_operator, lambda2, method, labels, list of label objects nave = 1, pick_ori = None, verbos = none, pick_normal = None Output: stc_Data, [n_sources_labels, n_times, n_trials] """ info = evoked_list[0].info method = _check_method(method) pick_ori = _check_ori(pick_ori, pick_normal) _check_ch_names(inverse_operator, info) inv = prepare_inverse_operator(inverse_operator, nave, lambda2, method) sel = _pick_channels_inverse_operator(info['ch_names'], inv) labels_union = None if labels is not None: labels_union = labels[0] if len(labels) > 1: for i in range(1,len(labels)): labels_union += labels[i] K, noise_norm, vertno = _assemble_kernel(inv, labels_union, method, pick_ori) is_free_ori = (inverse_operator['source_ori'] == FIFF.FIFFV_MNE_FREE_ORI and pick_ori is None) if not is_free_ori and noise_norm is not None: # premultiply kernel with noise normalization K *= noise_norm n_channels = len(sel) n_times = len(evoked_list[0].times) n_trials = len(evoked_list) n_sources = K.shape[0] stc_Data = np.zeros([n_sources,n_times, n_trials]) for i in range(n_trials): if is_free_ori: # Compute solution and combine current components (non-linear) sol = np.dot(K, evoked_list[i].data) # apply imaging kernel if is_free_ori: sol = combine_xyz(sol) if noise_norm is not None: sol *= noise_norm else: # Linear inverse: do computation here or delayed sol = np.dot(K, evoked_list[i].data) stc_Data[:,:,i] = sol return stc_Data
def get_roi_filter(label_name, fs, channels, show=False, method='sLORETA', lambda2=1): info = mne.create_info(ch_names=channels, sfreq=fs, montage=mne.channels.read_montage(kind='standard_1005'), ch_types=['eeg' for ch in channels]) mne.utils.set_config("SUBJECTS_DIR", 'av_brain', set_env=True) noise_cov = mne.make_ad_hoc_cov(info, verbose=None) fwd = mne.read_forward_solution(r'C:\Users\nsmetanin\PycharmProjects\nfb\tests\sloreta\fsaverage-fwd-1005-1.fif', surf_ori=True) inv = mne.minimum_norm.make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8, fixed=True) inv = mne.minimum_norm.prepare_inverse_operator(inv, nave=1, lambda2=lambda2, method=method) roi_label = get_roi_by_name(label_name) K, noise_norm, vertno = _assemble_kernel(inv, label=roi_label, method=method, pick_ori=None) w = get_filter(K, vertno, inv, roi_label, noise_norm) if show: mne.viz.plot_topomap(w, info) return w
def get_roi_filter(label_name, fs, channels, show=False, method='sLORETA', lambda2=1): standard_montage = mne.channels.read_montage(kind='standard_1005') standard_montage_names = [name.upper() for name in standard_montage.ch_names] for j, channel in enumerate(channels): channels[j] = standard_montage.ch_names[standard_montage_names.index(channel.upper())] info = mne.create_info(ch_names=channels, sfreq=fs, montage=standard_montage, ch_types=['eeg' for ch in channels]) noise_cov = mne.make_ad_hoc_cov(info, verbose=None) fwd = get_fwd_solution() inv = mne.minimum_norm.make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8, fixed=True) inv = mne.minimum_norm.prepare_inverse_operator(inv, nave=1, lambda2=lambda2, method=method) roi_label = get_roi_by_name(label_name) K, noise_norm, vertno = _assemble_kernel(inv, label=roi_label, method=method, pick_ori=None) w = get_filter(K, vertno, inv, roi_label, noise_norm) if show: mne.viz.plot_topomap(w, info) return w
def _apply_inverse_cov(cov, info, nave, inverse_operator, lambda2=1. / 9., method="dSPM", pick_ori=None, prepared=False, label=None, method_params=None, return_residual=False, verbose=None, log=True): """Apply inverse operator to evoked data HACKED """ from mne.minimum_norm.inverse import _check_reference from mne.minimum_norm.inverse import _check_ori from mne.minimum_norm.inverse import _check_ch_names from mne.minimum_norm.inverse import _check_or_prepare from mne.minimum_norm.inverse import _check_ori from mne.minimum_norm.inverse import _pick_channels_inverse_operator from mne.minimum_norm.inverse import _assemble_kernel from mne.minimum_norm.inverse import _subject_from_inverse from mne.minimum_norm.inverse import _get_src_type from mne.minimum_norm.inverse import combine_xyz from mne.minimum_norm.inverse import _make_stc from mne.utils import _check_option from mne.utils import logger from mne.io.constants import FIFF from collections import namedtuple INVERSE_METHODS = ['MNE', 'dSPM', 'sLORETA', 'eLORETA'] fake_evoked = namedtuple('fake', 'info')(info=info) _check_reference(fake_evoked, inverse_operator['info']['ch_names']) _check_option('method', method, INVERSE_METHODS) if method == 'eLORETA' and return_residual: raise ValueError('eLORETA does not currently support return_residual') _check_ori(pick_ori, inverse_operator['source_ori']) # # Set up the inverse according to the parameters # _check_ch_names(inverse_operator, info) inv = _check_or_prepare(inverse_operator, nave, lambda2, method, method_params, prepared) # # Pick the correct channels from the data # sel = _pick_channels_inverse_operator(cov['names'], inv) logger.info('Applying inverse operator to cov...') logger.info(' Picked %d channels from the data' % len(sel)) logger.info(' Computing inverse...') K, noise_norm, vertno, source_nn = _assemble_kernel( inv, label, method, pick_ori) # apply imaging kernel sol = np.einsum('ij,ij->i', K, (cov.data[sel] @ K.T).T)[:, None] is_free_ori = (inverse_operator['source_ori'] == FIFF.FIFFV_MNE_FREE_ORI and pick_ori != 'normal') if is_free_ori and pick_ori != 'vector': logger.info(' Combining the current components...') sol = combine_xyz(sol) if noise_norm is not None: logger.info(' %s...' % (method, )) if is_free_ori and pick_ori == 'vector': noise_norm = noise_norm.repeat(3, axis=0) sol *= noise_norm tstep = 1.0 / info['sfreq'] tmin = 0.0 subject = _subject_from_inverse(inverse_operator) src_type = _get_src_type(inverse_operator['src'], vertno) if log: sol = np.log10(sol, out=sol) stc = _make_stc(sol, vertno, tmin=tmin, tstep=tstep, subject=subject, vector=(pick_ori == 'vector'), source_nn=source_nn, src_type=src_type) logger.info('[done]') return stc
#Apply projector to forward models G1 = (np.eye(71) - (np.ones((71, 1)) @ np.ones((71, 1)).T) / (np.ones( (71, 1)).T @ np.ones((71, 1)))) @ fwd_fixed1['sol']['data'] noise_cov = data_train[subject1][1]['cov'] #Find linear inverse solution given by K multiplied by M, called T^MNE in the report inverse_operator = make_inverse_operator(evoked_tmp.info, fwd_fixed1, noise_cov, loose=loose, depth=depth) inverse_operator = prepare_inverse_operator(inverse_operator, 1, lambda2, method, None, False) K, noise_norm, vertno, source_nn = _assemble_kernel(inverse_operator, None, method, pick_ori=pick_ori, use_cps=True) #Find subjects to augment to for subject2 in np.random.choice(subjects_test, num_aug, replace=False): fwd2 = fwd_list[subject2] fwd_fixed2 = mne.convert_forward_solution(fwd2, force_fixed=True) G2 = (np.eye(71) - (np.ones((71, 1)) @ np.ones( (71, 1)).T) / (np.ones((71, 1)).T @ np.ones( (71, 1)))) @ fwd_fixed2['sol']['data'] src = mne.SourceEstimate( pinv(G1) @ evoked_tmp.average().data, [fwd1['src'][0]['vertno'], fwd1['src'][1]['vertno']], tmin=0, tstep=1 / (1100 * 9),
area = True labels = mne.read_labels_from_annot('fsaverage', parc='aparc') print([label.name for label in labels]) roi_label = labels[[label.name for label in labels].index('posteriorcingulate-rh')] arg = None # prepare inv method = 'sLORETA' inv = mne.minimum_norm.prepare_inverse_operator(inv, nave=1, lambda2=1, method=method) label = None if not area else roi_label K, noise_norm, vertno = _assemble_kernel(inv, label=roi_label, method=method, pick_ori=None) sol = np.dot(K, data) print(sol.shape, noise_norm.shape) if noise_norm is not None: sol *= noise_norm plt.plot(sol.T, 'r', alpha=0.2) plt.plot(np.mean(sol.T, axis=1)) #plt.show() #raw.set_eeg_reference() #stc = mne.minimum_norm.apply_inverse_raw(raw, inv, 0.1, method=method, prepared=True) #plt.plot(1e3 * stc.times, stc.data[::150, :].T) #plt.show() # get flip
f.set_size_inches(10, 3.5) label_name = ['caudalanteriorcingulate', 'lateraloccipital', 'posteriorcingulate'][0] for j, lambda2 in enumerate(lambdas): for k, add_label in enumerate(['lh', 'rh']): # setup roi area = True labels = mne.read_labels_from_annot('fsaverage', parc='aparc') print([label.name for label in labels]) roi_label = labels[[label.name for label in labels].index('{}-{}'.format(label_name, add_label))] arg = None # prepare inv method = 'sLORETA' inv = mne.minimum_norm.prepare_inverse_operator(inv, nave=1, lambda2=lambda2, method=method) label = None if not area else roi_label K, noise_norm, vertno = _assemble_kernel(inv, label=roi_label, method=method, pick_ori=None) sol = np.dot(K, data) print(sol.shape, noise_norm.shape) if noise_norm is not None: sol *= noise_norm #plt.plot(sol.T, 'r', alpha=0.2) #plt.plot(np.mean(sol.T, axis=1)) #plt.show() #raw.set_eeg_reference() #stc = mne.minimum_norm.apply_inverse_raw(raw, inv, 0.1, method=method, prepared=True) #plt.plot(1e3 * stc.times, stc.data[::150, :].T) #plt.show() # get flip
def _extract_operator_data(fwd, inv, labels_parc, method): """Function for extracting forward and inverse operator matrices from the MNE-Python forward and inverse data structures, and the assembling the source identity map. Input arguments: ================ fwd : Forward The forward operator. An instance of the MNE-Python class Forward. inv : Inverse The inverse operator. An instance of the MNE-Python class Inverse. labels_parc : list List of labels belonging to the used parcellation, e.g. the Desikan-Killiany, Destrieux, or Schaefer parcellation. method : str The inversion method. Must be either 'MNE', 'dSPM', 'sLORETA', or 'eLORETA'. Output arguments: ================= """ # counterpart to forwardOperator, [sources x sensors] inv_operator, noise_norm = \ _assemble_kernel(inv=inv, label=None, method=method, pick_ori='normal')[0:2] # get source space src = inv.get('src') # TODO: Is src[0] always the left hemisphere? vert_lh, vert_rh = src[0].get('vertno'), src[1].get('vertno') # get labels, vertices and src-identities src_ident_lh = np.full(len(vert_lh), -1, dtype='int') src_ident_rh = np.full(len(vert_rh), -1, dtype='int') """Discard medial wall (unknown) labels, so that they get value -1.""" labels_parc = discard_unknown_labels(labels_parc) """Sort labels to the order assumed in the following computations. This works as long as Label.hemi is specified for every label.""" labels_parc = sort_labels(labels_parc) # find sources that belong to the left HS labels n_labels = len(labels_parc) for l, label in enumerate(labels_parc[:n_labels // 2]): for v in label.vertices: src_ident_lh[np.where(vert_lh == v)] = l # find sources that belong to the right HS labels for l, label in enumerate(labels_parc[n_labels // 2:n_labels]): for v in label.vertices: src_ident_rh[np.where(vert_rh == v)] = l + (n_labels // 2) src_identities = np.concatenate((src_ident_lh, src_ident_rh)) # Extract forward matrix. fwd_operator = fwd['sol']['data'] # sensors x sources return src_identities, fwd_operator, inv_operator, noise_norm
def _extract_operator_data(fwd, inv_prep, labels, method='dSPM'): """Function for extracting forward and inverse operator matrices from the MNE-Python forward and inverse data structures, and assembling the source identity map. Input arguments: ================ fwd : ForwardOperator The fixed_orientation forward operator. Instance of the MNE-Python class Forward. inv_prep : Inverse The prepared inverse operator. Instance of the MNE-Python class InverseOperator. labels : list List of labels belonging to the used parcellation, e.g. the Desikan-Killiany, Destrieux, or Schaefer parcellation. May not contain 'trash' labels/parcels (unknown or medial wall), those should be deleted from the labels array! method : str The inversion method. Default 'dSPM'. Other methods ('MNE', 'sLORETA', 'eLORETA') have not been tested. Output arguments: ================= source_identities : ndarray Vector mapping sources to parcels or labels. fwd_mat : ndarray [sensors x sources] The forward operator matrix. inv_mat : ndarray [sources x sensors] The prepared inverse operator matrix. """ # counterpart to forwardOperator, [sources x sensors]. ### pick_ori None for free, 'normal' for fixed orientation. K, noise_norm, vertno, source_nn = _assemble_kernel(inv=inv_prep, label=None, method=method, pick_ori='normal') # get source space src = inv_prep.get('src') vert_lh, vert_rh = src[0].get('vertno'), src[1].get('vertno') # get labels, vertices and src-identities src_ident_lh = np.full(len(vert_lh), -1, dtype='int') src_ident_rh = np.full(len(vert_rh), -1, dtype='int') # find sources that belong to the left hemisphere labels n_labels = len(labels) for la, label in enumerate(labels[:n_labels // 2]): for v in label.vertices: src_ident_lh[np.where(vert_lh == v)] = la # find sources that belong to the right hemisphere labels. Add by n left. for la, label in enumerate(labels[n_labels // 2:n_labels]): for v in label.vertices: src_ident_rh[np.where(vert_rh == v)] = la src_ident_rh[np.where(src_ident_rh < 0)] = src_ident_rh[np.where( src_ident_rh < 0)] - n_labels / 2 src_ident_rh = src_ident_rh + (n_labels // 2) source_identities = np.concatenate((src_ident_lh, src_ident_rh)) # extract fwd and inv matrices fwd_mat = fwd['sol']['data'] # sensors x sources """If there are bad channels the corresponding rows can be missing from the forward matrix. Not sure if the same can occur for the inverse. This is not a problem if bad channels are interpolated.""" ### MOVED from weight_inverse_operator, just before """Compute the weighted operator.""" ind = np.asarray([ i for i, ch in enumerate(fwd['info']['ch_names']) if ch not in fwd['info']['bads'] ]) fwd_mat = fwd_mat[ind, :] # noise_norm is used with dSPM and sLORETA. Other methods return null. if method != 'dSPM' or method != 'sLORETA': noise_norm = 1. inv_mat = K * noise_norm # sources x sensors return source_identities, fwd_mat, inv_mat