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
