If raw contains annotations, Epochs can be constructed around
raw.annotations.onset, but note that the durations of the annotations
are ignored in this case.
The identity and timing of experimental events, around which the epochs were
created. See events for more information.Events that don’t match
the events of interest as specified by event_id will be marked as
IGNORED in the drop log.
Changed in version 1.7: Allow events=None to use raw.annotations.onset as the source of
epoch times.
The id of the events 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 of int, all events with the IDs specified in the list
are used. If a str or list of str, events must be None to use annotations
and then the IDs must be the name(s) of the annotations to use.
If None, all events will be used and a dict is created
with string integer names corresponding to the event id integers.
Start and end time of the epochs in seconds, relative to the time-locked
event. The closest or matching samples corresponding to the start and end
time are included. Defaults to -0.2 and 0.5, respectively.
The time interval to consider as “baseline” when applying baseline
correction. If None, do not apply baseline correction.
If a tuple (a,b), the interval is between a and b
(in seconds), including the endpoints.
If a is None, the beginning of the data is used; and if b
is None, it is set to the end of the data.
If (None,None), the entire time interval is used.
Note
The baseline (a,b) includes both endpoints, i.e. all timepoints t
such that a<=t<=b.
Correction is applied to each epoch and channel individually in the
following way:
Calculate the mean signal of the baseline period.
Subtract this mean from the entire epoch.
Defaults to (None,0), i.e. beginning of the the data until
time point zero.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all channels. Note that
channels in info['bads']will be included if their names or indices
are explicitly provided.
Reject epochs based on maximum peak-to-peak signal amplitude (PTP),
i.e. the absolute difference between the lowest and the highest signal
value. In each individual epoch, the PTP is calculated for every channel.
If the PTP of any one channel exceeds the rejection threshold, the
respective epoch will be dropped.
The dictionary keys correspond to the different channel types; valid
keys can be any channel type present in the object.
Example:
reject=dict(grad=4000e-13,# unit: T / m (gradiometers)mag=4e-12,# unit: T (magnetometers)eeg=40e-6,# unit: V (EEG channels)eog=250e-6# unit: V (EOG channels))
Note
Since rejection is based on a signal difference
calculated for each channel separately, applying baseline
correction does not affect the rejection procedure, as the
difference will be preserved.
Note
To constrain the time period used for estimation of signal
quality, pass the reject_tmin and reject_tmax parameters.
If reject is None (default), no rejection is performed.
Reject epochs based on minimum peak-to-peak signal amplitude (PTP).
Valid keys can be any channel type present in the object. The
values are floats that set the minimum acceptable PTP. If the PTP
is smaller than this threshold, the epoch will be dropped. If None
then no rejection is performed based on flatness of the signal.
Note
To constrain the time period used for estimation of signal
quality, pass the reject_tmin and reject_tmax parameters.
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.
Low-pass filtering is not performed, this simply selects
every Nth sample (where N is the value passed to
decim), i.e., it compresses the signal (see Notes).
If the data are not properly filtered, aliasing artifacts
may occur.
See Resampling and decimating data for more information.
Start and end of the time window used to reject epochs based on
peak-to-peak (PTP) amplitudes as specified via reject and flat.
The default None corresponds to the first and last time points of the
epochs, respectively.
Note
This parameter controls the time period used in conjunction with
both, reject and flat.
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).
on_missing‘raise’ | ‘warn’ | ‘ignore’
What to do if one or several event ids are not found in the recording.
Valid keys are ‘raise’ | ‘warn’ | ‘ignore’
Default is 'raise'. If 'warn', 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.
Whether to reject based on annotations. If True (default), epochs
overlapping with segments whose description begins with 'bad' are
rejected. If False, no rejection based on annotations is performed.
A pandas.DataFrame specifying metadata about each epoch.
If not None, len(metadata) must equal len(events). For
save/load compatibility, the DataFrame may only contain
str, int, float, and bool values.
If not None, then pandas-style queries may be used to select
subsets of data, see mne.Epochs.__getitem__(). When the Epochs object
is subsetted, the metadata is subsetted accordingly, and the row indices
will be modified to match Epochs.selection.
How to handle duplicates in events[:,0]. Can be 'error'
(default), to raise an error, ‘drop’ to only retain the row occurring
first in the events, or 'merge' to combine the coinciding
events (=duplicates) into a new event (see Notes for details).
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
A tuple 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 tuple; otherwise it will be
a tuple 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
For example with the event_id {'aud':1,'vis':2} and the events
[[0,0,1],[0,0,2]], the “merge” behavior will update both event_id
and events to be: {'aud/vis':3} and [[0,0,3]] respectively.
There is limited support for Annotations in the
Epochs class. Currently annotations that are present in the
Raw object will be preserved in the resulting
Epochs object, but:
It is not yet possible to add annotations
to the Epochs object programmatically (via code) or interactively
(through the plot window)
Concatenating Epochs objects
that contain annotations is not supported, and any annotations will
be dropped when concatenating.
Epochs can be accessed as epochs[...] in several ways:
Integer or slice:epochs[idx] will return an Epochs
object with a subset of epochs chosen by index (supports single
index and Python-style slicing).
String:epochs['name'] will return an Epochs object
comprising only the epochs labeled 'name' (i.e., epochs created
around events with the label 'name').
If there are no epochs labeled 'name' but there are epochs
labeled with /-separated tags (e.g. 'name/left',
'name/right'), then epochs['name'] will select the epochs
with labels that contain that tag (e.g., epochs['left'] selects
epochs labeled 'audio/left' and 'visual/left', but not
'audio_left').
If multiple tags are provided as a single string (e.g.,
epochs['name_1/name_2']), this selects epochs containing all
provided tags. For example, epochs['audio/left'] selects
'audio/left' and 'audio/quiet/left', but not
'audio/right'. Note that tag-based selection is insensitive to
order: tags like 'audio/left' and 'left/audio' will be
treated the same way when selecting via tag.
List of strings:epochs[['name_1','name_2',...]] will
return an Epochs object comprising epochs that match any of
the provided names (i.e., the list of names is treated as an
inclusive-or condition). If none of the provided names match any
epoch labels, a KeyError will be raised.
If epoch labels are /-separated tags, then providing multiple tags
as separate list entries will likewise act as an inclusive-or
filter. For example, epochs[['audio','left']] would select
'audio/left', 'audio/right', and 'visual/left', but not
'visual/right'.
Pandas query:epochs['pandasquery'] will return an
Epochs object with a subset of epochs (and matching
metadata) selected by the query called with
self.metadata.eval, e.g.:
epochs["col_a > 2 and col_b == 'foo'"]
would return all epochs whose associated col_a metadata was
greater than two, and whose col_b metadata was the string ‘foo’.
Query-based indexing only works if Pandas is installed and
self.metadata is a pandas.DataFrame.
Add raw annotations into the Epochs metadata data frame.
Adds three columns to the metadata consisting of a list
in each row:
- annot_onset: the onset of each Annotation within
the Epoch relative to the start time of the Epoch (in seconds).
- annot_duration: the duration of each Annotation
within the Epoch in seconds.
- annot_description: the free-form text description of each
Annotation.
If True, force the info for objects to be appended to match the
values in self. This should generally only be used when adding
stim channels for which important metadata won’t be overwritten.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Add reference channels to data that consists of all zeros.
Adds reference channels to data that were not included during
recording. This is useful when you need to re-reference your data
to different channels. These added channels will consist of all zeros.
Name of the electrode(s) which served as the reference in the
recording. If a name is provided, a corresponding channel is added
and its data is set to 0. This is useful for later re-referencing.
Number of days to subtract from all dates.
If None (default), the acquisition date, info['meas_date'],
will be set to January1ˢᵗ,2000. This parameter is ignored if
info['meas_date'] is None (i.e., no acquisition date has been set).
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
The time interval to consider as “baseline” when applying baseline
correction. If None, do not apply baseline correction.
If a tuple (a,b), the interval is between a and b
(in seconds), including the endpoints.
If a is None, the beginning of the data is used; and if b
is None, it is set to the end of the data.
If (None,None), the entire time interval is used.
Note
The baseline (a,b) includes both endpoints, i.e. all timepoints t
such that a<=t<=b.
Correction is applied to each epoch and channel individually in the
following way:
Calculate the mean signal of the baseline period.
Subtract this mean from the entire epoch.
Defaults to (None,0), i.e. beginning of the the data until
time point zero.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
The function fun is applied to the channels defined in picks.
The epochs object’s data is modified in-place. If the function returns a different
data type (e.g. numpy.complex128) it must be specified
using the dtype parameter, which causes the data type of all the data
to change (even if the function is only applied to channels in
picks). The object has to have the data loaded e.g. with preload=True or self.load_data().
Note
If n_jobs > 1, more memory is required as
len(picks)*n_times additional time points need to
be temporarily stored in memory.
Note
If the data type changes (dtype!=None), more memory is
required since the original and the converted data needs
to be stored in memory.
A function to be applied to the channels. The first argument of
fun has to be a timeseries (numpy.ndarray). The function must
operate on an array of shape (n_times,) if channel_wise=True and (len(picks),n_times) otherwise.
The function must return an ndarray shaped like its input.
Note
If channel_wise=True, one can optionally access the index and/or the
name of the currently processed channel within the applied function.
This can enable tailored computations for different channels.
To use this feature, add ch_idx and/or ch_name as
additional argument(s) to your function definition.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all data channels
(excluding reference MEG channels). Note that channels in info['bads']will be included if their names or indices are explicitly provided.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs. Ignored if channel_wise=False as the workload
is split across channels.
Whether to apply the function to each channel in each epoch individually. If False,
the function will be applied to all epochs and channels at once. Default True.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all data channels
(excluding reference MEG channels). Note that channels in info['bads']will be included if their names or indices are explicitly provided.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Points to use in the FFT for Hilbert transformation. The signal
will be padded with zeros before computing Hilbert, then cut back
to original length. If None, n == self.n_times. If ‘auto’,
the next highest fast FFT length will be use.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
If envelope=False, the analytic signal for the channels/vertices defined in
picks is computed and the data of the Raw object is converted to
a complex representation (the analytic signal is complex valued).
If envelope=True, the absolute value of the analytic signal for the
channels/vertices defined in picks is computed, resulting in the envelope
signal.
If envelope=False, more memory is required since the original raw data
as well as the analytic signal have temporarily to be stored in memory.
If n_jobs > 1, more memory is required as len(picks)*n_times
additional time points need to be temporarily stored in memory.
Also note that the n_fft parameter will allow you to pad the signal
with zeros before performing the Hilbert transform. This padding
is cut off, but it may result in a slightly different result
(particularly around the edges). Use at your own risk.
Analytic signal
The analytic signal “x_a(t)” of “x(t)” is:
x_a=F^{-1}(F(x)2U)=x+iy
where “F” is the Fourier transform, “U” the unit step function,
and “y” the Hilbert transform of “x”. One usage of the analytic
signal is the computation of the envelope signal, which is given by
“e(t) = abs(x_a(t))”. Due to the linearity of Hilbert transform and the
MNE inverse solution, the enevlope in source space can be obtained
by computing the analytic signal in sensor space, applying the MNE
inverse, and computing the envelope in source space.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
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 againevoked.copy().del_proj(0).apply_proj().plot()evoked.apply_proj()# finally keep both
Using virtual epochs to compute inverse can yield
unexpected results. The virtual channels have '_v' appended
at the end of the names to emphasize that the data contained in
them are interpolated.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all data channels. Note
that channels in info['bads']will be included if their names or
indices are explicitly provided.
How to combine the data. If “mean”/”median”, the mean/median
are returned.
Otherwise, must be a callable which, when passed an array of shape
(n_epochs, n_channels, n_time) returns an array of shape
(n_channels, n_time).
Note that due to file type limitations, the kind for all
these will be “average”.
When False (the default) all epochs are processed together and a single
Evoked object is returned. When True, epochs are first
grouped by event type (as specified using the event_id parameter) and a
list is returned containing a separate Evoked object for each
event type. The .comment attribute is set to the label of the event
type.
The averaged epochs.
When by_event_type=True was specified, a list is returned containing a
separate Evoked object for each event type. The list has the
same order as the event types as specified in the event_id
dictionary.
Notes
Computes an average of all epochs in the instance, even if
they correspond to different conditions. To average by condition,
do epochs[condition].average() for each condition separately.
When picks is None and epochs contain only ICA channels, no channels
are selected, resulting in an error. This is because ICA channels
are not considered data channels (they are of misc type) and only data
channels are selected when picks is None.
The method parameter allows e.g. robust averaging.
For example, one could do:
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick good data channels
(excluding reference MEG channels). Note that channels in info['bads']will be included if their names or indices are explicitly provided.
Channel names to exclude. If 'bads', channels
in info['bads'] are excluded; pass an empty list to
include all channels (including “bad” channels, if any).
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
**method_kw
Additional keyword arguments passed to the spectral estimation
function (e.g., n_fft,n_overlap,n_per_seg,average,window
for Welch method, or bandwidth,adaptive,low_bias,normalization
for multitaper method). See psd_array_welch()
and psd_array_multitaper() for details. Note
that for Welch method if n_fft is unspecified its default will be
the smaller of 2048 or the number of available time samples (taking into
account tmin and tmax), not 256 as in
psd_array_welch().
Spectrotemporal power estimation method. 'morlet' uses Morlet wavelets,
'multitaper' uses DPSS tapers [2], and 'stockwell' uses the S-transform [3][4][5][6]. None (the
default) only works when using __setstate__ and will raise an error otherwise.
The frequencies at which to compute the power estimates.
If method='stockwell' this must be a length 2 iterable specifying lowest
and highest frequencies, or 'auto' (to use all available frequencies).
For other methods, must be an array of shape (n_freqs,). None (the
default) only works when using __setstate__ and will raise an error otherwise.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick good data channels
(excluding reference MEG channels). Note that channels in info['bads']will be included if their names or indices are explicitly provided.
Whether to return average power across epochs (instead of single-trial
power). average=True is not compatible with output="complex" or
output="phase". Ignored if method="stockwell" (Stockwell method
requires averaging). Default is False.
Whether to return inter-trial coherence (ITC) as well as power estimates.
If True then must specify average=True (or method="stockwell",average="auto"). Default is False.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
**method_kw
Additional keyword arguments passed to the spectrotemporal estimation function
(e.g., n_cycles,use_fft,zero_mean for Morlet method, n_fft,width for Stockwell method,
or n_cycles,use_fft,zero_mean,time_bandwidth for multitaper method).
See tfr_array_morlet(), tfr_array_stockwell(),
and tfr_array_multitaper() for additional details.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Unlike Python slices, MNE time intervals by default include both
their end points; crop(tmin,tmax) returns the interval
tmin<=t<=tmax. Pass include_tmax=False to specify the half-open
interval tmin<=t<tmax instead.
Low-pass filtering is not performed, this simply selects
every Nth sample (where N is the value passed to
decim), i.e., it compresses the signal (see Notes).
If the data are not properly filtered, aliasing artifacts
may occur.
See Resampling and decimating data for more information.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
For historical reasons, decim / “decimation” refers to simply subselecting
samples from a given signal. This contrasts with the broader signal processing
literature, where decimation is defined as (quoting
[7], p. 172; which cites
[8]):
“… a general system for downsampling by a factor of M is the one shown
in Figure 4.23. Such a system is called a decimator, and downsampling
by lowpass filtering followed by compression [i.e, subselecting samples]
has been termed decimation (Crochiere and Rabiner, 1983).”
Hence “decimation” in MNE is what is considered “compression” in the signal
processing community.
Decimation can be done multiple times. For example,
inst.decimate(2).decimate(2) will be the same as
inst.decimate(4).
If decim is 1, this method does not copy the underlying data.
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 mne.Epochs.drop_bad() or
mne.Epochs.load_data() methods.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Reject epochs based on maximum peak-to-peak signal amplitude (PTP)
or custom functions. Peak-to-peak signal amplitude is defined as
the absolute difference between the lowest and the highest signal
value. In each individual epoch, the PTP is calculated for every channel.
If the PTP of any one channel exceeds the rejection threshold, the
respective epoch will be dropped.
The dictionary keys correspond to the different channel types; valid
keys can be any channel type present in the object.
Example:
reject=dict(grad=4000e-13,# unit: T / m (gradiometers)mag=4e-12,# unit: T (magnetometers)eeg=40e-6,# unit: V (EEG channels)eog=250e-6# unit: V (EOG channels))
Custom rejection criteria can be also be used by passing a callable,
e.g., to check for 99th percentile of absolute values of any channel
across time being bigger than 1 mV. The callable must return a
(good,reason) tuple: good must be bool and reason
must be str, list, or tuple where each entry
is a str:
If rejection is based on a signal difference
calculated for each channel separately, applying baseline
correction does not affect the rejection procedure, as the
difference will be preserved.
Note
If reject is a callable, than any criteria can be
used to reject epochs (including maxima and minima).
If reject is None, no rejection is performed. If 'existing'
(default), then the rejection parameters set at instantiation are used.
Reject epochs based on minimum peak-to-peak signal amplitude (PTP)
or a custom function. Valid keys can be any channel type present
in the object. If using PTP, values are floats that set the minimum
acceptable PTP. If the PTP is smaller than this threshold, the epoch
will be dropped. If None then no rejection is performed based on
flatness of the signal. If a custom function is used than flat can be
used to reject epochs based on any criteria (including maxima and
minima).
If 'existing', then the flat parameters set during epoch creation are
used.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
The epochs with bad epochs dropped. Operates in-place.
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.
Iterable (e.g. list) of channel name(s) or channel name to remove.
on_missing‘raise’ | ‘warn’ | ‘ignore’
Can be 'raise' (default) to raise an error, 'warn' to emit a
warning, or 'ignore' to ignore when entries in ch_names are not present in the raw instance.
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
within a Epochs instance. For example, if one event type
occurred at time points [1,2,3,4,120,121] and the another one
at [3.5,4.5,120.5,121.5], this method would remove the events at
times [1,2] for the first event type – and not the events at times
[120,121].
If None (default), equalize the counts of all event types
present in the Epochs instance.
If a list, each element can either be a string (event name) or a
list of strings. In the case where one of the entries is a list of
strings, event types in that list will be grouped together before
equalizing trial counts across conditions.
If a dictionary, the keys are considered as the event names whose
counts to equalize, i.e., passing dict(A=1,B=2) will have the
same effect as passing ['A','B']. This is useful if you intend
to pass an event_id dictionary that was used when creating
Epochs.
In the case where partial matching is used (using / in
the event names), the event types 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 non-overlapping subsets of the
epochs.
method'truncate' | 'mintime' | 'random'
If 'truncate', events will be truncated from the end of each event
list. If 'mintime', timing differences between each event list will be
minimized. If 'random', events will be randomly selected from each event
list.
A seed for the NumPy random number generator (RNG). If None (default),
the seed will be obtained from the operating system
(see RandomState for details), meaning it will most
likely produce different output every time this function or method is run.
To achieve reproducible results, pass a value here to explicitly initialize
the RNG with a defined state. Used only if method='random'.
would equalize the number of trials in the 'Nonspatial' condition
with the total number of trials in the 'Left' and 'Right'
conditions combined.
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 equally. E.g., it is possible to end up
with 70 'Nonspatial' epochs, 69 'Left' and 1 'Right'.
Changed in version 0.23: Default to equalizing all events in the passed instance if no
event names were specified explicitly.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Notes
New in v0.24.
Export to external format may not preserve all the information from the
instance. To save in native MNE format (.fif) without information loss,
use mne.Epochs.save() instead.
Export does not apply projector(s). Unapplied projector(s) will be lost.
Consider applying projector(s) before exporting with
mne.Epochs.apply_proj().
For EEGLAB exports, channel locations are expanded to full EEGLAB format.
For more details see eeglabio.utils.cart_to_eeglab().
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all data channels. Note
that channels in info['bads']will be included if their names or
indices are explicitly provided.
‘auto’ (default): The filter length is chosen based
on the size of the transition regions (6.6 times the reciprocal
of the shortest transition band for fir_window=’hamming’
and fir_design=”firwin2”, and half that for “firwin”).
str: A human-readable time in
units of “s” or “ms” (e.g., “10s” or “5500ms”) will be
converted to that number of samples if phase="zero", or
the shortest power-of-two length at least that duration for
phase="zero-double".
int: Specified length in samples. For fir_design=”firwin”,
this should not be used.
Width of the transition band at the low cut-off frequency in Hz
(high pass or cutoff 1 in bandpass). Can be “auto”
(default) to use a multiple of l_freq:
Width of the transition band at the high cut-off frequency in Hz
(low pass or cutoff 2 in bandpass). Can be “auto”
(default in 0.14) to use a multiple of h_freq:
Dictionary of parameters to use for IIR filtering.
If iir_params=None and method="iir", 4th order Butterworth will be used.
For more information, see mne.filter.construct_iir_filter().
Phase of the filter.
When method='fir', symmetric linear-phase FIR filters are constructed
with the following behaviors when method="fir":
"zero" (default)
The delay of this filter is compensated for, making it non-causal.
"minimum"
A minimum-phase filter will be constructed by decomposing the zero-phase filter
into a minimum-phase and all-pass systems, and then retaining only the
minimum-phase system (of the same length as the original zero-phase filter)
via scipy.signal.minimum_phase().
"zero-double"
This is a legacy option for compatibility with MNE <= 0.13.
The filter is applied twice, once forward, and once backward
(also making it non-causal).
"minimum-half"
This is a legacy option for compatibility with MNE <= 1.6.
A minimum-phase filter will be reconstructed from the zero-phase filter with
half the length of the original filter.
When method='iir', phase='zero' (default) or equivalently 'zero-double'
constructs and applies IIR filter twice, once forward, and once backward (making it
non-causal) using filtfilt(); phase='forward' will apply
the filter once in the forward (causal) direction using
lfilter().
New in v0.13.
Changed in version 1.7: The behavior for phase="minimum" was fixed to use a filter of the requested
length and improved suppression.
Can be “firwin” (default) to use scipy.signal.firwin(),
or “firwin2” to use scipy.signal.firwin2(). “firwin” uses
a time-domain design technique that generally gives improved
attenuation using fewer samples than “firwin2”.
If a string (or list of str), any annotation segment that begins
with the given string will not be included in filtering, and
segments on either side of the given excluded annotated segment
will be filtered separately (i.e., as independent signals).
The default (('edge','bad_acq_skip') will separately filter
any segments that were concatenated by mne.concatenate_raws()
or mne.io.Raw.append(), or separated during acquisition.
To disable, provide an empty list. Only used if inst is raw.
The type of padding to use. Supports
all numpy.pad()mode options. Can also be "reflect_limited", which
pads with a reflected version of each vector mirrored on the first and last values
of the vector, followed by zeros.
Only used for method='fir'.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
A list of lists (with length equal to number of epochs) where each
inner list contains any annotations that overlap the corresponding
epoch. Annotations are stored as a tuple of onset,
duration, description (not as a Annotations object),
where the onset is now relative to time=0 of the epoch, rather than
time=0 of the original continuous (raw) data.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all channels. Note that
channels in info['bads']will be included if their names or indices
are explicitly provided.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all channels. Note that
channels in info['bads']will be included if their names or indices
are explicitly provided.
The items to get. See mne.Epochs.__getitem__() for
a description of valid options. This can be substantially faster
for obtaining an ndarray than __getitem__()
for repeated access on large Epochs objects.
None (default) is an alias for slice(None).
Specify the unit(s) that the data should be returned in. If
None (default), the data is returned in the
channel-type-specific default units, which are SI units (see
Internal representation (units) and data channels). If a string, must be a
sub-multiple of SI units that will be used to scale the data from
all channels of the type associated with that unit. This only works
if the data contains one channel type that has a unit (unitless
channel types are left unchanged). For example if there are only
EEG and STIM channels, units='uV' will scale EEG channels to
micro-Volts while STIM channels will be unchanged. Finally, if a
dictionary is provided, keys must be channel types, and values must
be units to scale the data of that channel type to. For example
dict(grad='fT/cm',mag='fT') will scale the corresponding types
accordingly, but all other channel types will remain in their
channel-type-specific default unit.
Whether to return a copy of the object’s data, or (if possible) a view.
See the NumPy docs for an
explanation. Default is False in 1.6 but will change to True in 1.7,
set it explicitly to avoid a warning in some cases. A view is only possible
when itemisNone, picksisNone, unitsisNone, and data are
preloaded.
Warning
Using copy=False and then modifying the returned data will in
turn modify the Epochs object. Use with caution!
Changed in version 1.7: The default changed from False to True.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Returns:
dataarray of shape (n_epochs, n_channels, n_times)
The epochs data. Will be a copy when copy=True and will be a view
when possible when copy=False.
A montage containing channel positions. If a string or
DigMontage is
specified, the existing channel information will be updated with the
channel positions from the montage. Valid strings are the names of the
built-in montages that ship with MNE-Python; you can list those via
mne.channels.get_builtin_montages().
If None (default), the channel positions will be removed from the
Info.
Either 'accurate' or 'fast', determines the quality of the
Legendre polynomial expansion used for interpolation of channels
using the minimum-norm method.
If a str is provided, the method will be applied to all channel
types supported and available in the instance. The method "nan" will
replace the channel data with np.nan.
Warning
Be careful when using method="nan"; the default value
reset_bads=True may not be what you want.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all channels. Note that
channels in info['bads']will be included if their names or indices
are explicitly provided.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
The channel names given are assumed to be a set, i.e. the order
does not matter. The original order of the channels is preserved.
You can use reorder_channels to set channel order if necessary.
If True include MEG channels. If string it can be ‘mag’, ‘grad’,
‘planar1’ or ‘planar2’ to select only magnetometers, all
gradiometers, or a specific type of gradiometer.
If True include CTF / 4D reference channels. If ‘auto’, reference
channels are included if compensations are present and meg is
not False. Can also be the string options for the meg
parameter.
Functional near-infrared spectroscopy channels. If True include all
fNIRS channels. If False (default) include none. If string it can
be ‘hbo’ (to include channels measuring oxyhemoglobin) or ‘hbr’ (to
include channels measuring deoxyhemoglobin).
Eyetracking channels. If True include all eyetracking channels. If False
(default) include none. If string it can be ‘eyegaze’ (to include
eye position channels) or ‘pupil’ (to include pupil-size
channels).
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
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.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick good data channels. Note
that channels in info['bads']will be included if their names or
indices are explicitly provided.
Scaling factors for the traces. If a dictionary where any
value is 'auto', the scaling factor is set to match the 99.5th
percentile of the respective data. If 'auto', all scalings (for all
channel types) are set to 'auto'. If any values are 'auto' and the
data is not preloaded, a subset up to 100 MB will be loaded. If None,
defaults to:
A particular scaling value s corresponds to half of the visualized
signal range around zero (i.e. from 0 to +s or from 0 to
-s). For example, the default scaling of 20e-6 (20µV) for EEG
signals means that the visualized range will be 40 µV (20 µV in the
positive direction and 20 µV in the negative direction).
Events to show with vertical bars. You can use plot_events
as a legend for the colors. By default, the coloring scheme is the
same. True plots epochs.events. Defaults to False (do not
plot events).
Warning
If the epochs have been resampled, the events no longer
align with the data.
New in v0.14.0.
Changed in version 1.6: Passing events=None was disallowed.
The new equivalent is events=False.
Color(s) to use for events. To show all events in the same
color, pass any matplotlib-compatible color. To color events differently,
pass a dict that maps event names or integer event numbers to colors
(must include entries for all events, or include a “fallback” entry with
key -1). If None, colors are chosen from the current Matplotlib
color cycle.
Defaults to None.
Amount to decimate the data during display for speed purposes.
You should only decimate if the data are sufficiently low-passed,
otherwise aliasing can occur. The ‘auto’ mode (default) uses
the decimation that results in a sampling rate at least three times
larger than info['lowpass'] (e.g., a 40 Hz lowpass will result in
at least a 120 Hz displayed sample rate).
Noise covariance used to whiten the data while plotting.
Whitened data channels are scaled by scalings['whitened'],
and their channel names are shown in italic.
Can be a string to load a covariance from disk.
See also mne.Evoked.plot_white() for additional inspection
of noise covariance properties when whitening evoked data.
For data processed with SSS, the effective dependence between
magnetometers and gradiometers may introduce differences in scaling,
consider using mne.Evoked.plot_white().
Whether to show scrollbars when the plot is initialized. Can be toggled
after initialization by pressing z (“zen mode”) while the plot
window is focused. Default is True.
Whether to show scale bars when the plot is initialized. Can be toggled
after initialization by pressing s while the plot window is focused.
Default is True.
New in v0.24.0.
epoch_colorslist of (n_epochs) list (of n_channels) | None
Colors to use for individual epochs. If None, use default colors.
Determines to label the event markers on the plot. If True, uses
epochs.event_id. If False, uses integer event codes instead of IDs.
If a dict is passed, uses its keys as event labels on the plot for
entries whose values are integer codes for events being drawn. Ignored if
events=False.
How to group channels. 'type' groups by channel type,
'original' plots in the order of ch_names, 'selection' uses
Elekta’s channel groupings (only works for Neuromag data),
'position' groups the channels by the positions of the sensors.
'selection' and 'position' modes allow custom selections by
using a lasso selector on the topomap. In butterfly mode, 'type'
and 'original' group the channels by type, whereas 'selection'
and 'position' use regional grouping. 'type' and 'original'
modes are ignored when order is not None. Defaults to 'type'.
Whether to load all data (not just the visible portion) into RAM and
apply preprocessing (e.g., projectors) to the full data array in a separate
processor thread, instead of window-by-window during scrolling. The default
None uses the MNE_BROWSER_PRECOMPUTE variable, which defaults to
'auto'. 'auto' compares available RAM space to the expected size of
the precomputed data, and precomputes only if enough RAM is available.
This is only used with the Qt backend.
New in v0.24.
Changed in version 1.0: Support for the MNE_BROWSER_PRECOMPUTE config variable.
Whether to use OpenGL when rendering the plot (requires pyopengl).
May increase performance, but effect is dependent on system CPU and
graphics hardware. Only works if using the Qt backend. Default is
None, which will use False unless the user configuration variable
MNE_BROWSER_USE_OPENGL is set to 'true',
see mne.set_config().
Can be “auto”, “light”, or “dark” or a path-like to a
custom stylesheet. For Dark-Mode and automatic Dark-Mode-Detection,
qdarkstyle and
darkdetect,
respectively, are required. If None (default), the config option MNE_BROWSER_THEME will be used,
defaulting to “auto” if it’s not found.
Only supported by the 'qt' backend.
Can be “channels”, “empty”, or “hidden” to set the overview bar mode
for the 'qt' backend. If None (default), the config option
MNE_BROWSER_OVERVIEW_MODE will be used, defaulting to “channels”
if it’s not found.
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. h key plots a histogram of
peak-to-peak values along with the used rejection thresholds. Butterfly
plot can be toggled with b key. Left mouse click adds a vertical line
to the plot. Click ‘help’ button at bottom left corner of the plotter to
view all the options.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick good data channels. Note
that channels in info['bads']will be included if their names or
indices are explicitly provided.
picks interacts with group_by and combine to determine the
number of figures generated; see Notes.
The min value in the image (and the ER[P/F]). The unit is µV for
EEG channels, fT for magnetometers and fT/cm for gradiometers.
If vmin is None and multiple plots are returned, the limit is
equalized within channel types.
Hint: to specify the lower limit of the data, use
vmin=lambdadata:data.min().
The max value in the image (and the ER[P/F]). The unit is µV for
EEG channels, fT for magnetometers and fT/cm for gradiometers.
If vmin is None and multiple plots are returned, the limit is
equalized within channel types.
If not None, order is used to reorder the epochs along the y-axis
of the image. If it is an array of int, its length should
match the number of good epochs. If it is a callable it should accept
two positional parameters (times and data, where
data.shape==(len(good_epochs),len(times))) and return an
array of indices that will sort data along
its first axis.
Colormap. If tuple, the first value indicates the colormap to use and
the second value is a boolean defining interactivity. In interactive
mode the colors are adjustable by clicking and dragging the colorbar
with left and right mouse button. Left mouse button moves the scale up
and down and right mouse button adjusts the range. Hitting space bar
resets the scale. Up and down arrows can be used to change the
colormap. If ‘interactive’, translates to (‘RdBu_r’, True).
If None, “RdBu_r” is used, unless the data is all positive, in which
case “Reds” is used.
Figure instance to draw the image to.
Figure must contain the correct number of axes for drawing the epochs
image, the evoked response, and a colorbar (depending on values of
evoked and colorbar). If None a new figure is created.
Defaults to None.
List of Axes objects in which to draw the
image, evoked response, and colorbar (in that order). Length of list
must be 1, 2, or 3 (depending on values of colorbar and evoked
parameters). If a dict, each entry must be a list of Axes
objects with the same constraints as above. If both axes and
group_by are dicts, their keys must match. Providing non-None
values for both fig and axes results in an error. Defaults to
None.
Times (in seconds) at which to draw a line on the corresponding row of
the image (e.g., a reaction time associated with each epoch). Note that
overlay_times should be ordered to correspond with the
Epochs object (i.e., overlay_times[0] corresponds to
epochs[0], etc).
How to aggregate across channels. If None, channels are combined by
computing GFP/RMS, unless group_by is also None and picks is a
list of specific channels (not channel types), in which case no combining
is performed and each channel gets its own figure. If a string,
"mean" uses numpy.mean(), "median" computes the marginal median, "std"
uses numpy.std(), and "gfp" computes global field power
for EEG channels and RMS amplitude for MEG channels.
If callable(), it must operate on an array
of shape (n_epochs,n_channels,n_times) and return an array of shape
(n_epochs,n_times). For example:
Specifies which channels are aggregated into a single figure, with
aggregation method determined by the combine parameter. If not
None, one Figure is made per dict
entry; the dict key will be used as the figure title and the dict
values must be lists of picks (either channel names or integer indices
of epochs.ch_names). For example:
Note that within a dict entry all channels must have the same type.
group_by interacts with picks and combine to determine the
number of figures generated; see Notes. Defaults to None.
Arguments passed to a call to plot_compare_evokeds to style
the evoked plot below the image. Defaults to an empty dictionary,
meaning plot_compare_evokeds will be called with default
parameters.
One figure per channel, channel type, or group, depending on values of
picks, group_by, and combine. See Notes.
Notes
You can control how channels are aggregated into one figure or plotted in
separate figures through a combination of the picks, group_by, and
combine parameters. If group_by is a dict, the result is
one Figure per dictionary key (for any valid
values of picks and combine). If group_by is None, the
number and content of the figures generated depends on the values of
picks and combine, as summarized in this table:
group_by
picks
combine
result
dict
None, int, list of int,
ch_name, list of ch_names,
ch_type, list of ch_types
The channel type to plot. For 'grad', the gradiometers are
collected in pairs and the RMS for each pair is plotted. If
None it will return all channel types present.. If a list of ch_types is provided, it will return multiple figures. Defaults to None.
Whether to add markers for sensor locations. If str, should be a
valid matplotlib format string (e.g., 'r+' for red plusses, see the
Notes section of plot()). If True (the
default), black circles will be used.
If True, show channel names next to each sensor marker. If callable,
channel names will be formatted using the callable; e.g., to
delete the prefix ‘MEG ‘ from all channel names, pass the function
lambdax:x.replace('MEG',''). If mask is not None, only
non-masked sensor names will be shown.
The number of contour lines to draw. If 0, no contours will be drawn.
If a positive integer, that number of contour levels are chosen using the
matplotlib tick locator (may sometimes be inaccurate, use array for
accuracy). If array-like, the array values are used as the contour levels.
The values should be in µV for EEG, fT for magnetometers and fT/m for
gradiometers. If colorbar=True, the colorbar will have ticks
corresponding to the contour levels. Default is 6.
The outlines to be drawn. If ‘head’, the default head scheme will be
drawn. If dict, each key refers to a tuple of x and y positions, the values
in ‘mask_pos’ will serve as image mask.
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’.
The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel to use the origin and
radius from that object. If 'auto' the sphere is fit to digitization
points. If 'eeglab' the head circle is defined by EEG electrodes
'Fpz', 'Oz', 'T7', and 'T8' (if 'Fpz' is not present,
it will be approximated from the coordinates of 'Oz'). None (the
default) is equivalent to 'auto' when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise.
Extrapolate to four points placed to form a square encompassing all
data points, where each side of the square is three times the range
of the data in the respective dimension.
'local' (default for MEG sensors)
Extrapolate only to nearby points (approximately to points closer than
median inter-electrode distance). This will also set the
mask to be polygonal based on the convex hull of the sensors.
'head' (default for non-MEG sensors)
Extrapolate out to the edges of the clipping circle. This will be on
the head circle when the sensors are contained within the head circle,
but it can extend beyond the head when sensors are plotted outside
the head circle.
New in v0.20.
Changed in version 0.21:
The default was changed to 'local' for MEG sensors.
'local' was changed to use a convex hull mask
'head' was changed to extrapolate out to the clipping circle.
Colormap to use. If tuple, the first value indicates the colormap
to use and the second value is a boolean defining interactivity. In
interactive mode the colors are adjustable by clicking and dragging the
colorbar with left and right mouse button. Left mouse button moves the
scale up and down and right mouse button adjusts the range. Hitting
space bar resets the range. Up and down arrows can be used to change
the colormap. If None, 'Reds' is used for data that is either
all-positive or all-negative, and 'RdBu_r' is used otherwise.
'interactive' is equivalent to (None,True). Defaults to None.
Warning
Interactive mode works smoothly only for a small amount
of topomaps. Interactive mode is disabled by default for more than
2 topomaps.
Lower and upper bounds of the colormap, typically a numeric value in the same
units as the data. Elements of the tuple may also be callable functions
which take in a NumPyarray and return a scalar.
If both entries are None, the bounds are set at ± the maximum absolute value
of the data (yielding a colormap with midpoint at 0), or (0,max(abs(data)))
if the (possibly baselined) data are all-positive.
Providing None for just one entry will set the corresponding boundary at the
min/max of the data. If vlim="joint", will compute the colormap limits
jointly across all projectors of the same channel type (instead of separately
for each projector), using the min/max of the data for that channel type.
If vlim is "joint", info must not be None. Defaults to (None,None).
How to normalize the colormap. If None, standard linear normalization
is performed. If not None, vmin and vmax will be ignored.
See Matplotlib docs
for more details on colormap normalization, and
the ERDs example for an example of its use.
The axes to plot into. If None, a new Figure
will be created with the correct number of axes. If Axes
are provided (either as a single instance or a list of axes),
the number of axes provided must match the number of projectors. Default is None.
Separate plots are drawn for each channel type. When the data have been
processed with a bandpass, lowpass or highpass filter, dashed lines (╎)
indicate the boundaries of the filter. The line noise frequency is also
indicated with a dashed line (⋮). If average=False, the plot will
be interactive, and click-dragging on the spectrum will generate a
scalp topography plot for the chosen frequency range in a new figure.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick good data channels
(excluding reference MEG channels). Note that channels in info['bads']will be included if their names or indices are explicitly provided.
If False, the PSDs of all channels is displayed. No averaging
is done and parameters area_mode and area_alpha are ignored. When
False, it is possible to paint an area (hold left mouse button and
drag) to plot a topomap.
Plot Power Spectral Density (PSD), in units (amplitude**2/Hz (dB)) if
dB=True, and estimate='power' or estimate='auto'. Plot PSD
in units (amplitude**2/Hz) if dB=False and,
estimate='power'. Plot Amplitude Spectral Density (ASD), in units
(amplitude/sqrt(Hz)), if dB=False and estimate='amplitude' or
estimate='auto'. Plot ASD, in units (amplitude/sqrt(Hz) (dB)), if
dB=True and estimate='amplitude'.
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. If average=False, no area is plotted.
The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel to use the origin and
radius from that object. If 'auto' the sphere is fit to digitization
points. If 'eeglab' the head circle is defined by EEG electrodes
'Fpz', 'Oz', 'T7', and 'T8' (if 'Fpz' is not present,
it will be approximated from the coordinates of 'Oz'). None (the
default) is equivalent to 'auto' when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise.
Channels names to exclude from being shown. If ‘bads’, the bad
channels are excluded. Pass an empty list to plot all channels
(including channels marked “bad”, if any).
The axes to plot into. If None, a new Figure
will be created with the correct number of axes. If Axes
are provided (either as a single instance or a list of axes),
the number of axes provided must match the number of channel types present in the object.. Default is None.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
**method_kw
Additional keyword arguments passed to the spectral estimation
function (e.g., n_fft,n_overlap,n_per_seg,average,window
for Welch method, or bandwidth,adaptive,low_bias,normalization
for multitaper method). See psd_array_welch()
and psd_array_multitaper() for details. Note
that for Welch method if n_fft is unspecified its default will be
the smaller of 2048 or the number of available time samples (taking into
account tmin and tmax), not 256 as in
psd_array_welch().
Figure with frequency spectra of the data channels.
Notes
This method exists to support legacy code; for new code the preferred
idiom is inst.compute_psd().plot() (where inst is an instance
of Raw, Epochs, or Evoked).
Layout instance specifying sensor positions (does not need to be
specified for Neuromag data). If None (default), the layout is
inferred from the data (if possible).
The axes to plot into. If None, a new Figure
will be created with the correct number of axes. If Axes
are provided (either as a single instance or a list of axes),
the number of axes provided must be length 1 (for efficiency, subplots for each channel are simulated within a single Axes object). Default is None.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
**method_kw
Additional keyword arguments passed to the spectral estimation
function (e.g., n_fft,n_overlap,n_per_seg,average,window
for Welch method, or bandwidth,adaptive,low_bias,normalization
for multitaper method). See psd_array_welch()
and psd_array_multitaper() for details. Note
that for Welch method if n_fft is unspecified its default will be
the smaller of 2048 or the number of available time samples (taking into
account tmin and tmax), not 256 as in
psd_array_welch(). Defaults to dict(n_fft=2048).
The frequencies or frequency ranges to plot. If a dict, keys will
be used as subplot titles and values should be either a single frequency
(e.g., {'presentationrate':6.5}) or a length-two sequence of lower
and upper frequency band edges (e.g., {'theta':(4,8)}). If a single
frequency is provided, the plot will show the frequency bin that is closest
to the requested value. If None (the default), expands to:
For backwards compatibility, tuples of length 2 or 3 are
also accepted, where the last element of the tuple is the subplot title
and the other entries are frequency values (a single value or band
edges). New code should use dict or None.
Changed in version 1.2: Allow passing a dict and discourage passing tuples.
The channel type to plot. For 'grad', the gradiometers are
collected in pairs and the mean for each pair is plotted. If
None the first available channel type from order shown above is used. Defaults to None.
Whether to add markers for sensor locations. If str, should be a
valid matplotlib format string (e.g., 'r+' for red plusses, see the
Notes section of plot()). If True (the
default), black circles will be used.
If True, show channel names next to each sensor marker. If callable,
channel names will be formatted using the callable; e.g., to
delete the prefix ‘MEG ‘ from all channel names, pass the function
lambdax:x.replace('MEG',''). If mask is not None, only
non-masked sensor names will be shown.
Array indicating channel-time combinations to highlight with a distinct
plotting style (useful for, e.g. marking which channels at which times a statistical test of the data reaches significance). Array elements set to True will be plotted
with the parameters given in mask_params. Defaults to None,
equivalent to an array of all False elements.
The number of contour lines to draw. If 0, no contours will be drawn.
If a positive integer, that number of contour levels are chosen using the
matplotlib tick locator (may sometimes be inaccurate, use array for
accuracy). If array-like, the array values are used as the contour levels.
The values should be in µV for EEG, fT for magnetometers and fT/m for
gradiometers. If colorbar=True, the colorbar will have ticks
corresponding to the contour levels. Default is 6.
The outlines to be drawn. If ‘head’, the default head scheme will be
drawn. If dict, each key refers to a tuple of x and y positions, the values
in ‘mask_pos’ will serve as image mask.
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’.
The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel to use the origin and
radius from that object. If 'auto' the sphere is fit to digitization
points. If 'eeglab' the head circle is defined by EEG electrodes
'Fpz', 'Oz', 'T7', and 'T8' (if 'Fpz' is not present,
it will be approximated from the coordinates of 'Oz'). None (the
default) is equivalent to 'auto' when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise.
Extrapolate to four points placed to form a square encompassing all
data points, where each side of the square is three times the range
of the data in the respective dimension.
'local' (default for MEG sensors)
Extrapolate only to nearby points (approximately to points closer than
median inter-electrode distance). This will also set the
mask to be polygonal based on the convex hull of the sensors.
'head' (default for non-MEG sensors)
Extrapolate out to the edges of the clipping circle. This will be on
the head circle when the sensors are contained within the head circle,
but it can extend beyond the head when sensors are plotted outside
the head circle.
Colormap to use. If tuple, the first value indicates the colormap
to use and the second value is a boolean defining interactivity. In
interactive mode the colors are adjustable by clicking and dragging the
colorbar with left and right mouse button. Left mouse button moves the
scale up and down and right mouse button adjusts the range. Hitting
space bar resets the range. Up and down arrows can be used to change
the colormap. If None, 'Reds' is used for data that is either
all-positive or all-negative, and 'RdBu_r' is used otherwise.
'interactive' is equivalent to (None,True). Defaults to None.
Warning
Interactive mode works smoothly only for a small amount
of topomaps. Interactive mode is disabled by default for more than
2 topomaps.
Lower and upper bounds of the colormap, typically a numeric value in the same
units as the data. Elements of the tuple may also be callable functions
which take in a NumPyarray and return a scalar.
If both entries are None, the bounds are set at ± the maximum absolute value
of the data (yielding a colormap with midpoint at 0), or (0,max(abs(data)))
if the (possibly baselined) data are all-positive.
Providing None for just one entry will set the corresponding boundary at the
min/max of the data. If vlim="joint", will compute the colormap limits
jointly across all topomaps of the same channel type (instead of separately
for each topomap), using the min/max of the data for that channel type.
Defaults to (None,None).
How to normalize the colormap. If None, standard linear normalization
is performed. If not None, vmin and vmax will be ignored.
See Matplotlib docs
for more details on colormap normalization, and
the ERDs example for an example of its use.
Formatting string for colorbar tick labels. See Format Specification Mini-Language for
details.
If 'auto', is equivalent to ‘%0.3f’ if dB=False and ‘%0.1f’ if
dB=True. Defaults to 'auto'.
The axes to plot into. If None, a new Figure
will be created with the correct number of axes. If Axes
are provided (either as a single instance or a list of axes),
the number of axes provided must match the length of bands. Default is None.
The number of jobs to run in parallel. If -1, it is set
to the number of CPU cores. Requires the joblib package.
None (default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1 (sequential execution) unless the call is performed under
a joblib.parallel_config context manager that sets another
value for n_jobs.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
**method_kw
Additional keyword arguments passed to the spectral estimation
function (e.g., n_fft,n_overlap,n_per_seg,average,window
for Welch method, or bandwidth,adaptive,low_bias,normalization
for multitaper method). See psd_array_welch()
and psd_array_multitaper() for details. Note
that for Welch method if n_fft is unspecified its default will be
the smaller of 2048 or the number of available time samples (taking into
account tmin and tmax), not 256 as in
psd_array_welch().
Whether to plot the sensors as 3d, topomap or as an interactive
sensor selection dialog. Available options ‘topomap’, ‘3d’,
‘select’. If ‘select’, a set of channels can be selected
interactively by using lasso selector or clicking while holding
control key. The selected channels are returned along with the
figure instance. Defaults to ‘topomap’.
The channel type to plot. Available options 'mag', 'grad',
'eeg', 'seeg', 'dbs', 'ecog', 'all'. If 'all', all
the available mag, grad, eeg, seeg, dbs, and ecog channels are plotted. If
None (default), then channels are chosen in the order given above.
Whether to display all channel names. If an array, only the channel
names in the array are shown. Defaults to False.
ch_groups‘position’ | array of shape (n_ch_groups, n_picks) | None
Channel groups for coloring the sensors. If None (default), default
coloring scheme is used. If ‘position’, the sensors are divided
into 8 regions. See order kwarg of mne.viz.plot_raw(). If
array, the channels are divided by picks given in the array.
Whether to project the 3d locations to a sphere. When False, the
sensor array appears similar as to looking downwards straight above
the subject’s head. Has no effect when kind=’3d’. Defaults to True.
The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel to use the origin and
radius from that object. If 'auto' the sphere is fit to digitization
points. If 'eeglab' the head circle is defined by EEG electrodes
'Fpz', 'Oz', 'T7', and 'T8' (if 'Fpz' is not present,
it will be approximated from the coordinates of 'Oz'). None (the
default) is equivalent to 'auto' when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
If not None, order is used to reorder the epochs on the y-axis
of the image. If it’s an array of int it should be of length
the number of good epochs. If it’s a callable the arguments
passed are the times vector and the data as 2d array
(data.shape[1] == len(times)).
Figure distributing one image per channel across sensor topography.
Notes
In an interactive Python session, this plot will be interactive; clicking
on a channel image will pop open a larger view of the image; this image
will always have a colorbar even when the topo plot does not (because it
shows multiple sensor types).
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
When method="fft", this is the frequency-domain window to use in resampling,
and should be the same length as the signal; see scipy.signal.resample()
for details. When method="polyphase", this is the time-domain linear-phase
window to use after upsampling the signal; see scipy.signal.resample_poly()
for details. The default "auto" will use "boxcar" for method="fft" and
("kaiser",5.0) for method="polyphase".
The type of padding to use. When method="fft", supports
all numpy.pad()mode options. Can also be "reflect_limited", which
pads with a reflected version of each vector mirrored on the first and last values
of the vector, followed by zeros.
When method="polyphase", supports all modes of scipy.signal.upfirdn().
Resampling method to use. Can be "fft" (default) or "polyphase"
to use FFT-based on polyphase FIR resampling, respectively. These wrap to
scipy.signal.resample() and scipy.signal.resample_poly(), respectively.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
This method will simplify self.drop_log and self.selection
so that they are meaningless (tuple of empty tuples and increasing
integers, respectively). This can be useful when concatenating
many Epochs instances, as drop_log can accumulate many entries
which can become problematic when saving.
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.
Format to save data. Valid options are ‘double’ or
‘single’ for 64- or 32-bit float, or for 128- or
64-bit complex numbers respectively. Note: Data are processed with
double precision. Choosing single-precision, the saved data
will slightly differ due to the reduction in precision.
If True (default False), overwrite the destination file if it
exists.
To overwrite original file (the same one that was loaded),
data must be preloaded upon reading. This defaults to True in 0.18
but will change to False in 0.19.
New in v0.18.
split_naming‘neuromag’ | ‘bids’
When splitting files, append a filename partition with the appropriate
naming schema: for 'neuromag', a split file fname.fif will be named
fname.fif, fname-1.fif, fname-2.fif etc.; while for 'bids',
it will be named fname_split-01.fif, fname_split-02.fif, etc.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Approximate high cut-off frequency in Hz. Note that this
is not an exact cutoff, since Savitzky-Golay filtering
[9] 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.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Can be 'raise' (default) to raise an error, 'warn' to emit a
warning, or 'ignore' to ignore when entries in ch_names are not present in the raw instance.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Annotation onsets and offsets are stored as time in seconds (not as
sample numbers).
If you have an -epo.fif file saved to disk created before 1.0,
annotations can be added correctly only if no decimation or
resampling was performed. We thus suggest to regenerate your
mne.Epochs from raw and re-save to disk with 1.0+ if you
want to safely work with Annotations in epochs.
Since this method does not handle offsetting the times based
on first_samp or measurement dates, the recommended way to add
Annotations is:
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Use this function to explicitly specify the desired reference for EEG.
This can be either an existing electrode or a new virtual channel.
This function will re-reference the data according to the desired
reference.
The name(s) of the channel(s) used to construct the reference for
every channel of ch_type.
'average' to apply an average reference (default)
'REST' to use the Reference Electrode Standardization Technique
infinity reference [10].
A dictionary mapping names of data channels to (lists of) names of
reference channels. For example, {‘A1’: ‘A3’} would replace the
data in channel ‘A1’ with the difference between ‘A1’ and ‘A3’. To take
the average of multiple channels as reference, supply a list of channel
names as the dictionary value, e.g. {‘A1’: [‘A2’, ‘A3’]} would replace
channel A1 with A1-mean(A2,A3).
An empty list, in which case MNE will not attempt any re-referencing of
the data
If ref_channels='average' this argument specifies if the
average reference should be computed as a projection (True) or not
(False; default). If projection=True, the average reference is
added as a projection and is not applied to the data (it can be
applied afterwards with the apply_proj method). If
projection=False, the average reference is directly applied to
the data. If ref_channels is not 'average', projection
must be set to False (the default in this case).
The name of the channel type to apply the reference to.
Valid channel types are 'auto', 'eeg', 'ecog', 'seeg',
'dbs'. If 'auto', the first channel type of eeg, ecog, seeg or dbs
that is found (in that order) will be selected.
New in v0.19.
Changed in version 1.2: list-of-str is now supported with projection=True.
How to handle list-of-str ch_type. If False (default), one projector
is created per channel type. If True, one projector is created across
all channel types. This is only used when projection=True.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Data with EEG channels re-referenced. If ref_channels='average'
and projection=True a projection will be added instead of
directly re-referencing the data.
Convenience function for creating bipolar references.
Notes
Some common referencing schemes and the corresponding value for the
ref_channels parameter:
Average reference:
A new virtual reference electrode is created by averaging the current
EEG signal by setting ref_channels='average'. Bad EEG channels are
automatically excluded if they are properly set in info['bads'].
A single electrode:
Set ref_channels to a list containing the name of the channel that
will act as the new reference, for example ref_channels=['Cz'].
The mean of multiple electrodes:
A new virtual reference electrode is created by computing the average
of the current EEG signal recorded from two or more selected channels.
Set ref_channels to a list of channel names, indicating which
channels to use. For example, to apply an average mastoid reference,
when using the 10-20 naming scheme, set ref_channels=['M1','M2'].
REST
The given EEG electrodes are referenced to a point at infinity using the
lead fields in forward, which helps standardize the signals.
Different references for different channels
Set ref_channels to a dictionary mapping source channel names (str)
to the reference channel names (str or list of str). Unlike the other
approaches where the same reference is applied globally, you can set
different references for different channels with this method. For example,
to re-reference channel ‘A1’ to ‘A2’ and ‘B1’ to the average of ‘B2’ and
‘B3’, set ref_channels={'A1':'A2','B1':['B2','B3']}. Warnings are
issued when a mapping involves bad channels or channels of different types.
If a reference is requested that is not the average reference, this
function removes any pre-existing average reference projections.
During source localization, the EEG signal should have an average
reference.
In order to apply a reference, the data must be preloaded. This is not
necessary if ref_channels='average' and projection=True.
For an average or REST reference, bad EEG channels are automatically
excluded if they are properly set in info['bads'].
The new measurement date.
If datetime object, it must be timezone-aware and in UTC.
A tuple of (seconds, microseconds) or float (alias for
(meas_date,0)) can also be passed and a datetime
object will be automatically created. If None, will remove
the time reference.
A montage containing channel positions. If a string or
DigMontage is
specified, the existing channel information will be updated with the
channel positions from the montage. Valid strings are the names of the
built-in montages that ship with MNE-Python; you can list those via
mne.channels.get_builtin_montages().
If None (default), the channel positions will be removed from the
Info.
Whether to use a lookup table to match unrecognized channel location names
to their known aliases. If True, uses the mapping in
mne.io.constants.CHANNEL_LOC_ALIASES. If a dict is passed, it
will be used instead, and should map from non-standard channel names to
names in the specified montage. Default is False.
New in v0.23.
on_missing‘raise’ | ‘warn’ | ‘ignore’
Can be 'raise' (default) to raise an error, 'warn' to emit a
warning, or 'ignore' to ignore when channels have missing coordinates.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.
Only EEG/sEEG/ECoG/DBS/fNIRS channels can have their positions set using
a montage. Other channel types (e.g., MEG channels) should have
their positions defined properly using their data reading
functions.
Warning
Applying a montage will only set locations of channels that exist
at the time it is applied. This means when
re-referencing
make sure to apply the montage only after calling
mne.add_reference_channels()
The (absolute or relative) time shift in seconds. If relative
is True, positive tshift increases the time value associated with
each sample, while negative tshift decreases it.
If True, increase or decrease time values by tshift seconds.
Otherwise, shift the time values such that the time of the first
sample equals tshift.
Returns:
epochsMNE-object
The modified instance.
Notes
This method allows you to shift the time values associated with each
data sample by an arbitrary amount. It does not resample the signal
or change the data values in any way.
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all data channels. Note
that channels in info['bads']will be included if their names or
indices are explicitly provided.
When False (the default) all epochs are processed together and a single
Evoked object is returned. When True, epochs are first
grouped by event type (as specified using the event_id parameter) and a
list is returned containing a separate Evoked object for each
event type. The .comment attribute is set to the label of the event
type.
The standard error over epochs.
When by_event_type=True was specified, a list is returned containing a
separate Evoked object for each event type. The list has the
same order as the event types as specified in the event_id
dictionary.
Export data in tabular structure as a pandas DataFrame.
Channels are converted to columns in the DataFrame. By default,
additional columns “time”, “epoch” (epoch number), and “condition”
(epoch event description) are added, unless index is not None
(in which case the columns specified in index will be used to form
the DataFrame’s index instead).
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg','eeg']) will pick channels of those types, channel name strings (e.g.,
['MEG0111','MEG2623'] will pick the given channels. Can also be the
string values 'all' to pick all channels, or 'data' to pick
data channels. None (default) will pick all channels. Note that
channels in info['bads']will be included if their names or indices
are explicitly provided.
Kind of index to use for the DataFrame. If None, a sequential
integer index (pandas.RangeIndex) will be used. If 'time', a
pandas.Index or pandas.TimedeltaIndex will be used
(depending on the value of time_format). If a list of two or more string values, a pandas.MultiIndex will be created.
Valid string values are ‘time’, ‘epoch’, and ‘condition’.
Defaults to None.
Scaling factor applied to the channels picked. If None, defaults to
dict(eeg=1e6,mag=1e15,grad=1e13) — i.e., converts EEG to µV,
magnetometers to fT, and gradiometers to fT/cm.
If True, the DataFrame is returned in long format where each row is one
observation of the signal at a unique combination of time point, channel, epoch number, and condition.
For convenience, a ch_type column is added to facilitate subsetting the resulting DataFrame. Defaults to False.
Desired time format. If None, no conversion is applied, and time values
remain as float values in seconds. If 'ms', time values will be rounded
to the nearest millisecond and converted to integers. If 'timedelta',
time values will be converted to pandas.Timedelta values.
Default is None.
Control verbosity of the logging output. If None, use the default
verbosity level. See the logging documentation and
mne.verbose() for details. Should only be passed as a keyword
argument.