mne.Epochs

class mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), picks=None, name='Unknown', preload=False, reject=None, flat=None, proj=True, decim=1, reject_tmin=None, reject_tmax=None, detrend=None, add_eeg_ref=True, on_missing='error', verbose=None)

Epochs extracted from a Raw instance

Parameters:

raw : Raw object

An instance of Raw.

events : array of int, shape (n_events, 3)

The events typically returned by the read_events function. If some events don’t match the events of interest as specified by event_id, they will be marked as ‘IGNORED’ in the drop log.

event_id : int | list of int | dict | None

The id of the event to consider. If dict, the keys can later be used to access associated events. Example: dict(auditory=1, visual=3). If int, a dict will be created with the id as string. If a list, all events with the IDs specified in the list are used. If None, all events will be used with and a dict is created with string integer names corresponding to the event id integers.

tmin : float

Start time before event.

tmax : float

End time after event.

baseline : None or tuple of length 2 (default (None, 0))

The time interval to apply baseline correction. If None do not apply it. If baseline is (a, b) the interval is between “a (s)” and “b (s)”. If a is None the beginning of the data is used and if b is None then b is set to the end of the interval. If baseline is equal to (None, None) all the time interval is used. The baseline (a, b) includes both endpoints, i.e. all timepoints t such that a <= t <= b.

picks : array-like of int | None (default)

Indices of channels to include (if None, all channels are used).

name : string

Comment that describes the Epochs data created.

preload : boolean

Load all epochs from disk when creating the object or wait before accessing each epoch (more memory efficient but can be slower).

reject : dict | None

Rejection parameters based on peak-to-peak amplitude. Valid keys are ‘grad’ | ‘mag’ | ‘eeg’ | ‘eog’ | ‘ecg’. If reject is None then no rejection is done. Example:

reject = dict(grad=4000e-13, # T / m (gradiometers)
              mag=4e-12, # T (magnetometers)
              eeg=40e-6, # uV (EEG channels)
              eog=250e-6 # uV (EOG channels)
              )

flat : dict | None

Rejection parameters based on flatness of signal. Valid keys are ‘grad’ | ‘mag’ | ‘eeg’ | ‘eog’ | ‘ecg’, and values are floats that set the minimum acceptable peak-to-peak amplitude. If flat is None then no rejection is done.

proj : bool | ‘delayed’

Apply SSP projection vectors. If proj is ‘delayed’ and reject is not None the single epochs will be projected before the rejection decision, but used in unprojected state if they are kept. This way deciding which projection vectors are good can be postponed to the evoked stage without resulting in lower epoch counts and without producing results different from early SSP application given comparable parameters. Note that in this case baselining, detrending and temporal decimation will be postponed. If proj is False no projections will be applied which is the recommended value if SSPs are not used for cleaning the data.

decim : int

Factor by which to downsample the data from the raw file upon import. Warning: This simply selects every nth sample, data is not filtered here. If data is not properly filtered, aliasing artifacts may occur.

reject_tmin : scalar | None

Start of the time window used to reject epochs (with the default None, the window will start with tmin).

reject_tmax : scalar | None

End of the time window used to reject epochs (with the default None, the window will end with tmax).

detrend : int | None

If 0 or 1, the data channels (MEG and EEG) will be detrended when loaded. 0 is a constant (DC) detrend, 1 is a linear detrend. None is no detrending. Note that detrending is performed before baseline correction. If no DC offset is preferred (zeroth order detrending), either turn off baseline correction, as this may introduce a DC shift, or set baseline correction to use the entire time interval (will yield equivalent results but be slower).

add_eeg_ref : bool

If True, an EEG average reference will be added (unless one already exists).

on_missing : str

What to do if one or several event ids are not found in the recording. Valid keys are ‘error’ | ‘warning’ | ‘ignore’ Default is ‘error’. If on_missing is ‘warning’ it will proceed but warn, if ‘ignore’ it will proceed silently. Note. If none of the event ids are found in the data, an error will be automatically generated irrespective of this parameter.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose). Defaults to raw.verbose.

