<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 Basic MEG and EEG data processing
MNE-Python reimplements most of MNE-C's (the original MNE command line utils)
functionality and offers transparent scripting.
On top of that it extends MNE-C's functionality considerably
(customize events, compute contrasts, group statistics, time-frequency
analysis, EEG-sensor space analyses, etc.) It uses the same files as standard
MNE unix commands
Step1:  If you'd like to turn information status messages off
Step2:  But it's generally a good idea to leave them on
Step3:  You can set the default level by setting the environment variable
"MNE_LOGGING_LEVEL", or by having mne-python write preferences to a file
Step4:  Note that the location of the mne-python preferences file (for easier manual
editing) can be found using
Step5:  By default logging messages print to the console, but look at
mne.set_log_file() to save output to a file.
Access raw data
^^^^^^^^^^^^^^^
Step6:  <div class="alert alert-info"><h4>Note</h4><p>The MNE sample dataset should be downloaded automatically but be
          patient (approx. 2GB)</p></div>
Read data from file
Step7:  Look at the channels in raw
Step8:  Read and plot a segment of raw data
Step9:  Save a segment of 150s of raw data (MEG only)
Step10:  Define and read epochs
^^^^^^^^^^^^^^^^^^^^^^
First extract events
Step11:  Note that, by default, we use stim_channel='STI 014'. If you have a different
system (e.g., a newer system that uses channel 'STI101' by default), you can
use the following to set the default stim channel to use for finding events
Step12:  Events are stored as 2D numpy array where the first column is the time
instant and the last one is the event number. It is therefore easy to
manipulate.
Define epochs parameters
Step13:  Exclude some channels (original bads + 2 more)
Step14:  The variable raw.info['bads'] is just a python list.
Pick the good channels, excluding raw.info['bads']
Step15:  Alternatively one can restrict to magnetometers or gradiometers with
Step16:  Define the baseline period
Step17:  Define peak-to-peak rejection parameters for gradiometers, magnetometers
and EOG
Step18:  Read epochs
Step19:  Get single epochs for one condition
Step20:  epochs_data is a 3D array of dimension (55 epochs, 365 channels, 106 time
instants).
Scipy supports read and write of matlab files. You can save your single
trials with
Step21:  or if you want to keep all the information about the data you can save your
epochs in a fif file
Step22:  and read them later with
Step23:  Compute evoked responses for auditory responses by averaging and plot it
Step24:  .. topic
Step25:  It is also possible to read evoked data stored in a fif file
Step26:  Or another one stored in the same file
Step27:  Two evoked objects can be contrasted using 
Step28:  To do a weighted sum based on the number of averages, which will give
you what you would have gotten from pooling all trials together in
Step29:  Instead of dealing with mismatches in the number of averages, we can use
trial-count equalization before computing a contrast, which can have some
benefits in inverse imaging (note that here weights='nave' will
give the same result as weights='equal')
Step30:  Time-Frequency
Step31:  Compute induced power and phase-locking values and plot gradiometers
Step32:  Inverse modeling
Step33:  Read the inverse operator
Step34:  Define the inverse parameters
Step35:  Compute the inverse solution
Step36:  Save the source time courses to disk
Step37:  Now, let's compute dSPM on a raw file within a label
Step38:  Compute inverse solution during the first 15s
Step39:  Save result in stc files
Step40:  What else can you do?
^^^^^^^^^^^^^^^^^^^^^
- detect heart beat QRS component
- detect eye blinks and EOG artifacts
- compute SSP projections to remove ECG or EOG artifacts
- compute Independent Component Analysis (ICA) to remove artifacts or
  select latent sources
- estimate noise covariance matrix from Raw and Epochs
- visualize cross-trial response dynamics using epochs images
- compute forward solutions
- estimate power in the source space
- estimate connectivity in sensor and source space
- morph stc from one brain to another for group studies
- compute mass univariate statistics base on custom contrasts
- visualize source estimates
- export raw, epochs, and evoked data to other python data analysis
  libraries e.g. pandas
