MNE-Python

1.12.0 · active · verified Sun Apr 12

MNE-Python is an open-source Python package for exploring, visualizing, and analyzing human neurophysiological data such as MEG, EEG, sEEG, ECoG, NIRS, and more. It provides modules for data input/output, preprocessing, visualization, source estimation, time-frequency analysis, connectivity analysis, machine learning, and statistics. The library is actively developed, with stable releases occurring frequently, typically every few months.

Warnings

breaking MNE-Python version 1.9.0 and later requires Python 3.10 or higher. Earlier Python versions are no longer supported.
Fix: Upgrade your Python environment to 3.10 or newer.
breaking As of MNE-Python 1.9.0, the `mne.decoding` module explicitly requires `scikit-learn` to be installed.
Fix: Ensure `scikit-learn` is installed: `pip install scikit-learn`.
gotcha Resampling raw data with `mne.io.Raw.resample()` before forming `Epochs` can cause event timing jitter, potentially impacting analyses sensitive to precise event timing.
Fix: For final analysis, it is generally recommended to resample `Epochs` objects using `mne.Epochs.resample()` after epoching, or to be aware of the implications if resampling `Raw` data early.
gotcha Using mutable default arguments (e.g., lists, dictionaries) in custom functions that interact with MNE-Python objects can lead to unexpected shared state across function calls, a common Python pitfall.
Fix: Initialize mutable defaults inside the function, e.g., `def func(arg=None): arg = arg if arg is not None else []`.
gotcha Incorrectly identifying or handling 'bad' channels can bias results in subsequent processing steps like SSP (Signal Space Projection) or ICA (Independent Component Analysis).
Fix: Carefully review channel quality, use `raw.plot(block=True)` for interactive marking, and utilize MNE-Python's tools for marking and interpolating bad channels (e.g., `raw.info['bads']`, `raw.interpolate_bads()`). Consider `autoreject` for automated detection.
deprecated The `subject` parameter in `mne.datasets.eegbci.load_data()` was deprecated in favor of `subjects`.
Fix: Use `subjects` instead of `subject` when calling `mne.datasets.eegbci.load_data()`.

Install

pip install --upgrade mne Install latest stable version

Imports

mne
```
import mne
```
Raw
```
from mne.io import Raw
```
Epochs
```
from mne import Epochs
```
Evoked
```
from mne import Evoked
```
read_raw_fif
```
from mne.io import read_raw_fif
```
`read_raw_fif` is in the `mne.io` submodule, not directly under `mne`.
pick_types
```
from mne.channels import pick_types
```
`pick_types` is in the `mne.channels` submodule.

Quickstart

This quickstart demonstrates loading a sample MEG/EEG dataset, applying a basic filter to the continuous data, defining events, creating epoched data, computing an evoked response, and finally plotting the evoked activity.

import mne
import numpy as np

# Set MNE_DATA for sample dataset (optional, will download if not found)
os.environ['MNE_DATA'] = os.environ.get('MNE_DATA', mne.utils.get_config('MNE_DATA', default=''))

# Load a sample dataset
data_path = mne.datasets.sample.data_path()
raw_fname = data_path / 'MEG' / 'sample' / 'sample_audvis_raw.fif'

# Read raw data
raw = mne.io.read_raw_fif(raw_fname, preload=True, verbose='error')
raw.filter(1, 40, fir_design='firwin')

# Set up events and epochs
events = mne.find_events(raw, stim_channel='STI 014')
event_id = {'aud/left': 1, 'aud/right': 2, 'vis/left': 3, 'vis/right': 4}
t_min, t_max = -0.2, 0.5
epochs = mne.Epochs(raw, events, event_id, t_min, t_max, preload=True, verbose='error')

# Compute evoked response
evoked = epochs['aud/left'].average()

# Plot evoked data
evoked.plot()

print(f"Processed data has {len(epochs)} epochs and {len(raw.ch_names)} channels.")

view raw JSON →