Attributes:

info: dict :

Measurement info.

event_id : dict

Names of conditions corresponding to event_ids.

ch_names : list of string

List of channel names.

selection : array

List of indices of selected events (not dropped or ignored etc.). For example, if the original event array had 4 events and the second event has been dropped, this attribute would be np.array([0, 2, 3]).

preload : bool

Indicates whether epochs are in memory.

drop_log : list of lists

A list of the same length as the event array used to initialize the Epochs object. If the i-th original event is still part of the selection, drop_log[i] will be an empty list; otherwise it will be a list of the reasons the event is not longer in the selection, e.g.:

‘IGNORED’ if it isn’t part of the current subset defined by the user; ‘NO_DATA’ or ‘TOO_SHORT’ if epoch didn’t contain enough data; names of channels that exceeded the amplitude threshold; ‘EQUALIZED_COUNTS’ (see equalize_event_counts); or ‘USER’ for user-defined reasons (see drop_epochs).

verbose : bool, str, int, or None

See above.

Notes

When accessing data, Epochs are detrended, baseline-corrected, and decimated, then projectors are (optionally) applied.

For indexing and slicing:

epochs[idx] : Epochs
Return Epochs object with a subset of epochs (supports single index and python-style slicing)

For subset selection using categorial labels:

epochs[‘name’] : Epochs

Return Epochs object with a subset of epochs corresponding to an experimental condition as specified by ‘name’.

If conditions are tagged by names separated by ‘/’ (e.g. ‘audio/left’, ‘audio/right’), and ‘name’ is not in itself an event key, this selects every event whose condition contains the ‘name’ tag (e.g., ‘left’ matches ‘audio/left’ and ‘visual/left’; but not ‘audio_left’). Note that tags like ‘auditory/left’ and ‘left/auditory’ will be treated the same way when accessed using tags.

epochs[[‘name_1’, ‘name_2’, ... ]] : Epochs

Return Epochs object with a subset of epochs corresponding to multiple experimental conditions as specified by ‘name_1’, ‘name_2’, ... .

If conditions are separated by ‘/’, selects every item containing every list tag (e.g. [‘audio’, ‘left’] selects ‘audio/left’ and ‘audio/center/left’, but not ‘audio/right’).

Methods

add_channels(add_list[, copy]) Append new channels to the instance.
add_eeg_average_proj() Add an average EEG reference projector if one does not exist
add_proj(projs[, remove_existing]) Add SSP projection vectors
apply_baseline(baseline[, verbose]) Baseline correct epochs
apply_proj() Apply the signal space projection (SSP) operators to the data.
average([picks]) Compute average of epochs
copy() Return copy of Epochs instance
crop([tmin, tmax, copy]) Crops a time interval from epochs object.
decimate(decim[, copy]) Decimate the epochs
del_proj(idx) Remove SSP projection vector
drop_bad_epochs([reject, flat]) Drop bad epochs without retaining the epochs data.
drop_channels(ch_names[, copy]) Drop some channels
drop_epochs(indices[, reason, verbose]) Drop epochs based on indices or boolean mask
drop_log_stats([ignore]) Compute the channel stats based on a drop_log from Epochs.
equalize_event_counts(event_ids[, method, copy]) Equalize the number of trials in each condition
get_data() Get all epochs as a 3D array
interpolate_bads([reset_bads, mode]) Interpolate bad MEG and EEG channels.
iter_evoked() Iterate over Evoked objects with nave=1
load_data() Load the data if not already preloaded
next([return_event_id]) To make iteration over epochs easy.
pick_channels(ch_names[, copy]) Pick some channels
pick_types([meg, eeg, stim, eog, ecg, emg, ...]) Pick some channels by type and names
plot([picks, scalings, show, block, ...]) Visualize epochs.
plot_drop_log([threshold, n_max_plot, ...]) Show the channel stats based on a drop_log from Epochs
plot_projs_topomap([ch_type, layout, axes]) Plot SSP vector
plot_psd([fmin, fmax, proj, n_fft, picks, ...]) Plot the power spectral density across epochs
plot_psd_topomap([bands, vmin, vmax, proj, ...]) Plot the topomap of the power spectral density across epochs
rename_channels(mapping) Rename channels.
resample(sfreq[, npad, window, n_jobs, ...]) Resample preloaded data
save(fname[, split_size]) Save epochs in a fif file
savgol_filter(h_freq) Filter the data using Savitzky-Golay polynomial method
set_channel_types(mapping) Define the sensor type of channels.
set_montage(montage) Set EEG sensor configuration
standard_error([picks]) Compute standard error over epochs
subtract_evoked([evoked]) Subtract an evoked response from each epoch
to_data_frame([picks, index, scale_time, ...]) Export data in tabular structure as a pandas DataFrame.
__init__(raw, events, event_id, tmin, tmax, baseline=(None, 0), picks=None, name='Unknown', preload=False, reject=None, flat=None, proj=True, decim=1, reject_tmin=None, reject_tmax=None, detrend=None, add_eeg_ref=True, on_missing='error', verbose=None)
add_channels(add_list, copy=False)

