Notebooks/Day 2/3 - ICA.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "\n",
    "import mne\n",
    "import numpy as np\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data decomposition and artefact removal with independent component analysis (ICA) - the `ICA` class\n",
    "\n",
    "ICA is a common approach for breaking a set of signals down into the underlying components, with a mixing matrix explaining how the components are combined to form the observed signals.\n",
    "\n",
    "In practice, this is often used to isolate artefact sources from electrophysiological recordings (cardiac activity, eye movements, stimulation artefacts, etc...) and then reconstruct the signals with these unwanted sources removed.\n",
    "\n",
    "MNE has a comprehensive toolkit for performing ICA, in particular the [`mne.preprocessing.ICA`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html) class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1 - Data decomposition with ICA\n",
    "\n",
    "To explore ICA in MNE, we will generate a set of source signals which we then mix together to form the sensor signals.\n",
    "\n",
    "The source signals are:\n",
    "- A 10 Hz sine wave\n",
    "- An 8 Hz sawtooth wave\n",
    "- Some randomly generated noise\n",
    "\n",
    "We create a matrix of random numbers that acts as our mixing matrix, determining how the sources project into the sensor signals.\n",
    "\n",
    "The mixing matrix has shape `(sensors, sources)`. The (3 x 3) matrix we use here means that we will project our 3 sources into 3 sensor signals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulation settings\n",
    "duration = 10  # seconds\n",
    "sfreq = 200  # sampling rate (Hz)\n",
    "np.random.seed(44)  # for reproducibility\n",
    "\n",
    "# Timepoints of the simulated data\n",
    "times = np.linspace(start=0, stop=duration, num=sfreq * duration, endpoint=False)\n",
    "\n",
    "# Generate source signals\n",
    "sources = np.array(\n",
    "    [\n",
    "        np.sin(2 * np.pi * times * 10),  # 10 Hz sine wave\n",
    "        sp.signal.sawtooth(2 * np.pi * times * 8),  # 8 Hz sawtooth wave\n",
    "        np.random.normal(0, 1, times.shape),  # Noise with normal distribution\n",
    "    ]\n",
    ")\n",
    "source_names = [\"sine\", \"sawtooth\", \"noise\"]\n",
    "\n",
    "# Generate mixing matrix of sources to sensors\n",
    "mixing_matrix = np.random.rand(3, 3)\n",
    "\n",
    "# Combine sources into sensor signals\n",
    "sensors = mixing_matrix @ sources  # @ is matrix multiplication in Python\n",
    "sensor_names = [\"chan_1\", \"chan_2\", \"chan_3\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercises - Data decomposition with ICA**\n",
    "\n",
    "**Exercise:** Create an [`Info`](https://mne.tools/stable/generated/mne.Info.html) object for the source signals, specifying `source_names` as the channel names, the channel types as EEG, and using the sampling frequency we specified above.\n",
    "\n",
    "Afterwards, use the `sources` array and `Info` object to create a [`RawArray`](https://mne.tools/stable/generated/mne.io.RawArray.html) object for the source signals, called `raw_sources`.\n",
    "\n",
    "*Hint:* use the [`create_info()`](https://mne.tools/stable/generated/mne.create_info.html) function to create the `Info` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `Info` object for the sensor signals, specifying `sensor_names` as the channel names, the channel types as EEG, and using the sampling frequency we specified above.\n",
    "\n",
    "Afterwards, use the `sensors` array and `Info` object to create a `RawArray` object for the sensor signals, called `raw_sensors`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we plot the sources, we can clearly see the individual sine wave, sawtooth, and noise channels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The object containing the source data should be called `raw_sources`\n",
    "raw_sources.plot(scalings=\"auto\", title=\"Source signals\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast, thanks to the mixing matrix, no one sensor signal resembles any one of the source signals.\n",
    "\n",
    "Instead, the signals are a mix of all 3 sources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The object containing the sensor data should be called `raw_sensors`\n",
    "raw_sensors.plot(scalings=\"auto\", title=\"Sensor signals\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now consider that the sine and sawtooth signals are our signals of interest, and the random noise is some activity we are not interested in (i.e. noise!) and want to remove.\n",
    "\n",
    "This is a perfect use-case for ICA!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Performing ICA\n",
    "\n",
    "To perform ICA in MNE, we start by instantiating an [`ICA`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html) object.\n",
    "\n",
    "Here, we set the `random_state` parameter for reproducibility, as ICA fitting is not deterministic (i.e. there can be sign flips, components returned in different orders)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate ICA object\n",
    "ica = mne.preprocessing.ICA(random_state=0)\n",
    "ica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, without specifying anything else, MNE defaults to using the FastICA algorithm (`Method` tab), with a set of default fitting parameters (`Fit parameters` tab).\n",
    "\n",
    "The algorithm to use is specified with the `method` parameter, and the fitting parameters with the `fit_params` parameter.\n",
    "\n",
    "You may also notice that we did not supply any data when instantiating the `ICA` object, and that the `Fit` tab is set to `no` (i.e. not fitted to data).\n",
    "\n",
    "Data is provided to the `ICA` object when we call the [`fit()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.fit) method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When calling `fit()`:\n",
    "1. The data is [whitened](https://mne.tools/stable/documentation/glossary.html#term-whitening).\n",
    "2. The ICA algorithm is run to generate an unmixing matrix, with which we can separate the sources in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit ICA to the data\n",
    "ica.fit(inst=raw_sensors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now see that the `Fit` tab has changed to show that the ICA object has been fit to the data, and that we have 3 different ICA components available.\n",
    "\n",
    "We can inspect the extracted ICA sources using the [`plot_sources()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.plot_sources) method.\n",
    "\n",
    "Comparing these extracted sources to the original sources, we can clearly see that ICA has successfully separated the sine, sawtooth, and noise signals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot extracted sources\n",
    "ica.plot_sources(inst=raw_sensors, title=\"ICA sources\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are able to extract these sources from the sensor signals thanks to the unmixing matrix, which is applied to the data provided to the `plot_sources()` method.\n",
    "\n",
    "The unmixing matrix can be accessed under the `unmixing_matrix_` attribute (and inverse mixing matrix located under the `mixing_matrix_` attribute)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise unmixing matrix\n",
    "ica.unmixing_matrix_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Applying PCA for ICA\n",
    "\n",
    "Before we explore how to remove the noise source, we will explore the object instantiation and fitting options in more detail.\n",
    "\n",
    "An important implementation note for ICA in MNE is that when `fit()` is called, principal component analysis (PCA) is performed prior to running the ICA algorithm.\n",
    "\n",
    "PCA is a well-established algorithm for dimensionality reduction, whereby correlated signals are grouped together into components that are ordered according to how much they explain the variance in the data.\n",
    "\n",
    "You can then take only the first `n` principal components that contain a desired amount of variance (information) in the data, representing the data in a lower-dimensional space.\n",
    "\n",
    "If you need a refresher on PCA, check out this short introductory video: https://www.youtube.com/watch?v=FD4DeN81ODY\n",
    "\n",
    "The benefits of performing PCA prior to ICA include:\n",
    "- Reduced computational time for the ICA algorithm.\n",
    "- Easier interpretability of the resulting extracted ICA sources."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When instantiating the `ICA` object, MNE gives you the option to specify the degree of dimensionality reduction prior to performing ICA, using the `n_components` parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using PCA with a fixed number of components\n",
    "\n",
    "**Exercises - Applying PCA for ICA**\n",
    "\n",
    "**Exercise:** Instantiate an `ICA` object, specifying that 3 PCA components should be used for ICA.\n",
    "\n",
    "Fit this to the sensor signals (as above), and plot the extracted sources.\n",
    "\n",
    "How do the extracted sources compare to those where no PCA components were specified?\n",
    "\n",
    "*Hint:* Set `random_state=0` for reproducibility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see that the extracted sources are identical.\n",
    "\n",
    "This is because the default behaviour of `n_components=None` means that those PCA components which explain 99.9999% of the variance in the data will be used, which will almost always correspond to the number of sensors in the data (an exception being when you are working with rank-deficient data).\n",
    "\n",
    "Therefore, not specifying `n_components` is equivalent to specifying `n_components=3` in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Perform the same procedure again, but this time specify that 2 PCA components should be used for ICA.\n",
    "\n",
    "What do you see when you plot the extracted sources?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using PCA with a proportional number of components\n",
    "\n",
    "In addition to specifying a particular number of PCA components to use, `n_components` also accepts floats in the range `(0, 1)`.\n",
    "\n",
    "Providing a float value means that the number of PCA components used will be the minimum number required to explain this proportion of variance.\n",
    "\n",
    "E.g. `n_components=0.9` means that the number of PCA components used will be the minimum number required to explain 90% of the variance in the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Perform the same procedure again, but this time specify that 95% of the variance should be explained by the PCA components used for ICA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, only 2 PCA components were passed to the ICA algorithm, meaning the first 2 PCA components explain at least 95% of the variance in the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how much variance each PCA component explains, we can use the `explained_variance_ratio_` attribute.\n",
    "\n",
    "Dividing by the sum of the variances normalises these values to the range `[0, 1]`.\n",
    "\n",
    "Here, the first 2 PCA components explain 97% of the variance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute variance explained by PCA components\n",
    "explained_variance = ica.pca_explained_variance_ / np.sum(ica.pca_explained_variance_)\n",
    "\n",
    "print(f\"Variance explained by PCA components: {explained_variance}\")\n",
    "print(f\"Variance explained by first 2 PCA components: {np.sum(explained_variance[:2]) * 100:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Excluding ICA components\n",
    "\n",
    "Now we will look at how to exclude a given ICA component from the data.\n",
    "\n",
    "We can remove ICA components to \"clean\" the data using the [`apply()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.apply) method.\n",
    "\n",
    "Below, we specify the first component (i.e. the random noise source) to be removed from the data, by setting `exclude=[0]`.\n",
    "\n",
    "Note that we use a copy of the sensor signals, as the `apply()` method operates in-place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Re-instantiate the ICA object, using all PCA components\n",
    "ica = mne.preprocessing.ICA(random_state=0)\n",
    "\n",
    "# Fit the ICA to the sensor signals\n",
    "ica.fit(inst=raw_sensors)\n",
    "\n",
    "# Remove the first ICA component (the random noise) from the data\n",
    "raw_cleaned = ica.apply(inst=raw_sensors.copy(), exclude=[0])\n",
    "\n",
    "# Plot the cleaned data\n",
    "raw_cleaned.plot(scalings=\"auto\", title=\"Cleaned sensor signals (removed noise)\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the remaining activity in the 3 sensor signals is a combination of our sine and sawtooth waves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercises - Choosing which sources to retain for data reconstruction**\n",
    "\n",
    "**Exercise:** Use ICA to remove the sine wave source from the sensor signals with the `exclude` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use ICA to remove the sawtooth wave source from the sensor signals with the `exclude` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use ICA to remove both the noise and sawtooth wave sources from the sensor signals with the `exclude` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, the `apply()` function also has an `include` parameter which operates in the opposite way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use ICA to keep only the random noise source in the sensor signals with the `include` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use ICA to keep both the sine and sawtooth wave sources in the sensor signals with the `include` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CODE GOES HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, it is very easy in MNE to apply ICA to data and remove particular sources of unwanted activity.\n",
    "\n",
    "Now, you will see how this applies for a more typical use-case with the MNE sample dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2 - Artefact rejection with ICA\n",
    "\n",
    "Using the MNE sample dataset, we will see how ICA can be used to remove cardiac and ocular artefacts from MEG & EEG data.\n",
    "\n",
    "Like for the previous notebook, we highlight some channels where this activity is particularly strong, with the MEG channels showing strong cardiac activity, and the EEG channels showing strong ocular activity (see e.g. https://labeling.ucsd.edu/tutorial/labels)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the sample data\n",
    "raw = mne.io.read_raw_fif(\n",
    "    os.path.join(mne.datasets.sample.data_path(), \"MEG\", \"sample\", \"sample_audvis_raw.fif\")\n",
    ")\n",
    "raw.crop(tmax=60)\n",
    "raw.load_data()\n",
    "raw.del_proj()  # delete existing PCA projections\n",
    "\n",
    "# Highpass filter at 1 Hz for better ICA performance\n",
    "raw.filter(l_freq=1, h_freq=None)\n",
    "\n",
    "# Pick some channels with strong artefacts and plot them\n",
    "artefact_picks = [152, 155, 158, 170, 315, 316, 317, 318]\n",
    "raw.plot(order=artefact_picks, scalings=\"auto\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Manual exclusion of artefacts\n",
    "\n",
    "Now we perform ICA on the data, specifying that the first 10 PCA component should be passed to the ICA algorithm.\n",
    "\n",
    "Plotting the extracted ICA sources, we see that the first source reflects ocular activity, and the second source reflects cardiac activity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit ICA to the data\n",
    "ica = mne.preprocessing.ICA(n_components=10, random_state=0)\n",
    "ica.fit(inst=raw)\n",
    "ica.plot_sources(inst=raw, title=\"ICA sources (first 10 PCA components)\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the [`plot_overlay()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.plot_overlay) method, we can see show excluding the ocular artefact source (the first ICA component) would affect the EEG data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise effects of ocular artefact on EEG data\n",
    "ica.plot_overlay(inst=raw, exclude=[0], picks=\"eeg\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see how excluding the cardiac artefact source (the second ICA component) would affect the MEG data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise effects of cardiac artefact on MEG data\n",
    "ica.plot_overlay(inst=raw, exclude=[1], picks=\"mag\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After this, it is simply a case of excluding the first 2 ICA components to clean the data of cardiac and ocular artefacts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove artefact sources from the data\n",
    "raw_cleaned = ica.apply(inst=raw.copy(), exclude=[0, 1])\n",
    "raw_cleaned.plot(order=artefact_picks, scalings=\"auto\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Automatic exclusion of artefacts\n",
    "\n",
    "Although manually selecting the components is quite simple, when dealing with a large number of recordings, this can be a time-consuming process.\n",
    "\n",
    "Thankfully, the `ICA` class has the [`find_bads_eog()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.find_bads_eog) and [`find_bads_ecg()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.find_bads_ecg) methods, which automatically detect the ICA components corresponding to ocular and cardiac artefacts, respectively.\n",
    "\n",
    "**N.B.** There are also the [`find_bads_muscle()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.find_bads_muscle) and [`find_bads_ref()`](https://mne.tools/stable/generated/mne.preprocessing.ICA.html#mne.preprocessing.ICA.find_bads_ref) methods for automatically detecting muscle and MEG reference artefacts, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `find_bads_eog()`, we can see that the first ICA component is detected as an ocular artefact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Automatically identify ocular artefact sources\n",
    "eog_bads, _ = ica.find_bads_eog(inst=raw, threshold=1)\n",
    "print(f\"Ocular artefact ICA component(s): {eog_bads}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, using `find_bads_ecg()`, we can see that the second ICA component is detected as a cardiac artefact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Automatically identify cardiac artefact sources\n",
    "ecg_bads, _ = ica.find_bads_ecg(inst=raw, threshold=0.5)\n",
    "print(f\"Cardiac artefact ICA component(s): {ecg_bads}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then pass the ICA components that were automatically identified to `apply()` to achieve the same result as a manual selection of the artefact components."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove artefact sources from the data\n",
    "raw_cleaned = ica.apply(inst=raw.copy(), exclude=[*eog_bads, *ecg_bads])\n",
    "raw_cleaned.plot(order=artefact_picks, scalings=\"auto\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "ICA is a common approach for artefact rejection with electrophysiological data. MNE's `ICA` class provides a comprehensive set of tools for:\n",
    "- Isolating unwanted sources of activity.\n",
    "- Visualising the effects of removing particular sources.\n",
    "- Visualising the spatial topographies of the extracted sources.\n",
    "- Removing (manually or automatically) artefact activity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional resources\n",
    "\n",
    "MNE tutorial on ICA for artefact correction: https://mne.tools/stable/auto_tutorials/preprocessing/40_artifact_correction_ica.html\n",
    "\n",
    "arXiv paper discussing the maths behind ICA: https://arxiv.org/pdf/1404.2986.pdf"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mne_course",
   "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": 2
}