- and many more things ...
Want to know more ?
^^^^^^^^^^^^^^^^^^^
Browse the examples gallery &lt;auto_examples/index.html&gt;_.
<ASSISTANT_TASK:>
Python Code:
import mne
Explanation: Basic MEG and EEG data processing
MNE-Python reimplements most of MNE-C's (the original MNE command line utils)
functionality and offers transparent scripting.
On top of that it extends MNE-C's functionality considerably
(customize events, compute contrasts, group statistics, time-frequency
analysis, EEG-sensor space analyses, etc.) It uses the same files as standard
MNE unix commands: no need to convert your files to a new system or database.
What you can do with MNE Python
Raw data visualization to visualize recordings, can also use
     mne_browse_raw for extended functionality (see ch_browse)
Epoching: Define epochs, baseline correction, handle conditions etc.
Averaging to get Evoked data
Compute SSP projectors to remove ECG and EOG artifacts
Compute ICA to remove artifacts or select latent sources.
Maxwell filtering to remove environmental noise.
Boundary Element Modeling: single and three-layer BEM model
     creation and solution computation.
Forward modeling: BEM computation and mesh creation
     (see ch_forward)
Linear inverse solvers (dSPM, sLORETA, MNE, LCMV, DICS)
Sparse inverse solvers (L1/L2 mixed norm MxNE, Gamma Map,
     Time-Frequency MxNE)
Connectivity estimation in sensor and source space
Visualization of sensor and source space data
Time-frequency analysis with Morlet wavelets (induced power,
     intertrial coherence, phase lock value) also in the source space
Spectrum estimation using multi-taper method
Mixed Source Models combining cortical and subcortical structures
Dipole Fitting
Decoding multivariate pattern analyis of M/EEG topographies
Compute contrasts between conditions, between sensors, across
     subjects etc.
Non-parametric statistics in time, space and frequency
     (including cluster-level)
Scripting (batch and parallel computing)
What you're not supposed to do with MNE Python
- **Brain and head surface segmentation** for use with BEM
  models -- use Freesurfer.
- **Raw movement compensation** -- use Elekta Maxfilter™
<div class="alert alert-info"><h4>Note</h4><p>This package is based on the FIF file format from Neuromag. It
          can read and convert CTF, BTI/4D, KIT and various EEG formats to
          FIF.</p></div>
Installation of the required materials
See getting_started with Python.
<div class="alert alert-info"><h4>Note</h4><p>The expected location for the MNE-sample data is
    my-path-to/mne-python/examples. If you downloaded data and an example asks
    you whether to download it again, make sure
    the data reside in the examples directory and you run the script from its
    current directory.
    From IPython e.g. say::
        cd examples/preprocessing
    %run plot_find_ecg_artifacts.py</p></div>
From raw data to evoked data
Now, launch ipython_ (Advanced Python shell) using the QT backend, which
is best supported across systems::
$ ipython --matplotlib=qt
First, load the mne package:
<div class="alert alert-info"><h4>Note</h4><p>In IPython, you can press **shift-enter** with a given cell
          selected to execute it and advance to the next cell:</p></div>
End of explanation
mne.set_log_level('WARNING')
Explanation: If you'd like to turn information status messages off:
End of explanation
mne.set_log_level('INFO')
Explanation: But it's generally a good idea to leave them on:
End of explanation
mne.set_config('MNE_LOGGING_LEVEL', 'WARNING', set_env=True)
Explanation: You can set the default level by setting the environment variable
"MNE_LOGGING_LEVEL", or by having mne-python write preferences to a file:
End of explanation
mne.get_config_path()
Explanation: Note that the location of the mne-python preferences file (for easier manual
editing) can be found using:
End of explanation
from mne.datasets import sample  # noqa
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
print(raw_fname)
Explanation: By default logging messages print to the console, but look at
mne.set_log_file() to save output to a file.
Access raw data
^^^^^^^^^^^^^^^
End of explanation
raw = mne.io.read_raw_fif(raw_fname, add_eeg_ref=False)
print(raw)
print(raw.info)
Explanation: <div class="alert alert-info"><h4>Note</h4><p>The MNE sample dataset should be downloaded automatically but be
          patient (approx. 2GB)</p></div>