Append new channels to the instance.

Parameters:

add_list : list

A list of objects to append to self. Must contain all the same type as the current object

copy : bool

Whether to return a new instance or modify in place

Returns:

out : MNE object of type(self)

An object with new channels appended (will be the same object if copy==False)

add_eeg_average_proj()

Add an average EEG reference projector if one does not exist

add_proj(projs, remove_existing=False)

Add SSP projection vectors

Parameters:

projs : list

List with projection vectors.

remove_existing : bool

Remove the projection vectors currently in the file.

Returns:

self : instance of Raw | Epochs | Evoked

The data container.

apply_baseline(baseline, verbose=None)

Baseline correct epochs

Parameters:

baseline : tuple of length 2

The time interval to apply baseline correction. (a, b) is the interval is between “a (s)” and “b (s)”. If a is None the beginning of the data is used and if b is None then b is set to the end of the interval. If baseline is equal to (None, None) all the time interval is used.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose).

Returns:

epochs : instance of Epochs

The baseline-corrected Epochs object.

Notes

Baseline correction can be done multiple times.

New in version 0.10.0.

apply_proj()

Apply the signal space projection (SSP) operators to the data.

Returns:

self : instance of Raw | Epochs | Evoked

The instance.

Notes

Once the projectors have been applied, they can no longer be removed. It is usually not recommended to apply the projectors at too early stages, as they are applied automatically later on (e.g. when computing inverse solutions). Hint: using the copy method individual projection vectors can be tested without affecting the original data. With evoked data, consider the following example:

projs_a = mne.read_proj('proj_a.fif')
projs_b = mne.read_proj('proj_b.fif')
# add the first, copy, apply and see ...
evoked.add_proj(a).copy().apply_proj().plot()
# add the second, copy, apply and see ...
evoked.add_proj(b).copy().apply_proj().plot()
# drop the first and see again
evoked.copy().del_proj(0).apply_proj().plot()
evoked.apply_proj()  # finally keep both
average(picks=None)

Compute average of epochs

Parameters:

picks : array-like of int | None

If None only MEG, EEG and SEEG channels are kept otherwise the channels indices in picks are kept.

Returns:

evoked : instance of Evoked

The averaged epochs.

ch_names

Channel names

copy()

Return copy of Epochs instance

crop(tmin=None, tmax=None, copy=False)

Crops a time interval from epochs object.

Parameters:

tmin : float | None

Start time of selection in seconds.

tmax : float | None

End time of selection in seconds.

copy : bool

If False epochs is cropped in place.

Returns:

epochs : Epochs instance

The cropped epochs.

Notes

Unlike Python slices, MNE time intervals include both their end points; crop(tmin, tmax) returns the interval tmin <= t <= tmax.

decimate(decim, copy=False)

Decimate the epochs

Parameters:

decim : int

The amount to decimate data.

copy : bool

If True, operate on and return a copy of the Epochs object.

Returns:

epochs : instance of Epochs

The decimated Epochs object.

Notes

Decimation can be done multiple times. For example, epochs.decimate(2).decimate(2) will be the same as epochs.decimate(4).

New in version 0.10.0.

del_proj(idx)

Remove SSP projection vector

Note: The projection vector can only be removed if it is inactive
(has not been applied to the data).
Parameters:

idx : int

Index of the projector to remove.

Returns:

self : instance of Raw | Epochs | Evoked

drop_bad_epochs(reject='existing', flat='existing')

Drop bad epochs without retaining the epochs data.

Should be used before slicing operations.

Warning

Operation is slow since all epochs have to be read from disk. To avoid reading epochs from disk multiple times, initialize Epochs object with preload=True.

Parameters:

reject : dict | str | None

Rejection parameters based on peak-to-peak amplitude. Valid keys are ‘grad’ | ‘mag’ | ‘eeg’ | ‘eog’ | ‘ecg’. If reject is None then no rejection is done. If ‘existing’, then the rejection parameters set at instantiation are used.

flat : dict | str | None

Rejection parameters based on flatness of signal. Valid keys are ‘grad’ | ‘mag’ | ‘eeg’ | ‘eog’ | ‘ecg’, and values are floats that set the minimum acceptable peak-to-peak amplitude. If flat is None then no rejection is done. If ‘existing’, then the flat parameters set at instantiation are used.

Notes

Dropping bad epochs can be done multiple times with different reject and flat parameters. However, once an epoch is dropped, it is dropped forever, so if more lenient thresholds may subsequently be applied, epochs.copy should be used.

drop_channels(ch_names, copy=False)

Drop some channels

Parameters:

ch_names : list

The list of channels to remove.

copy : bool

If True, returns new instance. Else, modifies in place. Defaults to False.

See also

pick_channels

Notes

New in version 0.9.0.

drop_epochs(indices, reason='USER', verbose=None)

Drop epochs based on indices or boolean mask

Note that the indices refer to the current set of undropped epochs rather than the complete set of dropped and undropped epochs. They are therefore not necessarily consistent with any external indices (e.g., behavioral logs). To drop epochs based on external criteria, do not use the preload=True flag when constructing an Epochs object, and call this method before calling the drop_bad_epochs method.

Parameters:

indices : array of ints or bools

Set epochs to remove by specifying indices to remove or a boolean mask to apply (where True values get removed). Events are correspondingly modified.

reason : str

Reason for dropping the epochs (‘ECG’, ‘timeout’, ‘blink’ etc). Default: ‘USER’.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose). Defaults to raw.verbose.

drop_log_stats(ignore=('IGNORED', ))

Compute the channel stats based on a drop_log from Epochs.

Parameters:

ignore : list

The drop reasons to ignore.

Returns:

perc : float

Total percentage of epochs dropped.

See also

plot_drop_log

equalize_event_counts(event_ids, method='mintime', copy=True)

Equalize the number of trials in each condition

It tries to make the remaining epochs occurring as close as possible in time. This method works based on the idea that if there happened to be some time-varying (like on the scale of minutes) noise characteristics during a recording, they could be compensated for (to some extent) in the equalization process. This method thus seeks to reduce any of those effects by minimizing the differences in the times of the events in the two sets of epochs. For example, if one had event times [1, 2, 3, 4, 120, 121] and the other one had [3.5, 4.5, 120.5, 121.5], it would remove events at times [1, 2] in the first epochs and not [20, 21].

Parameters:

event_ids : list

The event types to equalize. Each entry in the list can either be a str (single event) or a list of str. In the case where one of the entries is a list of str, event_ids in that list will be grouped together before equalizing trial counts across conditions. In the case where partial matching is used (using ‘/’ in event_ids), event_ids will be matched according to the provided tags, that is, processing works as if the event_ids matched by the provided tags had been supplied instead. The event_ids must identify nonoverlapping subsets of the epochs.

method : str

If ‘truncate’, events will be truncated from the end of each event list. If ‘mintime’, timing differences between each event list will be minimized.

