Notebooks/Day 1/2 - Epochs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7f32110-e046-4c35-94cd-dfc8aeda9c9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "\n",
    "import mne\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Epoching timeseries data in MNE - the `Epochs` class\n",
    "\n",
    "For many analyses, it is useful to divide timeseries data into discrete chunks of time, called [epochs](https://mne.tools/stable/documentation/glossary.html#term-epochs).\n",
    "\n",
    "Epochs can take the form of individuals trials (e.g. isolating data around a given stimulus or behaviour), or divide continuous resting-state data into discrete chunks.\n",
    "\n",
    "Epochs are stored in MNE as [`mne.Epochs`](https://mne.tools/stable/generated/mne.Epochs.html) objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa1dc34a",
   "metadata": {},
   "source": [
    "### Part 1 - Epoching data from events\n",
    "\n",
    "To explore how we can create epochs around events (e.g. stimulus presentation, behaviour), we will reload the example dataset and isolate the EEG data and stimulus channels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96f4425a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load sample data from disk\n",
    "raw = mne.io.read_raw_fif(\n",
    "    os.path.join(mne.datasets.sample.data_path(), \"MEG\", \"sample\", \"sample_audvis_raw.fif\")\n",
    ")\n",
    "\n",
    "# Select only EEG and stimulus channels\n",
    "raw.pick([\"eeg\", \"stim\"])\n",
    "raw.info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60f0dfc7",
   "metadata": {},
   "source": [
    "Stimulus channels contain information about e.g. when stimuli were presented to subjects, when subjects performed an action, etc...\n",
    "\n",
    "We can use the `plot()` method to visualise how stimulus data is stored in the `Raw` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "704fbe44",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot data of stimulus channels\n",
    "raw.copy().pick(\"stim\").plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5c6252f",
   "metadata": {},
   "source": [
    "The [`mne.find_events()`](https://mne.tools/stable/generated/mne.find_events.html) function can be used to convert this information into discrete timepoints based on changes in the signal.\n",
    "\n",
    "[Events](https://mne.tools/stable/documentation/glossary.html#term-events) are stored as an array of shape `(events, 3)`, where:\n",
    "- the first column is the timepoint of the event (in samples)\n",
    "- the second column is the previous type of the event \n",
    "- the third column is the new type of the event\n",
    "\n",
    "An event ID of `0` corresponds to the absence of an event, and event IDs > `0` are stimuli/responses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fd3018a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the events from a given stimulus channel\n",
    "events = mne.find_events(raw, stim_channel=\"STI 014\")\n",
    "\n",
    "# Print a subset of events\n",
    "events[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "731a5ada",
   "metadata": {},
   "source": [
    "Using these events, we can now create an `Epochs` object.\n",
    "\n",
    "If we already have a `Raw` object, this is simply a case of passing the `Raw` object and the events array to the `Epochs` class.\n",
    "\n",
    "Here, we create epochs for all events with an ID > `0`, taking the data from 1 second before to 1 second after each event using the `tmin` and `tmax` parameters (times are relative to the timings of events)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "575fd461",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Epoch timeseries data from event markers\n",
    "epochs = mne.Epochs(raw=raw, events=events, tmin=-1, tmax=1)\n",
    "epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c809ed",
   "metadata": {},
   "source": [
    "As you can see:\n",
    "-   this data has 320 events across all event types.\n",
    "-   we have selected data in the [-1, +1] second window around each event.\n",
    "-   each epoch was baseline-corrected using the time from the start of each epoch to the event itself (0 seconds)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b390df1",
   "metadata": {},
   "source": [
    "Similarly to `Raw` objects, we can visualise the data stored in `Epochs` objects using the [`plot()`](https://mne.tools/stable/generated/mne.Epochs.html#mne.Epochs.plot) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46a73297",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot first 3 epochs in the data\n",
    "epochs.plot(scalings=\"auto\", n_epochs=3);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29c36081",
   "metadata": {},
   "source": [
    "As for `Raw` objects, the data itself can be accessed using the [`get_data()`](https://mne.tools/stable/generated/mne.Epochs.html#mne.Epochs.get_data) method, which returns an array of shape `(epochs, channels, times)`.\n",
    "\n",
    "Having the epochs as the first dimension is convenient for iterating over the data of each epoch, e.g.\n",
    "```python\n",
    "    data = epochs.get_data()\n",
    "    for epoch_data in data:\n",
    "        ### Do something with the data of a single epoch...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c91eccbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get data as an array\n",
    "data = epochs.get_data(copy=False)\n",
    "print(f\"Data has shape: {data.shape} (epochs, channels, times)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5b64d1c",
   "metadata": {},
   "source": [
    "**Exercises - Creating epochs around events**\n",
    "\n",
    "**Exercise:** Create epochs around all events in the window [-2, +2] seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78def82c",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933227cb",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around all events in the window [-1, +3] seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8666842",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dfecefc",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around all events in the window [-0.5, +0.5] seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3fe6ce9",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f35f53e",
   "metadata": {},
   "source": [
    "Baseline-correction of epochs involves taking the mean of a given data period and subtracting this value from each data point of the whole epoch.\n",
    "\n",
    "The `baseline` parameter of `Epochs` is used to control which period is used for baseline correction.\n",
    "\n",
    "The default when creating an `Epochs` object in MNE is to take the period from the start of the epoch to the event itself as the baseline period, specified as `baseline=(None, 0)`.\n",
    "\n",
    "Like for `tmin` and `tmax`, the times in `baseline` are relative to the events.\t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd87de7d",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around all events in the window [-1, +1], but only use the window [-0.5, 0] seconds as a baseline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "442ede0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "131574f5",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around all events in the window [-1, +2], but only use the window [0, +2] seconds as a baseline.\n",
    "\n",
    "There are two ways you can specify this, so try to include them both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c61e8c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22251a6d",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around all events in the window [-1, +2], and use this whole period as a baseline.\n",
    "\n",
    "There are again two ways you can specify this, so try to include them both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b2f262e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b48e0647",
   "metadata": {},
   "source": [
    "Above, we have been creating epochs around all events, however we may wish to only create epochs around a single type of event.\n",
    "\n",
    "Epochs for only particular event types can be specified using the `event_id` parameter of `Epochs`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e465a10c",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around only the events with an ID of `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ce811db",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1b749f",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around only the events with an ID of `2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60bc6332",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac6f1ad7",
   "metadata": {},
   "source": [
    "**Exercise:** Create epochs around only the events with IDs of `1`, `2`, and `3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13794689",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c576703",
   "metadata": {},
   "source": [
    "As you can see, the `Epochs` object of MNE is a very convenient way to create epochs of a given duration, with a given baseline, around specific stimuli/behaviours.\n",
    "\n",
    "However, we can also create continuous epochs unrelated to any events, such as you would do for an analysis of resting-state data (i.e. no stimuli, no behaviour)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83fc2446",
   "metadata": {},
   "source": [
    "### Part 2 - Creating continuous epochs of data\n",
    "\n",
    "Continuous epochs can be created easily from `Raw` object using the [`mne.make_fixed_length_epochs()`](https://mne.tools/stable/generated/mne.make_fixed_length_epochs.html) function.\n",
    "\n",
    "This creates an `Epochs` object with epochs of a specified duration directly from a `Raw` object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbdca124",
   "metadata": {},
   "source": [
    "Here we create an `Epochs` object with 1-second-long epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a577294",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create continuous epochs\n",
    "epochs = mne.make_fixed_length_epochs(raw=raw, duration=1)\n",
    "epochs.plot(scalings=\"auto\", n_epochs=3)\n",
    "epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afbfb89",
   "metadata": {},
   "source": [
    "**Exercises - Creating continuous epochs (specifying the duration)**\n",
    "\n",
    "**Exercise:** Create an `Epochs` object with 2-second-long epochs and verify the length of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37a03ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8d62a1",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `Epochs` object with 4-second-long epochs and verify the length of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aea4ac2",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6f28fb",
   "metadata": {},
   "source": [
    "Continuous epochs do not need to contain data for unique windows of data.\n",
    "\n",
    "We can artificially increase the amount of data available by having overlapping epochs. By default, there is no overlap between epochs.\n",
    "\n",
    "Here, we create 1-second-long epochs that have an overlap of 0.5 seconds (50% overlap).\n",
    "\n",
    "How does the number of epochs compare to that when there was no overlap?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ed078cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create continuous epochs with overlap\n",
    "epochs = mne.make_fixed_length_epochs(raw=raw, duration=1, overlap=0.5)\n",
    "epochs.plot(scalings=\"auto\", n_epochs=3)\n",
    "epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a4fd0c6",
   "metadata": {},
   "source": [
    "**Exercises - Creating continuous epochs (specifying the overlap)**\n",
    "\n",
    "**Exercise:** Create 2-second-long epochs with 1 second overlap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f216e9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2345edb",
   "metadata": {},
   "source": [
    "**Exercise:** Create 4-second-long epochs with 25% overlap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da4a54a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4efc1790",
   "metadata": {},
   "source": [
    "You may have noticed that when creating `Epochs` in this way, we do not specify the baseline settings.\n",
    "\n",
    "Inspecting the `Epochs` shows that `baseline` is set to `\"off\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "613dee61",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create continuous epochs\n",
    "epochs = mne.make_fixed_length_epochs(raw=raw, duration=2)\n",
    "\n",
    "# Show information about the epochs\n",
    "epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b407218a",
   "metadata": {},
   "source": [
    "This is no problem, as we can use the [`apply_baseline()`](https://mne.tools/stable/generated/mne.Epochs.html#mne.Epochs.apply_baseline) method of the `Epochs` object to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f27d0f8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Baseline-correct the epochs\n",
    "epochs.apply_baseline(baseline=(None, None))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b95a1d",
   "metadata": {},
   "source": [
    "Above, we added a baseline based on the whole epoch duration.\n",
    "\n",
    "But what would happen if we set the baseline to the [-1, 0] second window?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "504d9761",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    epochs.apply_baseline(baseline=(-1, 0))\n",
    "except ValueError as error:\n",
    "    print(f\"ValueError: {error}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7879bfc0",
   "metadata": {},
   "source": [
    "We get an error!\n",
    "\n",
    "This is because `Epochs` created from `make_fixed_length_epochs()` always start at 0 seconds and end at the epoch's duration (in this case, 2 seconds)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b15ff849",
   "metadata": {},
   "source": [
    "**Exercises - Baseline-correcting `Epochs` object**\n",
    "\n",
    "**Exercise:** Apply a baseline to the first second of the `Epochs` object.\n",
    "\n",
    "There are two ways you can specify this, so try to include them both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "770e37de",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2cd80fb",
   "metadata": {},
   "source": [
    "**Exercise:** Apply a baseline to the last second of the `Epochs` object.\n",
    "\n",
    "Again, there are two ways you can specify this, so try to include them both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c385f1f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff11f537",
   "metadata": {},
   "source": [
    "As you can see, MNE has plenty of tools for creating epochs of data, either around event markers or as continuous segments of data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc897763",
   "metadata": {},
   "source": [
    "### Part 3 - Creating `Epochs` from arrays\n",
    "\n",
    "Just like for `Raw` objects, we can also create `Epochs` objects from data arrays. Specifically, we create [`mne.EpochsArray`](https://mne.tools/stable/generated/mne.EpochsArray.html) objects.\n",
    "\n",
    "Again, this requires that we provide some metadata so that MNE can keep track of what the data represents. This is also done as an [`Info`](https://mne.tools/stable/generated/mne.Info.html) object.\n",
    "\n",
    "Below, we randomly generate some data of 3 channels and 1,000 timepoints, then reshape this into 10 1-second-long epochs.\n",
    "\n",
    "Remember that MNE expects epoched data to have shape `(epochs, channels, times)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fc18a2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define parameters for generating data\n",
    "n_channels = 3\n",
    "n_epochs = 10\n",
    "n_times = 1000  # samples\n",
    "n_times_per_epoch = n_times // n_epochs  # samples\n",
    "np.random.seed(44)  # set seed for consistency\n",
    "\n",
    "# Generate the data\n",
    "data = np.random.randn(n_channels, n_times)\n",
    "data = np.reshape(data, (n_channels, n_epochs, n_times_per_epoch))\n",
    "data = data.transpose((1, 0, 2))\n",
    "print(f\"Data has shape: {data.shape} (epochs, channels, times)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a7ad916",
   "metadata": {},
   "source": [
    "**Exercises - Creating `Epochs` from arrays**\n",
    "\n",
    "**Exercise:** Create an `Info` object for this data using the [`mne.create_info()`](https://mne.tools/stable/generated/mne.create_info.html) function.\n",
    "\n",
    "Recall that we need to specify:\n",
    "- the names of the channels - `ch_names` parameter\n",
    "- the types of the channels - `ch_types` parameter\n",
    "- the sampling frequency - `sfreq` parameter\n",
    "\n",
    "Create the `Info` object for the 3 channels with: names of your choice; of type EEG; and a sampling frequency of 100 Hz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22f74b1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "451bed6a",
   "metadata": {},
   "source": [
    "We can then pass the data array and the `Info` object to the `EpochsArray` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3adf6e6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store the data and information in an EpochsArray object\n",
    "epochs = mne.EpochsArray(data=data, info=info)\n",
    "\n",
    "# Show what is stored in the EpochsArray object\n",
    "epochs.plot(scalings=\"auto\", n_epochs=3)\n",
    "epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c091ad0f",
   "metadata": {},
   "source": [
    "Just like an `Epochs` object, we can specify the baseline correction to apply (default is no baseline correction)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aa75aec",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `EpochsArray` object from the data, with baseline correction for the whole epoch duration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48b61bd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3f1dfc",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `EpochsArray` object from the data, with baseline correction for the first half of each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42dcc9e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70868db1",
   "metadata": {},
   "source": [
    "Like when we created continuous epochs, the first sample of each epoch is considered to be 0 seconds.\n",
    "\n",
    "We can change this when creating the `EpochsArray` object, similarly to how we specified `tmin` when creating `Epochs` objects from `Raw` objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d19db0f",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `EpochsArray` object from the data with times in the window [-1, 0] seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8091413",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59115177",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `EpochsArray` object from the data with times in the window [-0.5, +0.5] seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3332c43b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a67f096f",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `EpochsArray` object from the data with times in the window [-0.5, +0.5] seconds, and baseline correct it for the first half of the epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45bb4c77",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f988bb9a",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Alongside `Raw` objects, `Epochs` objects are some of the most heavily used parts of MNE, storing segments of data around experimentally-relevent events, or fixed-length chunks of continuous data.\n",
    "\n",
    "They can be created from `Raw` objects (`Raw` -> `Epochs`), or from arrays (`array` -> `EpochsArray`).\n",
    "\n",
    "In the upcoming notebooks, we will continue to build on this foundation for working with epochs as we explore different forms of data analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aefa91c",
   "metadata": {},
   "source": [
    "## Additional resources\n",
    "\n",
    "MNE tutorial on `Epochs` objects: https://mne.tools/stable/auto_tutorials/epochs/10_epochs_overview.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}