Read data from file:
End of explanation
print(raw.ch_names)
Explanation: Look at the channels in raw:
End of explanation
start, stop = raw.time_as_index([100, 115])  # 100 s to 115 s data segment
data, times = raw[:, start:stop]
print(data.shape)
print(times.shape)
data, times = raw[2:20:3, start:stop]  # access underlying data
raw.plot()
Explanation: Read and plot a segment of raw data
End of explanation
picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=True,
                       exclude='bads')
raw.save('sample_audvis_meg_raw.fif', tmin=0, tmax=150, picks=picks,
         overwrite=True)
Explanation: Save a segment of 150s of raw data (MEG only):
End of explanation
events = mne.find_events(raw, stim_channel='STI 014')
print(events[:5])
Explanation: Define and read epochs
^^^^^^^^^^^^^^^^^^^^^^
First extract events:
End of explanation
mne.set_config('MNE_STIM_CHANNEL', 'STI101', set_env=True)
Explanation: Note that, by default, we use stim_channel='STI 014'. If you have a different
system (e.g., a newer system that uses channel 'STI101' by default), you can
use the following to set the default stim channel to use for finding events:
End of explanation
event_id = dict(aud_l=1, aud_r=2)  # event trigger and conditions
tmin = -0.2  # start of each epoch (200ms before the trigger)
tmax = 0.5  # end of each epoch (500ms after the trigger)
Explanation: Events are stored as 2D numpy array where the first column is the time
instant and the last one is the event number. It is therefore easy to
manipulate.
Define epochs parameters:
End of explanation
raw.info['bads'] += ['MEG 2443', 'EEG 053']
Explanation: Exclude some channels (original bads + 2 more):
End of explanation
picks = mne.pick_types(raw.info, meg=True, eeg=True, eog=True, stim=False,
                       exclude='bads')
Explanation: The variable raw.info['bads'] is just a python list.
Pick the good channels, excluding raw.info['bads']:
End of explanation
mag_picks = mne.pick_types(raw.info, meg='mag', eog=True, exclude='bads')
grad_picks = mne.pick_types(raw.info, meg='grad', eog=True, exclude='bads')
Explanation: Alternatively one can restrict to magnetometers or gradiometers with:
End of explanation
baseline = (None, 0)  # means from the first instant to t = 0
Explanation: Define the baseline period:
End of explanation
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
Explanation: Define peak-to-peak rejection parameters for gradiometers, magnetometers
and EOG:
End of explanation
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
                    baseline=baseline, preload=False, reject=reject,
                    add_eeg_ref=False)
print(epochs)
Explanation: Read epochs:
End of explanation
epochs_data = epochs['aud_l'].get_data()
print(epochs_data.shape)
Explanation: Get single epochs for one condition:
End of explanation
from scipy import io  # noqa
io.savemat('epochs_data.mat', dict(epochs_data=epochs_data), oned_as='row')
Explanation: epochs_data is a 3D array of dimension (55 epochs, 365 channels, 106 time
instants).
Scipy supports read and write of matlab files. You can save your single
trials with:
End of explanation
epochs.save('sample-epo.fif')
Explanation: or if you want to keep all the information about the data you can save your
epochs in a fif file:
End of explanation
saved_epochs = mne.read_epochs('sample-epo.fif')
Explanation: and read them later with:
End of explanation
evoked = epochs['aud_l'].average()
print(evoked)
evoked.plot()
Explanation: Compute evoked responses for auditory responses by averaging and plot it:
End of explanation
max_in_each_epoch = [e.max() for e in epochs['aud_l']]  # doctest:+ELLIPSIS
print(max_in_each_epoch[:4])  # doctest:+ELLIPSIS
Explanation: .. topic:: Exercise
Extract the max value of each epoch
End of explanation
evoked_fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
evoked1 = mne.read_evokeds(
    evoked_fname, condition='Left Auditory', baseline=(None, 0), proj=True)
Explanation: It is also possible to read evoked data stored in a fif file:
End of explanation
evoked2 = mne.read_evokeds(
    evoked_fname, condition='Right Auditory', baseline=(None, 0), proj=True)