copy : bool

If True, a copy of epochs will be returned. Otherwise, the function will operate in-place.

Returns:

epochs : instance of Epochs

The modified Epochs instance.

indices : array of int

Indices from the original events list that were dropped.

Notes

For example (if epochs.event_id was {‘Left’: 1, ‘Right’: 2, ‘Nonspatial’:3}:

epochs.equalize_event_counts([[‘Left’, ‘Right’], ‘Nonspatial’])

would equalize the number of trials in the ‘Nonspatial’ condition with the total number of trials in the ‘Left’ and ‘Right’ conditions.

If multiple indices are provided (e.g. ‘Left’ and ‘Right’ in the example above), it is not guaranteed that after equalization, the conditions will contribute evenly. E.g., it is possible to end up with 70 ‘Nonspatial’ trials, 69 ‘Left’ and 1 ‘Right’.

get_data()

Get all epochs as a 3D array

Returns:

data : array of shape (n_epochs, n_channels, n_times)

A copy of the epochs data.

interpolate_bads(reset_bads=True, mode='accurate')

Interpolate bad MEG and EEG channels.

Operates in place.

Parameters:

reset_bads : bool

If True, remove the bads from info.

mode : str

Either ‘accurate’ or ‘fast’, determines the quality of the Legendre polynomial expansion used for interpolation of MEG channels.

Returns:

self : mne.io.Raw, mne.Epochs or mne.Evoked

The interpolated data.

Notes

New in version 0.9.0.

iter_evoked()

Iterate over Evoked objects with nave=1

load_data()

Load the data if not already preloaded

Returns:

epochs : instance of Epochs

The epochs object.

Notes

This function operates in-place.

New in version 0.10.0.

next(return_event_id=False)

To make iteration over epochs easy.

Parameters:

return_event_id : bool

If True, return both an epoch and and event_id.

Returns:

epoch : instance of Epochs

The epoch.

event_id : int

The event id. Only returned if return_event_id is True.

pick_channels(ch_names, copy=False)

Pick some channels

Parameters:

ch_names : list

The list of channels to select.

copy : bool

If True, returns new instance. Else, modifies in place. Defaults to False.

See also

drop_channels

Notes

New in version 0.9.0.

pick_types(meg=True, eeg=False, stim=False, eog=False, ecg=False, emg=False, ref_meg='auto', misc=False, resp=False, chpi=False, exci=False, ias=False, syst=False, seeg=False, include=[], exclude='bads', selection=None, copy=False)

Pick some channels by type and names

Parameters:

meg : bool | str

If True include all MEG channels. If False include None If string it can be ‘mag’, ‘grad’, ‘planar1’ or ‘planar2’ to select only magnetometers, all gradiometers, or a specific type of gradiometer.

eeg : bool

If True include EEG channels.

stim : bool

If True include stimulus channels.

eog : bool

If True include EOG channels.

ecg : bool

If True include ECG channels.

emg : bool

If True include EMG channels.

ref_meg: bool | str :

If True include CTF / 4D reference channels. If ‘auto’, the reference channels are only included if compensations are present.

misc : bool

If True include miscellaneous analog channels.

resp : bool

If True include response-trigger channel. For some MEG systems this is separate from the stim channel.

chpi : bool

If True include continuous HPI coil channels.

exci : bool

Flux excitation channel used to be a stimulus channel.

ias : bool

Internal Active Shielding data (maybe on Triux only).

syst : bool

System status channel information (on Triux systems only).

seeg : bool

Stereotactic EEG channels.

include : list of string

List of additional channels to include. If empty do not include any.

exclude : list of string | str

List of channels to exclude. If ‘bads’ (default), exclude channels in info['bads'].

selection : list of string

Restrict sensor channels (MEG, EEG) to this list of channel names.

copy : bool

If True, returns new instance. Else, modifies in place. Defaults to False.

Notes

New in version 0.9.0.

plot(picks=None, scalings=None, show=True, block=False, n_epochs=20, n_channels=20, title=None)

Visualize epochs.

Bad epochs can be marked with a left click on top of the epoch. Bad channels can be selected by clicking the channel name on the left side of the main axes. Calling this function drops all the selected bad epochs as well as bad epochs marked beforehand with rejection parameters.

Parameters:

picks : array-like of int | None

Channels to be included. If None only good data channels are used. Defaults to None

scalings : dict | None

Scale factors for the traces. If None, defaults to dict(mag=1e-12, grad=4e-11, eeg=20e-6, eog=150e-6, ecg=5e-4, emg=1e-3, ref_meg=1e-12, misc=1e-3, stim=1, resp=1, chpi=1e-4).

show : bool

Whether to show the figure or not.

block : bool

Whether to halt program execution until the figure is closed. Useful for rejecting bad trials on the fly by clicking on a sub plot.

n_epochs : int

The number of epochs per view.

n_channels : int

The number of channels per view on mne_browse_epochs. If trellis is True, this parameter has no effect. Defaults to 20.

title : str | None

The title of the window. If None, epochs name will be displayed. If trellis is True, this parameter has no effect. Defaults to None.

Returns:

fig : Instance of matplotlib.figure.Figure

The figure.

Notes

The arrow keys (up/down/left/right) can be used to navigate between channels and epochs and the scaling can be adjusted with - and + (or =) keys, but this depends on the backend matplotlib is configured to use (e.g., mpl.use(TkAgg) should work). Full screen mode can be toggled with f11 key. The amount of epochs and channels per view can be adjusted with home/end and page down/page up keys. Butterfly plot can be toggled with b key. Right mouse click adds a vertical line to the plot.

New in version 0.10.0.

plot_drop_log(threshold=0, n_max_plot=20, subject='Unknown', color=(0.9, 0.9, 0.9), width=0.8, ignore=('IGNORED', ), show=True)

Show the channel stats based on a drop_log from Epochs

Parameters:

threshold : float

The percentage threshold to use to decide whether or not to plot. Default is zero (always plot).

n_max_plot : int

Maximum number of channels to show stats for.

subject : str

The subject name to use in the title of the plot.

color : tuple | str

Color to use for the bars.

width : float

Width of the bars.

ignore : list

The drop reasons to ignore.

show : bool

Show figure if True.

Returns:

perc : float

Total percentage of epochs dropped.

fig : Instance of matplotlib.figure.Figure

The figure.

plot_projs_topomap(ch_type=None, layout=None, axes=None)

Plot SSP vector

Parameters:

ch_type : ‘mag’ | ‘grad’ | ‘planar1’ | ‘planar2’ | ‘eeg’ | None | List

The channel type to plot. For ‘grad’, the gradiometers are collec- ted in pairs and the RMS for each pair is plotted. If None (default), it will return all channel types present. If a list of ch_types is provided, it will return multiple figures.

layout : None | Layout | List of Layouts

Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. Or a list of Layout if projections are from different sensor types.

axes : instance of Axes | list | None

The axes to plot to. If list, the list must be a list of Axes of the same length as the number of projectors. If instance of Axes, there must be only one projector. Defaults to None.

Returns:

fig : instance of matplotlib figure

Figure distributing one image per channel across sensor topography.

plot_psd(fmin=0, fmax=inf, proj=False, n_fft=256, picks=None, ax=None, color='black', area_mode='std', area_alpha=0.33, n_overlap=0, dB=True, n_jobs=1, verbose=None, show=True)

Plot the power spectral density across epochs

Parameters:

fmin : float

Start frequency to consider.

fmax : float

End frequency to consider.

proj : bool

Apply projection.

n_fft : int

Number of points to use in Welch FFT calculations.

picks : array-like of int | None

List of channels to use.

ax : instance of matplotlib Axes | None

Axes to plot into. If None, axes will be created.

color : str | tuple

A matplotlib-compatible color to use.

area_mode : str | None

Mode for plotting area. If ‘std’, the mean +/- 1 STD (across channels) will be plotted. If ‘range’, the min and max (across channels) will be plotted. Bad channels will be excluded from these calculations. If None, no area will be plotted.

area_alpha : float

Alpha for the area.

n_overlap : int

The number of points of overlap between blocks.

dB : bool

If True, transform data to decibels.

n_jobs : int

Number of jobs to run in parallel.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose).

