Using MNE Python at the CBU

MNE is a software developed for EEG/MEG analysis at the Martinos Centre for Biomedical Imaging. It was originally developed for use under Linux (see e.g. MNE examples, and MNE at the CBU.

Recently, MNE has been integrated into Python for optimization and automatization, as described on the MNE-Python intro pages.

In order to use MNE-Python at the CBU, type

mne_python

in your Linux command window, which will run it in the iPython environment on one of the linux boxes 43-56. This might take a while to start.

In order to check whether you've got access to the MNE Python tools, type

mne. <tab>

(where <tab> means pressing your tab key, not enter), and you'll see a list of MNE commands.

You are ready to go, and you might want to start with the example on the MNE-Python intro site.

For your convenience, the example data set has already been downloaded to /imaging/olaf/MEG/MNE_Python/MNE-sample-data (but feel free to download it yourself - this may take a while though).

If you want to use it, you have to change the data_path variable "data_path = '/imaging/olaf/MEG/MNE_Python/MNE-sample-data'" at the top of the example (see below). The folder "/MEG/sample/labels" is missing, so one part of the example won't work.

Below, I've copied the commands from the MNE-Python intro page into a text file, and removed any unnecessary text. You may use it to copy/paste sections of it into your Python window and play around with it.

It's all quite new and exciting, so any comments or feedback would be welcome!

import mne

# Access raw data
from mne.datasets import sample
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
print raw_fname

# Read data from file
raw = mne.fiff.Raw(raw_fname) 
print raw

# Read and plot a segment of raw data
start, stop = raw.time_to_index(100, 115)  # 100 s to 115 s data segment
data, times = raw[:, start:stop]
print data.shape
print times.shape
data, times = raw[2:20:3, start:stop]  # take some Magnetometers

# Save a segment of 150s of raw data (MEG only):
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=False, stim=True)
raw.save('sample_audvis_meg_raw.fif', tmin=0, tmax=150, picks=picks) 

#First extract events:
events = mne.find_events(raw, stim_channel='STI 014')
print events[:5]

# Define epochs parameters:
event_id = 1
tmin = -0.2
tmax = 0.5

# Exclude some channels (bads + 2 more):
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053']

# Pick the good channels:
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True, stim=False, exclude=exclude)

# Define the baseline period:
baseline = (None, 0)  # means from the first instant to t = 0

# Define peak-to-peak rejection parameters for gradiometers, magnetometers and EOG:
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)

# Read epochs:
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=baseline, preload=False, reject=reject)
print epochs

# Compute evoked responses by averaging and plot it:
evoked = epochs.average() 
print evoked
from mne.viz import plot_evoked
plot_evoked(evoked)

# Extract the max value of each epoch
max_in_each_epoch = [e.max() for e in epochs] 
print max_in_each_epoch[:4]

## Time-Frequency: Induced power and phase-locking values

# Define parameters:
import numpy as np
n_cycles = 2  # number of cycles in Morlet wavelet
frequencies = np.arange(7, 30, 3)  # frequencies of interest
Fs = raw.info['sfreq']  # sampling in Hz

# Compute induced power and phase-locking values:
data = epochs.get_data()
from mne.time_frequency import induced_power
power, phase_lock = induced_power(data, Fs=Fs, frequencies=frequencies, n_cycles=2, n_jobs=1)


## Inverse modeling: MNE and dSPM on evoked and raw data

# Import the required functions:
from mne.minimum_norm import apply_inverse, read_inverse_operator

# Read the inverse operator:
fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
inverse_operator = read_inverse_operator(fname_inv) 

# Define the inverse parameters:
snr = 3.0
lambda2 = 1.0 / snr ** 2
dSPM = True

# Compute the inverse solution:
stc = apply_inverse(evoked, inverse_operator, lambda2, dSPM) 

# Save the source time courses to disk:
stc.save('mne_dSPM_inverse')

# Now, let’s compute dSPM on a raw file within a label:
fname_label = data_path + '/MEG/sample/labels/Aud-lh.label'
label = mne.read_label(fname_label)

# Compute inverse solution during the first 15s:
from mne.minimum_norm import apply_inverse_raw
start, stop = raw.time_to_index(0, 15)  # read the first 15s of data
stc = apply_inverse_raw(raw, inverse_operator, lambda2, dSPM, label, start, stop) 

# Save result in stc files:
stc.save('mne_dSPM_raw_inverse_Aud')