Explanation: Or another one stored in the same file:
End of explanation
contrast = mne.combine_evoked([evoked1, evoked2], weights=[0.5, -0.5])
contrast = mne.combine_evoked([evoked1, -evoked2], weights='equal')
print(contrast)
Explanation: Two evoked objects can be contrasted using :func:mne.combine_evoked.
This function can use weights='equal', which provides a simple
element-by-element subtraction (and sets the
:attr:mne.Evoked.nave attribute properly based on the underlying number
of trials) using either equivalent call:
End of explanation
average = mne.combine_evoked([evoked1, evoked2], weights='nave')
print(contrast)
Explanation: To do a weighted sum based on the number of averages, which will give
you what you would have gotten from pooling all trials together in
:class:mne.Epochs before creating the :class:mne.Evoked instance,
you can use weights='nave':
End of explanation
epochs_eq = epochs.copy().equalize_event_counts(['aud_l', 'aud_r'])[0]
evoked1, evoked2 = epochs_eq['aud_l'].average(), epochs_eq['aud_r'].average()
print(evoked1)
print(evoked2)
contrast = mne.combine_evoked([evoked1, -evoked2], weights='equal')
print(contrast)
Explanation: Instead of dealing with mismatches in the number of averages, we can use
trial-count equalization before computing a contrast, which can have some
benefits in inverse imaging (note that here weights='nave' will
give the same result as weights='equal'):
End of explanation
import numpy as np  # noqa
n_cycles = 2  # number of cycles in Morlet wavelet
freqs = np.arange(7, 30, 3)  # frequencies of interest
Explanation: Time-Frequency: Induced power and inter trial coherence
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Define parameters:
End of explanation
from mne.time_frequency import tfr_morlet  # noqa
power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles,
                        return_itc=True, decim=3, n_jobs=1)
power.plot([power.ch_names.index('MEG 1332')])
Explanation: Compute induced power and phase-locking values and plot gradiometers:
End of explanation
from mne.minimum_norm import apply_inverse, read_inverse_operator  # noqa
Explanation: Inverse modeling: MNE and dSPM on evoked and raw data
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Import the required functions:
End of explanation
fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
inverse_operator = read_inverse_operator(fname_inv)
Explanation: Read the inverse operator:
End of explanation
snr = 3.0
lambda2 = 1.0 / snr ** 2
method = "dSPM"
Explanation: Define the inverse parameters:
End of explanation
stc = apply_inverse(evoked, inverse_operator, lambda2, method)
Explanation: Compute the inverse solution:
End of explanation
stc.save('mne_dSPM_inverse')
Explanation: Save the source time courses to disk:
End of explanation
fname_label = data_path + '/MEG/sample/labels/Aud-lh.label'
label = mne.read_label(fname_label)
Explanation: Now, let's compute dSPM on a raw file within a label:
End of explanation
from mne.minimum_norm import apply_inverse_raw  # noqa
start, stop = raw.time_as_index([0, 15])  # read the first 15s of data
stc = apply_inverse_raw(raw, inverse_operator, lambda2, method, label,
                        start, stop)
Explanation: Compute inverse solution during the first 15s:
End of explanation
stc.save('mne_dSPM_raw_inverse_Aud')
Explanation: Save result in stc files:
End of explanation
print("Done!")
Explanation: What else can you do?
^^^^^^^^^^^^^^^^^^^^^
- detect heart beat QRS component
- detect eye blinks and EOG artifacts
- compute SSP projections to remove ECG or EOG artifacts
- compute Independent Component Analysis (ICA) to remove artifacts or
  select latent sources
- estimate noise covariance matrix from Raw and Epochs
- visualize cross-trial response dynamics using epochs images
- compute forward solutions
- estimate power in the source space
- estimate connectivity in sensor and source space
- morph stc from one brain to another for group studies
- compute mass univariate statistics base on custom contrasts
- visualize source estimates
- export raw, epochs, and evoked data to other python data analysis
  libraries e.g. pandas
- and many more things ...
Want to know more ?
^^^^^^^^^^^^^^^^^^^
Browse the examples gallery &lt;auto_examples/index.html&gt;_.
End of explanation
<END_TASK>