show : bool

Show figure if True.

Returns:

fig : instance of matplotlib figure

Figure distributing one image per channel across sensor topography.

plot_psd_topomap(bands=None, vmin=None, vmax=None, proj=False, n_fft=256, ch_type=None, n_overlap=0, layout=None, cmap='RdBu_r', agg_fun=None, dB=True, n_jobs=1, normalize=False, cbar_fmt='%0.3f', outlines='head', show=True, verbose=None)

Plot the topomap of the power spectral density across epochs

Parameters:

bands : list of tuple | None

The lower and upper frequency and the name for that band. If None, (default) expands to:

bands = [(0, 4, ‘Delta’), (4, 8, ‘Theta’), (8, 12, ‘Alpha’),

(12, 30, ‘Beta’), (30, 45, ‘Gamma’)]

vmin : float | callable | None

The value specifying the lower bound of the color range. If None, and vmax is None, -vmax is used. Else np.min(data). If callable, the output equals vmin(data).

vmax : float | callable | None

The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None.

proj : bool

Apply projection.

n_fft : int

Number of points to use in Welch FFT calculations.

ch_type : {None, ‘mag’, ‘grad’, ‘planar1’, ‘planar2’, ‘eeg’}

The channel type to plot. For ‘grad’, the gradiometers are collected in pairs and the RMS for each pair is plotted. If None, defaults to ‘mag’ if MEG data are present and to ‘eeg’ if only EEG data are present.

n_overlap : int

The number of points of overlap between blocks.

layout : None | Layout

Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations.

cmap : matplotlib colormap

Colormap. For magnetometers and eeg defaults to ‘RdBu_r’, else ‘Reds’.

agg_fun : callable

The function used to aggregate over frequencies. Defaults to np.sum. if normalize is True, else np.mean.

dB : bool

If True, transform data to decibels (with 10 * np.log10(data)) following the application of agg_fun. Only valid if normalize is False.

n_jobs : int

Number of jobs to run in parallel.

normalize : bool

If True, each band will be devided by the total power. Defaults to False.

cbar_fmt : str

The colorbar format. Defaults to ‘%0.3f’.

outlines : ‘head’ | ‘skirt’ | dict | None

The outlines to be drawn. If ‘head’, the default head scheme will be drawn. If ‘skirt’ the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in ‘mask_pos’ will serve as image mask, and the ‘autoshrink’ (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to ‘head’.

show : bool

Show figure if True.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose).

Returns:

fig : instance of matplotlib figure

Figure distributing one image per channel across sensor topography.

rename_channels(mapping)

Rename channels.

Parameters:

mapping : dict | callable

a dictionary mapping the old channel to a new channel name e.g. {‘EEG061’ : ‘EEG161’}. Can also be a callable function that takes and returns a string (new in version 0.10.0).

Notes

New in version 0.9.0.

resample(sfreq, npad=100, window='boxcar', n_jobs=1, copy=False, verbose=None)

Resample preloaded data

Parameters:

sfreq : float

New sample rate to use

npad : int

Amount to pad the start and end of the data.

window : string or tuple

Window to use in resampling. See scipy.signal.resample.

n_jobs : int

Number of jobs to run in parallel.

copy : bool

Whether to operate on a copy of the data (True) or modify data in-place (False). Defaults to False.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose). Defaults to self.verbose.

Returns:

epochs : instance of Epochs

The resampled epochs object.

Notes

For some data, it may be more accurate to use npad=0 to reduce artifacts. This is dataset dependent – check your data!

save(fname, split_size='2GB')

Save epochs in a fif file

Parameters:

fname : str

The name of the file, which should end with -epo.fif or -epo.fif.gz.

split_size : string | int

Large raw files are automatically split into multiple pieces. This parameter specifies the maximum size of each piece. If the parameter is an integer, it specifies the size in Bytes. It is also possible to pass a human-readable string, e.g., 100MB. Note: Due to FIFF file limitations, the maximum split size is 2GB.

New in version 0.10.0.

Notes

Bad epochs will be dropped before saving the epochs to disk.

savgol_filter(h_freq)

Filter the data using Savitzky-Golay polynomial method

Parameters:

h_freq : float

Approximate high cut-off frequency in Hz. Note that this is not an exact cutoff, since Savitzky-Golay filtering [R1] is done using polynomial fits instead of FIR/IIR filtering. This parameter is thus used to determine the length of the window over which a 5th-order polynomial smoothing is used.

See also

mne.io.Raw.filter

Notes

Data are modified in-place.

For Savitzky-Golay low-pass approximation, see:

New in version 0.9.0.

References

[R1](1, 2) Savitzky, A., Golay, M.J.E. (1964). “Smoothing and Differentiation of Data by Simplified Least Squares Procedures”. Analytical Chemistry 36 (8): 1627-39.

Examples

>>> import mne
>>> from os import path as op
>>> evoked_fname = op.join(mne.datasets.sample.data_path(), 'MEG', 'sample', 'sample_audvis-ave.fif')  
>>> evoked = mne.read_evokeds(evoked_fname, baseline=(None, 0))[0]  
>>> evoked.savgol_filter(10.)  # low-pass at around 10 Hz 
>>> evoked.plot()  
set_channel_types(mapping)

Define the sensor type of channels.

Note: The following sensor types are accepted:
ecg, eeg, emg, eog, exci, ias, misc, resp, seeg, stim, syst
Parameters:

mapping : dict

a dictionary mapping a channel to a sensor type (str) {‘EEG061’: ‘eog’}.

Notes

New in version 0.9.0.

set_montage(montage)

Set EEG sensor configuration

Parameters:montage : instance of Montage or DigMontage

Notes

Operates in place.

New in version 0.9.0.

standard_error(picks=None)

Compute standard error over epochs

Parameters:

picks : array-like of int | None

If None only MEG, EEG and SEEG channels are kept otherwise the channels indices in picks are kept.

Returns:

evoked : instance of Evoked

The standard error over epochs.

subtract_evoked(evoked=None)

Subtract an evoked response from each epoch

Can be used to exclude the evoked response when analyzing induced activity, see e.g. [1].

Parameters:

evoked : instance of Evoked | None

The evoked response to subtract. If None, the evoked response is computed from Epochs itself.

Returns:

self : instance of Epochs

The modified instance (instance is also modified inplace).

References

[1] David et al. “Mechanisms of evoked and induced responses in MEG/EEG”, NeuroImage, vol. 31, no. 4, pp. 1580-1591, July 2006.

to_data_frame(picks=None, index=None, scale_time=1000.0, scalings=None, copy=True, start=None, stop=None)

Export data in tabular structure as a pandas DataFrame.

Columns and indices will depend on the object being converted. Generally this will include as much relevant information as possible for the data type being converted. This makes it easy to convert data for use in packages that utilize dataframes, such as statsmodels or seaborn.

Parameters:

picks : array-like of int | None

If None only MEG and EEG channels are kept otherwise the channels indices in picks are kept.

index : tuple of str | None

Column to be used as index for the data. Valid string options are ‘epoch’, ‘time’ and ‘condition’. If None, all three info columns will be included in the table as categorial data.

scale_time : float

Scaling to be applied to time units.

scalings : dict | None

Scaling to be applied to the channels picked. If None, defaults to scalings=dict(eeg=1e6, grad=1e13, mag=1e15, misc=1.0).

copy : bool

If true, data will be copied. Else data may be modified in place.

start : int | None

If it is a Raw object, this defines a starting index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal.

stop : int | None

If it is a Raw object, this defines a stop index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal.

Returns:

df : instance of pandas.core.DataFrame

A dataframe suitable for usage with other statistical/plotting/analysis packages. Column/Index values will depend on the object type being converted, but should be human-readable.